Mountain/Binary/Main/

Entry.rs

#![allow(unused_imports)]

//! # Entry (Binary/Main)
//!
//! ## RESPONSIBILITIES
//!
//! Main application entry point that orchestrates the complete application
//! lifecycle. This function coordinates:
//! - Tokio runtime creation and management
//! - CLI argument parsing
//! - Application state initialization
//! - Tauri application builder setup
//! - Service initialization (Vine, Cocoon, Configuration)
//! - Graceful shutdown handling
//!
//! ## ARCHITECTURAL ROLE
//!
//! The Entry module is the **primary entry point** in Mountain's architecture:
//!
//! ```text
//! main.rs ──► Binary::Main::Entry::Fn()
//!                                    │
//!                                    ▼
//! AppLifecycle ──► Service Initialization ──► Tauri App Run
//!                                           │
//!                                           ▼
//!                                   Graceful Shutdown
//! ```
//!
//! ## KEY COMPONENTS
//!
//! - **Fn()**: Main entry point exported as `Binary::Main::Fn()`
//! - Tokio runtime management
//! - Application state initialization via StateBuild
//! - Tauri builder configuration via TauriBuild
//! - Service orchestration (Vine, Cocoon, Configuration)
//! - Event-driven lifecycle management
//!
//! ## ERROR HANDLING
//!
//! - Panics on fatal errors (Tokio runtime failure, Tauri build failure)
//! - Logs errors for service initialization failures
//! - Graceful degradation for non-critical service failures
//!
//! ## LOGGING
//!
//! Uses the TraceStep! macro for checkpoint logging at TRACE level.
//! Additional logging at DEBUG, INFO, WARN, and ERROR levels throughout.
//!
//! ## PERFORMANCE CONSIDERATIONS
//!
//! - Tokio multi-threaded runtime for optimal performance
//! - Asynchronous service initialization
//! - Lazy initialization where possible
//!
//! ## TODO
//! - [ ] Add crash recovery mechanism
//! - [ ] Implement proper error dialog for startup failures
//! - [ ] Add startup performance metrics

use std::sync::{
	Arc,
	atomic::{AtomicBool, Ordering},
};

use tauri::{App, Manager, RunEvent, Wry};
use Echo::Scheduler::{Scheduler::Scheduler, SchedulerBuilder::SchedulerBuilder};

use crate::dev_log;
use crate::{
	// Crate root imports
	ApplicationState::State::ApplicationState::ApplicationState,
	Binary::Build::DnsCommands::{
		StartupTime::init_dns_startup_time,
		dns_get_forward_allowlist::dns_get_forward_allowlist,
		dns_get_health_status::dns_get_health_status,
		dns_get_server_info::dns_get_server_info,
		dns_get_zone_info::dns_get_zone_info,
		dns_health_check::dns_health_check,
		dns_resolve::dns_resolve,
		dns_test_resolution::dns_test_resolution,
	},
	// Binary submodule imports
	Binary::Build::LocalhostPlugin::LocalhostPlugin as LocalhostPluginFn,
	Binary::Build::LoggingPlugin::LoggingPlugin as LoggingPluginFn,
	Binary::Build::Scheme::{self, DnsPort, init_service_registry, land_scheme_handler, register_land_service},
	Binary::Build::ServiceRegistry::ServiceRegistry as ServiceRegistryFn,
	Binary::Build::TauriBuild::TauriBuild as TauriBuildFn,
	Binary::Build::WindowBuild::WindowBuild as WindowBuildFn,
	Binary::Extension::ExtensionPopulate::ExtensionPopulate as ExtensionPopulateFn,
	Binary::Extension::ScanPathConfigure::ScanPathConfigure as ScanPathConfigureFn,
	Binary::Initialize::CliParse::Parse as CliParseFn,
	Binary::Initialize::LogLevel::Resolve as ResolveLogLevel,
	Binary::Initialize::PortSelector::BuildUrl as BuildPortUrl,
	Binary::Initialize::PortSelector::Select as SelectPort,
	Binary::Initialize::StateBuild::Build as BuildStateFn,
	Binary::Register::AdvancedFeaturesRegister::AdvancedFeaturesRegister as AdvancedFeaturesRegisterFn,
	Binary::Register::CommandRegister::CommandRegister as CommandRegisterFn,
	Binary::Register::IPCServerRegister::IPCServerRegister as IPCServerRegisterFn,
	Binary::Register::StatusReporterRegister::StatusReporterRegister as StatusReporterRegisterFn,
	Binary::Register::WindSyncRegister::WindSyncRegister as WindSyncRegisterFn,
	Binary::Service::CocoonStart::CocoonStart as CocoonStartFn,
	Binary::Service::ConfigurationInitialize::ConfigurationInitialize as ConfigurationInitializeFn,
	Binary::Service::VineStart::VineStart as VineStartFn,
	Binary::Shutdown::RuntimeShutdown::RuntimeShutdown as RuntimeShutdownFn,
	Binary::Shutdown::SchedulerShutdown::SchedulerShutdown as SchedulerShutdownFn,
	Command,
	Environment::MountainEnvironment::MountainEnvironment,
	ProcessManagement::InitializationData,
	RunTime::ApplicationRunTime::ApplicationRunTime,
	Track,
};
use super::AppLifecycle::AppLifecycleSetup;

