202 lines
12 KiB
Rust
202 lines
12 KiB
Rust
// file: crates/ksp-app-raw-transaction-ingest-desk/src/lib.rs
|
|
// version: 8
|
|
|
|
//! Tauri desktop application scaffold for composing and supervising KSP live RAW transaction ingest routes.
|
|
|
|
#![forbid(unsafe_code)]
|
|
#![deny(unreachable_pub)]
|
|
#![warn(missing_docs)]
|
|
|
|
mod app_state;
|
|
mod bootstrap;
|
|
mod constants;
|
|
mod dto_common;
|
|
mod dto_route;
|
|
mod errors;
|
|
mod frontend_logging;
|
|
mod logging_runtime;
|
|
mod route_inventory;
|
|
mod route_monitoring;
|
|
mod route_runtime;
|
|
mod route_start;
|
|
mod splash;
|
|
mod tauri;
|
|
mod tw_main;
|
|
mod tw_splash;
|
|
|
|
/// Runs the KSP Raw Transaction Ingest desktop application.
|
|
pub use self::tauri::run;
|
|
|
|
/// Shared Raw Transaction Ingest Desk application state managed by Tauri.
|
|
pub(crate) use self::app_state::AppState;
|
|
/// Crate-internal Logging startup state shared by the application state.
|
|
pub(crate) use self::bootstrap::LoggingStartup;
|
|
/// Builds the Config management facade from the common KSP CLI bootstrap contract.
|
|
pub(crate) use self::bootstrap::config_management;
|
|
/// Initializes Logging from the Raw Transaction Ingest Desk composite with a bounded fallback.
|
|
pub(crate) use self::bootstrap::initialize_logging;
|
|
/// Loads the Raw Transaction Ingest Desk composite selected by its registered logical file identifier.
|
|
pub(crate) use self::bootstrap::load_raw_transaction_ingest_desk_composite;
|
|
/// Loads one explicit or default Raw Transaction Ingest Desk composite profile.
|
|
pub(crate) use self::bootstrap::load_raw_transaction_ingest_desk_composite_profile;
|
|
/// Resolves one required standard Config profile from the Raw Transaction Ingest Desk composite.
|
|
pub(crate) use self::bootstrap::required_composite_component_profile;
|
|
/// Composite-local identifier for the standard Logging component.
|
|
pub(crate) use self::constants::COMPOSITE_COMPONENT_ID_LOGGING;
|
|
/// Composite-local identifier for the standard Store component.
|
|
pub(crate) use self::constants::COMPOSITE_COMPONENT_ID_STORE;
|
|
/// Composite-local identifier for the standard Transport component.
|
|
pub(crate) use self::constants::COMPOSITE_COMPONENT_ID_TRANSPORT;
|
|
/// Composite-local optional Transport source for Helius WebSocket capabilities.
|
|
pub(crate) use self::constants::COMPOSITE_COMPONENT_ID_TRANSPORT_HELIUS;
|
|
/// Prefix used by optional same-network Transport capability sources.
|
|
pub(crate) use self::constants::COMPOSITE_COMPONENT_ID_TRANSPORT_PREFIX;
|
|
/// Composite-local optional Transport source for Yellowstone gRPC capabilities.
|
|
pub(crate) use self::constants::COMPOSITE_COMPONENT_ID_TRANSPORT_YELLOWSTONE;
|
|
/// Structured domain used while bootstrapping Config and Logging.
|
|
pub(crate) use self::constants::TRACING_DOMAIN_BOOTSTRAP;
|
|
/// Structured domain used by technical frontend events.
|
|
pub(crate) use self::constants::TRACING_DOMAIN_FRONTEND;
|
|
/// Structured domain used while rebuilding Config-only route inventory.
|
|
pub(crate) use self::constants::TRACING_DOMAIN_INVENTORY;
|
|
/// Structured domain used by multi-route shared-Store and Worker lifecycle operations.
|
|
pub(crate) use self::constants::TRACING_DOMAIN_ROUTE_RUNTIME;
|
|
/// Structured domain used while revalidating future Start requests.
|
|
pub(crate) use self::constants::TRACING_DOMAIN_ROUTE_START;
|
|
/// Structured domain used by the Raw Transaction Ingest Desk shell.
|
|
pub(crate) use self::constants::TRACING_DOMAIN_SHELL;
|
|
/// Structured domain used by Tauri window lifecycle operations.
|
|
pub(crate) use self::constants::TRACING_DOMAIN_WINDOWS;
|
|
/// Owning target for backend events emitted by Raw Transaction Ingest Desk.
|
|
pub(crate) use self::constants::TRACING_TARGET;
|
|
/// Owning target for generic frontend events emitted through the KSP bridge.
|
|
pub(crate) use self::constants::TRACING_TARGET_FRONTEND;
|
|
/// Owning target for main-window frontend events.
|
|
pub(crate) use self::constants::TRACING_TARGET_FRONTEND_MAIN;
|
|
/// Owning target for splash-window frontend events.
|
|
pub(crate) use self::constants::TRACING_TARGET_FRONTEND_SPLASH;
|
|
/// Safe command error projection exposed to Tauri commands.
|
|
pub(crate) use self::dto_common::CommandErrorDto;
|
|
/// Safe scaffold/runtime snapshot exposed to the shell.
|
|
pub(crate) use self::dto_common::ShellStatusDto;
|
|
/// Bounded confirmed/finalized commitment accepted by future route Start requests.
|
|
pub(crate) use self::dto_route::RawIngestCommitment;
|
|
/// Safe route inventory for one logical composite profile.
|
|
pub(crate) use self::dto_route::RawIngestProfileInventoryDto;
|
|
/// Safe Config-only composability projection for one logical route.
|
|
pub(crate) use self::dto_route::RawIngestRouteDto;
|
|
/// Stable application-owned route family.
|
|
pub(crate) use self::dto_route::RawIngestRouteFamily;
|
|
/// Static route/state foundation retained as the bounded vocabulary behind the Config inventory.
|
|
pub(crate) use self::dto_route::RawIngestRouteFoundationDto;
|
|
/// Stable logical V1 route identifiers owned by the Desk.
|
|
pub(crate) use self::dto_route::RawIngestRouteId;
|
|
/// Complete deterministic Config-only route inventory.
|
|
pub(crate) use self::dto_route::RawIngestRouteInventoryDto;
|
|
/// Safe per-route runtime acknowledgement containing only logical identity and lifecycle.
|
|
pub(crate) use self::dto_route::RawIngestRouteRuntimeDto;
|
|
/// Safe future Start request containing only logical route selection and inventory generation.
|
|
pub(crate) use self::dto_route::RawIngestRouteStartRequestDto;
|
|
/// Safe acknowledgement that exact Start-time resources were reconstructed without Worker launch.
|
|
pub(crate) use self::dto_route::RawIngestRouteStartValidationDto;
|
|
/// Stable route lifecycle states reserved for runtime projections.
|
|
pub(crate) use self::dto_route::RawIngestRouteState;
|
|
/// Safe targeted Stop request containing only logical route identity.
|
|
pub(crate) use self::dto_route::RawIngestRouteStopRequestDto;
|
|
/// Safe reason explaining why one logical route is not composable from Config.
|
|
pub(crate) use self::dto_route::RawIngestRouteUnavailableReason;
|
|
/// Shared Raw Transaction Ingest Desk application state is internally inconsistent.
|
|
pub(crate) use self::errors::ERROR_CODE_APP_STATE_INVALID;
|
|
/// Shared Raw Transaction Ingest Desk runtime state cannot be locked safely.
|
|
pub(crate) use self::errors::ERROR_CODE_APP_STATE_LOCK_FAILED;
|
|
/// Raw Transaction Ingest Desk Config composite is missing or invalid.
|
|
pub(crate) use self::errors::ERROR_CODE_CONFIG_COMPOSITE_INVALID;
|
|
/// Frontend logging requested an unsupported level.
|
|
pub(crate) use self::errors::ERROR_CODE_FRONTEND_LOG_LEVEL_INVALID;
|
|
/// Frontend logging payload exceeds the bounded technical IPC contract.
|
|
pub(crate) use self::errors::ERROR_CODE_FRONTEND_LOG_PAYLOAD_INVALID;
|
|
/// Frontend logging requested an unsupported target.
|
|
pub(crate) use self::errors::ERROR_CODE_FRONTEND_LOG_TARGET_INVALID;
|
|
/// Managed and fallback Logging initialization failed.
|
|
pub(crate) use self::errors::ERROR_CODE_LOGGING_BOOTSTRAP_FAILED;
|
|
/// Config-only route inventory cannot be projected safely.
|
|
pub(crate) use self::errors::ERROR_CODE_ROUTE_INVENTORY_INVALID;
|
|
/// Start/Stop IPC request contains an invalid logical shape.
|
|
pub(crate) use self::errors::ERROR_CODE_ROUTE_REQUEST_INVALID;
|
|
/// A Worker runtime already owns the same logical route in the shared application runtime.
|
|
pub(crate) use self::errors::ERROR_CODE_ROUTE_RUNTIME_ACTIVE;
|
|
/// Selected route cannot share the currently open Store because its network differs.
|
|
pub(crate) use self::errors::ERROR_CODE_ROUTE_RUNTIME_NETWORK_MISMATCH;
|
|
/// No selected route Worker runtime is currently active.
|
|
pub(crate) use self::errors::ERROR_CODE_ROUTE_RUNTIME_NOT_ACTIVE;
|
|
/// Application shutdown could not complete all bounded route/Store cleanup.
|
|
pub(crate) use self::errors::ERROR_CODE_ROUTE_RUNTIME_SHUTDOWN_FAILED;
|
|
/// Application shutdown has closed admission for new route Worker starts.
|
|
pub(crate) use self::errors::ERROR_CODE_ROUTE_RUNTIME_SHUTTING_DOWN;
|
|
/// Store or Worker startup failed after Start-time route revalidation.
|
|
pub(crate) use self::errors::ERROR_CODE_ROUTE_RUNTIME_START_FAILED;
|
|
/// The multi-route runtime reservation or handle state changed unexpectedly.
|
|
pub(crate) use self::errors::ERROR_CODE_ROUTE_RUNTIME_STATE_INVALID;
|
|
/// The opened Store did not prove Ready before Worker launch.
|
|
pub(crate) use self::errors::ERROR_CODE_ROUTE_RUNTIME_STORE_NOT_READY;
|
|
/// The Store could not be reclaimed or explicitly closed after Worker termination.
|
|
pub(crate) use self::errors::ERROR_CODE_ROUTE_RUNTIME_STORE_SHUTDOWN_FAILED;
|
|
/// Exact Start-time Transport resources cannot be reconstructed safely.
|
|
pub(crate) use self::errors::ERROR_CODE_ROUTE_START_PREPARATION_FAILED;
|
|
/// Start request references a stale inventory generation.
|
|
pub(crate) use self::errors::ERROR_CODE_ROUTE_START_STALE_INVENTORY;
|
|
/// Start request references a route that is no longer Configured/applicable.
|
|
pub(crate) use self::errors::ERROR_CODE_ROUTE_START_UNAVAILABLE;
|
|
/// Splash readiness originated from an invalid window.
|
|
pub(crate) use self::errors::ERROR_CODE_SPLASH_ORIGIN_INVALID;
|
|
/// Splash timing configuration is invalid.
|
|
pub(crate) use self::errors::ERROR_CODE_SPLASH_SETTING_INVALID;
|
|
/// Tauri runtime assembly or execution failed.
|
|
pub(crate) use self::errors::ERROR_CODE_TAURI_RUNTIME_FAILED;
|
|
/// A required Tauri window is missing.
|
|
pub(crate) use self::errors::ERROR_CODE_TAURI_WINDOW_MISSING;
|
|
/// A Tauri window operation failed.
|
|
pub(crate) use self::errors::ERROR_CODE_TAURI_WINDOW_OPERATION_FAILED;
|
|
/// Log payload sent by Raw Transaction Ingest Desk frontend scripts.
|
|
pub(crate) use self::frontend_logging::FrontendLogPayloadDto;
|
|
/// Emits one validated frontend event through the KSP Logging facade.
|
|
pub(crate) use self::frontend_logging::emit_frontend_log_event;
|
|
/// Creates the stable runtime identity for this Raw Transaction Ingest Desk process launch.
|
|
pub(crate) use self::logging_runtime::launch_identity;
|
|
/// Rebuilds the complete safe route inventory from validated Config without runtime I/O.
|
|
pub(crate) use self::route_inventory::build_route_inventory;
|
|
/// Rebuilds the route inventory from one already captured Config environment snapshot.
|
|
pub(crate) use self::route_inventory::build_route_inventory_with_environment;
|
|
/// Stable Tauri event carrying one complete latest-value route monitoring projection.
|
|
pub(crate) use self::route_monitoring::RAW_INGEST_ROUTE_STATUS_EVENT_NAME;
|
|
/// Frontend-safe bounded projection of one run-local continuity gap.
|
|
pub(crate) use self::route_monitoring::RawIngestRouteGapDto;
|
|
/// Frontend-safe latest-value monitoring projection of one independent route Worker.
|
|
pub(crate) use self::route_monitoring::RawIngestRouteMonitoringDto;
|
|
/// Projects one complete concrete Worker snapshot to the safe route monitoring contract.
|
|
pub(crate) use self::route_monitoring::project_route_monitoring;
|
|
/// Launch ownership for one independent route Worker sharing the application Store when eligible.
|
|
pub(crate) use self::route_runtime::RouteRuntimeLaunch;
|
|
/// Shared multi-route runtime state with one independent Worker per route and one same-network Store.
|
|
pub(crate) use self::route_runtime::RouteRuntimeState;
|
|
/// Opens Store and starts one exact route Worker after Start-time revalidation.
|
|
pub(crate) use self::route_runtime::start_route_runtime;
|
|
/// Fully revalidated Start preparation retaining Store settings and exact Worker resources.
|
|
pub(crate) use self::route_start::PreparedRouteStart;
|
|
/// Revalidates one Start request and retains its backend-only Store/Worker resources.
|
|
pub(crate) use self::route_start::prepare_route_start;
|
|
/// Revalidates one future Start request and reconstructs its exact Transport-owned Worker source contract without launch.
|
|
pub(crate) use self::route_start::validate_route_start;
|
|
/// Command emitted by Rust to the splash frontend.
|
|
pub(crate) use self::splash::SplashOrderDto;
|
|
/// Runtime timings used by the common desk splash lifecycle.
|
|
pub(crate) use self::splash::SplashSettings;
|
|
/// Resolves the required main window or returns a typed error.
|
|
pub(crate) use self::tw_main::require_main_window;
|
|
/// Shows and focuses the main Raw Transaction Ingest Desk window.
|
|
pub(crate) use self::tw_main::show_main_window;
|
|
/// Resolves the required splash window or returns a typed error.
|
|
pub(crate) use self::tw_splash::require_splash_window;
|
|
/// Starts the one-shot splash lifecycle after the splash frontend reports readiness.
|
|
pub(crate) use self::tw_splash::splash_frontend_ready_service;
|