Wind - Deep Dive

Wind is the frontend service layer in the Land project. It provides VSCode API compatibility through Effect-TS native implementations and a Tauri anti-corruption layer, enabling Sky’s VSCode-based UI components to communicate with the Mountain Rust backend.

Core Architecture 🏗️

Principle	Description	Key Components
High-Fidelity Emulation	VSCode renderer environment emulation so Sky reuses VSCode UI with minimal changes	`Preload.ts`, `Platform/VSCode/*`
Effect-TS Native	Entire service layer built with Effect-TS layer composition	All `Effect`-based modules
Anti-Corruption Layer	Clean abstraction over Tauri APIs, isolating platform specifics	`Integration/Tauri/Wrap/*`, `Preload.ts`
Declarative Service Composition	Effect-TS patterns for dependency injection and composable service construction	`Application/*`, `AppLayer`
Performance Optimization	Efficient bundling and API shimming	`Configuration/ESBuild/*`
Security Hardening	CSP and secure API boundaries for the Tauri webview	`Preload.ts` security patterns

Component Breakdown 🧩

Preload.ts (Environmental Foundation)

Executes in the Tauri webview before Sky loads. Reconstructs the window.vscode global object with:

ipcRenderer - Maps to Tauri’s event system (TauriEmit, TauriListen, TauriInvoke).
process - Provides an ISandboxNodeProcess-like object with platform, arch, env, and cwd().
Context resolution - Reads ISandboxConfiguration from meta tags injected by Mountain.
Security - CSP compliance and secure API boundary enforcement.

Integration/Tauri/ (Anti-Corruption Layer)

Effect Factories (Wrap/*) - Converts promise-based Tauri APIs to Effect operations.
Type Converters (Convert/*) - Pure functions for VSCode-to-Tauri type conversion.
Complex Resolvers (Resolve/*) - Multi-step operations with error handling and fallbacks.
Domain-Specific Errors (Error/*) - Precise error classes for Effect.catchTag handling.

Effect/Produce/ (Meta-Factories)

FromAsync - Transforms async functions into Effect-producing functions with proper error typing.
OptionalFromAsync - Variant for functions returning null/undefined, wrapping results in Option<T>.

Application/ (Core Frontend Services)

Tag-Based Dependency Injection - Uses Context.Tag for clean service management.
Orchestration Patterns - Multi-step Effects defining core business logic.
Layer Composition - Builds complete services from individual components.
Error Transformation - Converts integration-level errors to application-level types.

VSCode Environment Emulation 🖥️

Wind ensures API compatibility through:

Interface Matching - TypeScript definitions match all VSCode API interfaces.
Behavior Preservation - Sophisticated shimming and event mapping.
Error Handling Compatibility - Error types match VSCode expectations.
Asynchronous Semantics - Proper sequencing and error propagation.

Service Call Latency ⏱️

Layer	Time
VSCode API Shim	~0.02ms
Effect Orchestration	~0.05ms
Tauri Integration	~0.03ms
Total overhead	~0.10ms

Native execution time is variable and OS-dependent. Full-stack calls include Mountain backend processing and gRPC round-trips.

Security Architecture 🔒

Wind protects the Tauri webview through CSP enforcement, API boundary security, input validation at all boundaries, and error containment that prevents information leakage.

Platform Integration 🔗

Sky UI -[calls]-> Wind App Services -[orchestrates]-> Tauri Integration -[invokes]-> Mountain Track
  |                                                                             |
  +--[listens via Tauri events]---+                                             |
                                   +--> Environment Providers --> ApplicationState

Wind bridges the Sky UI component layer and the Mountain Rust backend, translating VSCode-style API calls into typed Tauri commands and returning results as Effect resolutions.