// Note: Tauri commands are used with fully qualified paths in generate_handler
// because the __cmd_* macros generated by #[tauri::command] are module-local.

/// Logs a checkpoint message at TRACE level.
macro_rules! TraceStep {

	($($arg:tt)*) => {{

		dev_log!("lifecycle", $($arg)*);
	}};
}

/// The main function that orchestrates the application lifecycle.
///
/// This function:
/// 1. Creates a Tokio runtime
/// 2. Parses CLI arguments
/// 3. Builds application state
/// 4. Creates a scheduler
/// 5. Selects a port for the local server
/// 6. Resolves the log level
/// 7. Sets up the Tauri builder
/// 8. Configures the application lifecycle
/// 9. Runs the Tauri application
/// 10. Handles graceful shutdown
pub fn Fn() {
	// Initialize the native keyring store (Keychain on macOS) before any
	// code path that calls SecretProvider. keyring-core 1.0 requires an
	// explicit store set via set_default_store() before Entry::new() can
	// create or look up credentials. omitting this causes "No default
	// store has been set, so cannot search or create entries" on every
	// secrets.get call, which in turn prevents extensions (e.g. Roo Code)
	// from completing their webview initialisation.
	//
	// The `not_keyutils` parameter only matters on Linux - macOS ignores
	// it and always routes to the native Keychain.
	match keyring::use_native_store(false) {
		Ok(()) => dev_log!("lifecycle", "[Boot] [Keyring] Native store initialized for secret management"),
		Err(E) => {
			dev_log!(
				"lifecycle",
				"warn: [Boot] [Keyring] Failed to initialize native store ({}); secret operations will fall back to \
				 no-op",
				E
			)
		},
	}

	// Open `Mountain.dev.log` up front. Forces `InitFileSink` to create
	// the session log header on disk before any other code can panic, so
	// an early crash still leaves a file with a timestamp + pid + tag
	// context for post-mortem. Env vars are read from the shell here (the
	// `.env.Land` load below may add MORE keys but never overrides
	// Trace / Record because `set_var` only runs when a
	// key is currently unset). Harmless to call: the inner `OnceLock`
	// gates repeat invocations.
	crate::IPC::DevLog::InitEager::Fn();

	// -------------------------------------------------------------------------
	// [Boot] [Env] Enhance the process environment with the user's
	// interactive-shell PATH / NVM_DIR / HOMEBREW_PREFIX / JAVA_HOME / …
	// before any child process is spawned. macOS GUI launches (Finder,
	// Dock, Spotlight, `open <bundle>.app`) start the app with a minimal
	// env where Homebrew, NVM, and similar are not on PATH; without this
	// step the Cocoon node binary, language servers, and `git` calls
	// from extensions all fall back to system defaults (or fail).
	//
	// Skip entirely when launched from a TTY (terminal already has the
	// right env). On macOS, `std::io::stdin().is_terminal()` is the
	// canonical check - waits for is-terminal 0.5; in the interim,
	// probe `TERM_PROGRAM` env var which macOS Terminal.app and iTerm2
	// both set. `TERM=xterm-256color` alone is unreliable (pipelines
	// set it too). No-op when skip or the shell probe fails/times out.
	// -------------------------------------------------------------------------
	let IsTtyLaunch =
		std::env::var("TERM_PROGRAM").is_ok() || std::env::var("TERM").map_or(false, |V| V != "dumb" && V != "unknown");

	if !IsTtyLaunch {
		crate::Environment::Utility::EnhanceShellEnvironment::Fn();
	}

	// -------------------------------------------------------------------------
	// [Boot] [Env] Load .env.Land into process env so standalone binary
	// invocations pick up Product*, Tier*, Network* vars without requiring
	// the shell to pre-source the env file. Skip when launched from a TTY
	// (terminal already has the right env).
	// -------------------------------------------------------------------------
	if !IsTtyLaunch {
		{
			fn LoadEnvFile(Path:&std::path::Path) -> bool {
				let Ok(Content) = std::fs::read_to_string(Path) else {
					return false;
				};

				for Line in Content.lines() {
					let Trimmed = Line.trim();

					if Trimmed.is_empty() || Trimmed.starts_with('#') {
						continue;
					}

					if let Some((Key, Value)) = Trimmed.split_once('=') {
						let CleanKey = Key.trim();

						let CleanValue = Value.trim().trim_matches('"').trim_matches('\'');

						if std::env::var_os(CleanKey).is_none() {
							// SAFETY: set_var is called once per key during bootstrap
							// before any threads read env (Tokio runtime starts later
							// in this function).
							unsafe { std::env::set_var(CleanKey, CleanValue) };
						}
					}
				}

				true
			}

			let mut Candidates:Vec<std::path::PathBuf> = Vec::new();

			if let Ok(Cwd) = std::env::current_dir() {
				Candidates.push(Cwd.join(".env.Land"));

				if let Some(Parent) = Cwd.parent() {
					Candidates.push(Parent.join(".env.Land"));
				}

				Candidates.push(Cwd.join(".env.Land.Sample"));

				if let Some(Parent) = Cwd.parent() {
					Candidates.push(Parent.join(".env.Land.Sample"));
				}
			}

			// Repo-layout probe: Target/debug/<bin> → four hops up lands at Land/.
			if let Ok(Exe) = std::env::current_exe() {
				let Ancestors:Vec<&std::path::Path> = Exe.ancestors().collect();

				for Candidate in Ancestors.iter().take(6) {
					Candidates.push(Candidate.join(".env.Land"));

					Candidates.push(Candidate.join(".env.Land.Sample"));
				}
			}

			let mut Loaded = false;

			for Candidate in Candidates {
				if Candidate.exists() && LoadEnvFile(&Candidate) {
					crate::dev_log!("lifecycle", "[Boot] [Env] Loaded env from {}", Candidate.display());

					Loaded = true;

					break;
				}
			}

			if !Loaded {
				crate::dev_log!(
					"lifecycle",
					"[Boot] [Env] No .env.Land / .env.Land.Sample found - using defaults"
				);
			}
		}
	}

	// -------------------------------------------------------------------------
	// [Boot] [Tier] Resolved tier banner (Plan A Wave 1.7 runtime banner)
	// -------------------------------------------------------------------------
	crate::LandFixTier::LogResolvedTiers();

	// -------------------------------------------------------------------------
	// [Boot] [Profile] Self-report (BATCH-13 step 6)
	//
	// Build.sh exports `Browser`/`Mountain`/`Electron`/`Bundle`/`Compiler`/
	// `Profile` into the shell that invokes cargo. `build.rs` captures
	// those into `cargo:rustc-env=LAND_*` so they're baked into the binary -
	// runtime env lookups don't survive launching the binary from Finder /
	// another shell. `option_env!` falls back to "unknown" when the build
	// ran outside Build.sh (e.g. plain `cargo build`).
	// -------------------------------------------------------------------------
	{
		let NamedProfile = option_env!("Profile").unwrap_or("unknown");

		let Workbench = option_env!("Pack").unwrap_or("Unknown");

		let Bundle = option_env!("Bundle").unwrap_or("");

		let Compiler = option_env!("Compiler").unwrap_or("default");

		dev_log!(
			"lifecycle",
			"[LandFix:Profile] Active profile={} workbench={} bundle={} compiler={}",
			NamedProfile,
			Workbench,
			Bundle,
			Compiler
		);
	}

	// -------------------------------------------------------------------------
	// [Boot] [Runtime] Tokio runtime creation
	// -------------------------------------------------------------------------
	TraceStep!("[Boot] [Runtime] Building Tokio runtime...");

	let Runtime = tokio::runtime::Builder::new_multi_thread()
		.enable_all()
		.build()
		.expect("FATAL: Cannot build Tokio runtime.");

	TraceStep!("[Boot] [Runtime] Tokio runtime built.");

	Runtime.block_on(async {
		// ---------------------------------------------------------------------
		// [Boot] [Telemetry] Hydrate runtime env from compile-baked
		// Constants so spawned children (Cocoon Node, Sky webview)
		// see the same telemetry config Mountain itself was built
		// with - even when the user invokes the bare binary without
		// sourcing `.env.Land.PostHog`. Idempotent + debug-only.
		// Must run BEFORE PostHogPlugin::Initialize so the client
		// reads the same effective env as the children.
		// ---------------------------------------------------------------------
		crate::Binary::Build::PostHogPlugin::HydrateRuntimeEnvironment::Fn();

		// ---------------------------------------------------------------------
		// [Boot] [PostHog] Initialize telemetry client first so any
		// error captured during the rest of boot lands in the project.
		// No-op in release builds or when Report=false.
		// ---------------------------------------------------------------------
		crate::Binary::Build::PostHogPlugin::Initialize::Fn().await;

		// ---------------------------------------------------------------------
		// [Boot] [Common::Telemetry] Initialize the shared dual-pipe
		// stack so library crates linked into Mountain (Echo, Mist,
		// Common) emit through the same client. The HydrateRuntime
		// Environment step above populated the env so this picks up
		// the same Authorize/Beam/Capture values Mountain's plugin
		// already loaded. Idempotent.
		// ---------------------------------------------------------------------
		CommonLibrary::Telemetry::Initialize::Fn(CommonLibrary::Telemetry::Tier::Tier::Mountain).await;

		// ---------------------------------------------------------------------
		// [Boot] [Args] CLI parsing (using CliParse module)
		// ---------------------------------------------------------------------
		let _WorkspaceConfigurationPath = CliParseFn();
		let _InitialFolders:Vec<String> = vec![];

		// ---------------------------------------------------------------------
		// [Boot] [State] ApplicationState (using StateBuild module)
		// ---------------------------------------------------------------------
		dev_log!("lifecycle", "[Boot] [State] Building ApplicationState...");

		// Create application state directly (StateBuild::Build with default config)
		let AppState = ApplicationState::default();

		// -------------------------------------------------------------------
		// [Boot] [Workspace] Seed initial workspace folders so every extension
		// that calls `vscode.workspace.findFiles(...)` at activation has
		// something to walk. Precedence: --folder flags → positional dirs →
		// Open env → CWD fallback. See
		// CliParse::ParseWorkspaceFolders.
		// -------------------------------------------------------------------
		{
			let InitialFolderPaths = crate::Binary::Initialize::CliParse::ParseWorkspaceFolders();
			if InitialFolderPaths.is_empty() {
				dev_log!(
					"lifecycle",
					"[Boot] [Workspace] No initial folders resolved - editor will open in \"no folder\" mode."
				);
			} else {
				use crate::ApplicationState::DTO::WorkspaceFolderStateDTO::WorkspaceFolderStateDTO;
				let mut Folders:Vec<WorkspaceFolderStateDTO> = Vec::new();
				for (Index, Path) in InitialFolderPaths.iter().enumerate() {
					let Uri = match url::Url::from_directory_path(Path) {
						Ok(U) => U,
						Err(()) => {
							dev_log!(
								"lifecycle",
								"warn: [Boot] [Workspace] Failed to build URL for {}; skipping",
								Path.display()
							);
							continue;
						},
					};
					let Name = Path
						.file_name()
						.and_then(|N| N.to_str())
						.map(str::to_string)
						.unwrap_or_else(|| Path.display().to_string());
					match WorkspaceFolderStateDTO::New(Uri, Name, Index) {
						Ok(Dto) => Folders.push(Dto),
						Err(Error) => {
							dev_log!(
								"lifecycle",
								"warn: [Boot] [Workspace] Failed to build folder DTO for {}: {}",
								Path.display(),
								Error
							);
						},
					}
				}
				if !Folders.is_empty() {
					// Seed state directly; Cocoon is not yet spawned at this
					// point, so there is no sidecar to notify. The initial
					// workspace makes it to Cocoon via `InitializeExtensionHost`'s
					// `workspace` payload during its handshake instead.
					AppState.Workspace.SetWorkspaceFolders(Folders);
					dev_log!(
						"lifecycle",
						"[Boot] [Workspace] Seeded {} workspace folder(s).",
						InitialFolderPaths.len()
					);
				}
			}
		}

		dev_log!(
			"lifecycle",
			"[Boot] [State] ApplicationState created with {} workspace folders.",
			AppState.Workspace.WorkspaceFolders.lock().map(|f| f.len()).unwrap_or(0)
		);

		// Create Arc for application state to be managed by Tauri
		let AppStateArcForClosure = Arc::new(AppState.clone());

		// ---------------------------------------------------------------------
		// [Boot] [Runtime] Scheduler handles (using RuntimeBuild module)
		// ---------------------------------------------------------------------
		let Scheduler = Arc::new(SchedulerBuilder::Create().Build());
		let SchedulerForClosure = Scheduler.clone();
		TraceStep!("[Boot] [Echo] Scheduler handles prepared.");

		// ---------------------------------------------------------------------
		// [Boot] [Localhost] Port selection (using PortSelector module)
		// ---------------------------------------------------------------------
		let ServerPort = SelectPort();
		let LocalhostUrl = BuildPortUrl(ServerPort);

		// ---------------------------------------------------------------------
		// [Boot] [Logging] Log level resolution (using LogLevel module)
		// ---------------------------------------------------------------------
		let log_level = ResolveLogLevel();

		// ---------------------------------------------------------------------
		// [Boot] [Tauri] Builder setup (using TauriBuild module)
		// ---------------------------------------------------------------------
		let Builder = TauriBuildFn();

		Builder
			.plugin(LoggingPluginFn(log_level))
			.plugin(LocalhostPluginFn(ServerPort))
			.manage(AppStateArcForClosure.clone())
			.setup({
				let LocalhostUrl = LocalhostUrl.clone();
				let ServerPortForClosure = ServerPort;
				move |app:&mut App| {
					dev_log!("lifecycle", "[Lifecycle] [Setup] Setup hook started.");
					dev_log!("lifecycle", "[Lifecycle] [Setup] LocalhostUrl={}", LocalhostUrl);

					// ---------------------------------------------------------
					// [Service Registry] Initialize service registry for land:// routing
					// ---------------------------------------------------------
					dev_log!(
						"lifecycle",
						"[Lifecycle] [Setup] Initializing ServiceRegistry for land:// scheme..."
					);
					let service_registry = ServiceRegistryFn::new();
					init_service_registry(service_registry.clone());

					// ---------------------------------------------------------
					// [Service Registry] Register local HTTP services
					// ---------------------------------------------------------
					// Register the main code editor service
					dev_log!(
						"lifecycle",
						"[Lifecycle] [Setup] Registering code.editor.land service on port {}",
						ServerPortForClosure
					);
					register_land_service("code.editor.land", ServerPortForClosure);

					// Register API editor service (same port for now, can be separate later)
					register_land_service("api.editor.land", ServerPortForClosure);

					// Register assets editor service (same port for now, can be separate later)
					register_land_service("assets.editor.land", ServerPortForClosure);

					// Make the registry available as managed state for Tauri commands
					app.manage(service_registry);
					dev_log!(
						"lifecycle",
						"[Lifecycle] [Setup] ServiceRegistry initialized and services registered."
					);

					// ---------------------------------------------------------
					// [DNS Server] Start the Hickory DNS server
					// ---------------------------------------------------------
					// The DNS server must start BEFORE any webview loads to ensure
					// that land:// protocol_resolution is available
					dev_log!("lifecycle", "[Lifecycle] [Setup] Starting DNS server on preferred port 5380...");
					let dns_port = Mist::start(5380).unwrap_or_else(|e| {
						dev_log!(
							"lifecycle",
							"warn: [Lifecycle] [Setup] Failed to start DNS server on port 5380: {}",
							e
						);
						// Fallback to random port if preferred port fails
						Mist::start(0).unwrap_or_else(|e| {
							dev_log!(
								"lifecycle",
								"error: [Lifecycle] [Setup] Completely failed to start DNS server: {}",
								e
							);
							0 // Return 0 as error indicator
						})
					});

					if dns_port == 0 {
						dev_log!(
							"lifecycle",
							"warn: [Lifecycle] [Setup] DNS server failed to start, land:// protocol will not be \
							 available"
						);
					} else {
						dev_log!(
							"lifecycle",
							"[Lifecycle] [Setup] DNS server started successfully on port {}",
							dns_port
						);
						// Initialize DNS startup time for tracking
						crate::Binary::Build::DnsCommands::StartupTime::init_dns_startup_time();
					}

					// Register DnsPort as managed state for Tauri commands
					app.manage(DnsPort(dns_port));

					let AppHandle = app.handle().clone();
					TraceStep!("[Lifecycle] [Setup] AppHandle acquired.");

					// ---------------------------------------------------------
					// Setup application lifecycle through AppLifecycle module
					// ---------------------------------------------------------
					let AppStateArcFromClosure = AppStateArcForClosure.clone();

					if let Err(e) = AppLifecycleSetup(
						app,
						AppHandle.clone(),
						LocalhostUrl.clone(),
						SchedulerForClosure.clone(),
						AppStateArcFromClosure,
					) {
						dev_log!("lifecycle", "error: [Lifecycle] [Setup] Failed to setup lifecycle: {}", e);
					}

					Ok(())
				}
			})
			.register_asynchronous_uri_scheme_protocol("land", |_ctx, request, responder| {
				// Implemented: delegate to synchronous scheme handler
				let response = crate::Binary::Build::Scheme::land_scheme_handler(&request);
				responder.respond(response);
			})
			.register_asynchronous_uri_scheme_protocol("vscode-file", |ctx, request, responder| {
				// VS Code Electron workbench uses vscode-file:// to load assets.
				// Maps to embedded frontend assets from Sky/Target.
				let AppHandle = ctx.app_handle().clone();
				std::thread::spawn(move || {
					let response = crate::Binary::Build::Scheme::VscodeFileSchemeHandler(&AppHandle, &request);
					responder.respond(response);
				});
			})
			.register_asynchronous_uri_scheme_protocol("vscode-webview", |ctx, request, responder| {
				// VS Code's `WebviewElement` wraps every extension webview in
				// an iframe whose `src` is `vscode-webview://<authority>/index.html?...`.
				// Without this handler the iframe stays blank and every
				// extension that uses `webviewView` / `WebviewPanel` /
				// `CustomEditor` (Roo Code, Claude, GitLens, custom editors)
				// is dead. The handler serves the three-file `pre/`
				// directory (`index.html`, `service-worker.js`, `fake.html`);
				// extension HTML itself comes through later via the workbench's
				// `swMessage` postMessage channel, not this scheme.
				let AppHandle = ctx.app_handle().clone();
				std::thread::spawn(move || {
					let response = crate::Binary::Build::Scheme::VscodeWebviewSchemeHandler(&AppHandle, &request);
					responder.respond(response);
				});
			})
			.register_asynchronous_uri_scheme_protocol("vscode-webview-resource", |ctx, request, responder| {
				// `vscode-webview-resource://<auth>/<path>` is the URI shape
				// stock VS Code emits from `webview.asWebviewUri(...)`. The
				// service worker inside `pre/index.html` would normally
				// intercept these and proxy through the host. Land disables
				// that SW (see Output `PatchWebviewIframeServiceWorker`)
				// because WKWebView refuses SW registration on the
				// `vscode-webview://` custom protocol; instead we register
				// this scheme directly so any extension that hard-codes
				// the URI form (or didn't go through Cocoon's `asWebviewUri`
				// rewrite) still resolves. Strip the `<auth>` and forward
				// the path to `VscodeFileSchemeHandler` by rewriting the
				// URI to `vscode-file://vscode-app/<path>`.
				let AppHandle = ctx.app_handle().clone();
				std::thread::spawn(move || {
					let Original = request.uri().to_string();
					let RewrittenUri = match Original.strip_prefix("vscode-webview-resource://") {
						Some(After) => {
							let Rest = After.find('/').map(|I| &After[I..]).unwrap_or("/");
							format!("vscode-file://vscode-app{}", Rest)
						},
						None => "vscode-file://vscode-app/".to_string(),
					};
					crate::dev_log!(
						"scheme-assets",
						"[LandFix:VscodeWebviewResource] {} -> {}",
						Original,
						RewrittenUri
					);
					let mut Builder = tauri::http::request::Request::builder().uri(&RewrittenUri);
					for (Name, Value) in request.headers().iter() {
						Builder = Builder.header(Name, Value);
					}
					let Forwarded = Builder
						.method(request.method().clone())
						.body(request.body().clone())
						.unwrap_or_else(|_| request.clone());
					let response = crate::Binary::Build::Scheme::VscodeFileSchemeHandler(&AppHandle, &Forwarded);
					responder.respond(response);
				});
			})
			.register_asynchronous_uri_scheme_protocol("vscode-resource", |ctx, request, responder| {
				// Legacy stock-VS Code resource scheme. Same handling as
				// `vscode-webview-resource` - rewrite to `vscode-file://`
				// and dispatch through the existing file handler.
				let AppHandle = ctx.app_handle().clone();
				std::thread::spawn(move || {
					let Original = request.uri().to_string();
					let RewrittenUri = match Original.strip_prefix("vscode-resource://") {
						Some(After) => {
							let Rest = After.find('/').map(|I| &After[I..]).unwrap_or("/");
							format!("vscode-file://vscode-app{}", Rest)
						},
						None => "vscode-file://vscode-app/".to_string(),
					};
					crate::dev_log!("scheme-assets", "[LandFix:VscodeResource] {} -> {}", Original, RewrittenUri);
					let mut Builder = tauri::http::request::Request::builder().uri(&RewrittenUri);
					for (Name, Value) in request.headers().iter() {
						Builder = Builder.header(Name, Value);
					}
					let Forwarded = Builder
						.method(request.method().clone())
						.body(request.body().clone())
						.unwrap_or_else(|_| request.clone());
					let response = crate::Binary::Build::Scheme::VscodeFileSchemeHandler(&AppHandle, &Forwarded);
					responder.respond(response);
				});
			})
			.plugin(tauri_plugin_dialog::init())
			.plugin(tauri_plugin_fs::init())
			.invoke_handler(tauri::generate_handler![
				crate::Binary::Tray::SwitchTrayIcon::SwitchTrayIcon,

				crate::Binary::IPC::WorkbenchConfigurationCommand::MountainGetWorkbenchConfiguration,

				Command::TreeView::GetTreeViewChildren::GetTreeViewChildren,

				Command::LanguageFeature::MountainProvideHover::MountainProvideHover,

				Command::LanguageFeature::MountainProvideCompletions::MountainProvideCompletions,

				Command::LanguageFeature::MountainProvideDefinition::MountainProvideDefinition,

				Command::LanguageFeature::MountainProvideReferences::MountainProvideReferences,

				Command::SourceControlManagement::GetAllSourceControlManagementState::GetAllSourceControlManagementState,

				Command::Keybinding::GetResolvedKeybinding::GetResolvedKeybinding,

				Track::FrontendCommand::DispatchFrontendCommand::DispatchFrontendCommand,

				Track::UIRequest::ResolveUIRequest::ResolveUIRequest,

				Track::Webview::MountainWebviewPostMessageFromGuest::MountainWebviewPostMessageFromGuest,

				crate::Binary::IPC::MessageReceiveCommand::MountainIPCReceiveMessage,

				crate::Binary::IPC::StatusGetCommand::MountainIPCGetStatus,

				crate::Binary::IPC::InvokeCommand::MountainIPCInvoke,

				crate::Binary::IPC::WindConfigurationCommand::MountainGetWindDesktopConfiguration,

				crate::Binary::IPC::ConfigurationUpdateCommand::MountainUpdateConfigurationFromWind,

				crate::Binary::IPC::ConfigurationSyncCommand::MountainSynchronizeConfiguration,

				crate::Binary::IPC::ConfigurationStatusCommand::MountainGetConfigurationStatus,

				crate::Binary::IPC::IPCStatusCommand::MountainGetIPCStatus,

				crate::Binary::IPC::IPCStatusHistoryCommand::MountainGetIPCStatusHistory,

				crate::Binary::IPC::IPCStatusReportingStartCommand::MountainStartIPCStatusReporting,

				crate::Binary::IPC::PerformanceStatsCommand::MountainGetPerformanceStats,

				crate::Binary::IPC::CacheStatsCommand::MountainGetCacheStats,

				crate::Binary::IPC::CollaborationSessionCommand::MountainCreateCollaborationSession,

				crate::Binary::IPC::CollaborationSessionCommand::MountainGetCollaborationSessions,

				crate::Binary::IPC::DocumentSyncCommand::MountainAddDocumentForSync,

				crate::Binary::IPC::DocumentSyncCommand::MountainGetSyncStatus,

				crate::Binary::IPC::UpdateSubscriptionCommand::MountainSubscribeToUpdates,

				crate::Binary::IPC::ConfigurationDataCommand::GetConfigurationData,

				crate::Binary::IPC::ConfigurationDataCommand::SaveConfigurationData,

				crate::Binary::IPC::WorkspaceFolderCommand::MountainWorkspaceOpenFolder,

				crate::Binary::IPC::WorkspaceFolderCommand::MountainWorkspaceListFolders,

				crate::Binary::IPC::WorkspaceFolderCommand::MountainWorkspaceCloseAllFolders,

				crate::Binary::Build::DnsCommands::dns_get_server_info::dns_get_server_info,

				crate::Binary::Build::DnsCommands::dns_get_zone_info::dns_get_zone_info,

				crate::Binary::Build::DnsCommands::dns_get_forward_allowlist::dns_get_forward_allowlist,

				crate::Binary::Build::DnsCommands::dns_get_health_status::dns_get_health_status,

				crate::Binary::Build::DnsCommands::dns_resolve::dns_resolve,

				crate::Binary::Build::DnsCommands::dns_test_resolution::dns_test_resolution,

				crate::Binary::Build::DnsCommands::dns_health_check::dns_health_check,

				// Process commands (direct Tauri invoke from ProcessPolyfill)
				crate::Binary::IPC::ProcessCommand::process_get_exec_path::process_get_exec_path,

				crate::Binary::IPC::ProcessCommand::process_get_platform::process_get_platform,

				crate::Binary::IPC::ProcessCommand::process_get_arch::process_get_arch,

				crate::Binary::IPC::ProcessCommand::process_get_pid::process_get_pid,

				crate::Binary::IPC::ProcessCommand::process_get_shell_env::process_get_shell_env,

				crate::Binary::IPC::ProcessCommand::process_get_memory_info::process_get_memory_info,

				// Health check commands (direct Tauri invoke from SharedProcessProxy)
				crate::Binary::IPC::HealthCommand::cocoon_extension_host_health::cocoon_extension_host_health,

				crate::Binary::IPC::HealthCommand::cocoon_search_service_health::cocoon_search_service_health,

				crate::Binary::IPC::HealthCommand::cocoon_debug_service_health::cocoon_debug_service_health,

				crate::Binary::IPC::HealthCommand::shared_process_service_health::shared_process_service_health,

				crate::Binary::IPC::RenderDevLogCommand::RenderDevLog,

				// LAND-PATCH B7-S6 P14.5: Vine notification broadcast
				// subscription. `vine_subscribe_notifications` opens a
				// Tauri Channel that drains the process-wide
				// `Vine::Client` broadcast into the webview; Effect-TS
				// `VineNotificationsLive` Layer wraps it as a
				// `Stream<NotificationFrame>`. `vine_subscriber_count`
				// is a diagnostic for verifying registrations didn't
				// leak across reloads.
				crate::Binary::IPC::VineSubscribeCommand::vine_subscribe_notifications,

				crate::Binary::IPC::VineSubscribeCommand::vine_subscriber_count,
			])
			.build(tauri::generate_context!())
			.expect("FATAL: Error while building Mountain Tauri application")
			.run(move |app_handle:&tauri::AppHandle, event:tauri::RunEvent| {
				// Debug-only: log selected lifecycle events
				if cfg!(debug_assertions) {
					match &event {
						RunEvent::MainEventsCleared => {},
						RunEvent::WindowEvent { .. } => {},
						_ => dev_log!("lifecycle", "[Lifecycle] [RunEvent] {:?}", event),
					}
				}

				if let RunEvent::ExitRequested { api, .. } = event {
					// Shutdown runs once. The graceful path ends with
					// `app_handle.exit(0)`, which Tauri re-delivers as a
					// second `ExitRequested { code: Some(0) }`. On re-entry
					// we must NOT `prevent_exit` or spawn the shutdown task
					// again - Cocoon has already been SIGKILLed and the
					// second pass would log spurious "tcp connect error"
					// warnings trying to notify a dead sidecar.
					static SHUTTING_DOWN:AtomicBool = AtomicBool::new(false);
					if SHUTTING_DOWN.swap(true, Ordering::SeqCst) {
						return;
					}

					dev_log!(
						"lifecycle",
						"warn: [Lifecycle] [Shutdown] Exit requested. Starting graceful shutdown..."
					);
					api.prevent_exit();

					let SchedulerHandle = Scheduler.clone();
					let app_handle_clone = app_handle.clone();

					tokio::spawn(async move {
						dev_log!("lifecycle", "[Lifecycle] [Shutdown] Shutting down ApplicationRunTime...");
						let _ = RuntimeShutdownFn(&app_handle_clone).await;

						dev_log!("lifecycle", "[Lifecycle] [Shutdown] Stopping Echo scheduler...");
						let _ = SchedulerShutdownFn(SchedulerHandle).await;

						dev_log!("lifecycle", "[Lifecycle] [Shutdown] Done. Exiting process.");
						app_handle_clone.exit(0);
					});
				}
			});

		dev_log!("lifecycle", "[Lifecycle] [Exit] Mountain application has shut down.");
	});
}