feat(WebSite): Add 21 new documentation pages with hierarchical sidebar navigation

Add comprehensive documentation for all 15 Land elements (Air, Cocoon, Common, Echo, Grove, Maintain, Mist, Mountain, Output, Rest, SideCar, Sky, Vine, Wind, Worker) and 6 technology rationale articles (Why CC0, Why Effect-TS, Why gRPC, Why Rust, Why Tauri, Why WebAssembly). Each doc page follows a problem-solution narrative explaining what pain point the element or technology solves.

Update DynamicDocSidebar.tsx to link to dedicated /Doc/{slug} pages instead of anchor links (#SectionId). Group all documentation pages by section (Start, Architecture, Usage, Development, Community, Support, Element, Technology, License) for hierarchical sidebar navigation. Update Doc.astro and Doc/[Slug].astro to render grouped sections and link to individual pages.

Sync homepage copy in HomePage.tsx and Home.json: rewrite hero subtitle, CTA buttons, feature titles/descriptions, roadmap tiers, and download section. All 21 doc pages and supporting files are staged.

Author: NikolaRHristov

Source/Component/Dynamic/DynamicDocSidebar.tsx

@@ -59,7 +59,7 @@ const DynamicDocSidebar = ({
 												return (
 													<li key={Child.Id}>
 														<a
-															href={`#${Child.Id}`}
+															href={`/Doc/${Child.Id}`}
 															aria-current={
 																IsChildActive
 																	? "page"
@@ -85,7 +85,7 @@ const DynamicDocSidebar = ({
 					return (
 						<li key={Section.Id}>
 							<a
-								href={`#${Section.Id}`}
+								href={`/Doc/${Section.Id}`}
 								aria-current={IsActive ? "page" : undefined}
 								className={`block px-3 py-2 text-sm transition-colors hover:bg-[var(--ColorSecondary)] focus:outline-2 focus:outline-offset-2 focus:outline-[var(--ColorPrimary)] ${
 									IsActive

Source/Component/Dynamic/HomePage.tsx

@@ -0,0 +1,33 @@
+---
+title: "Air"
+section: "Element"
+order: 15
+description: "The background daemon that pre-stages updates and eliminates cold starts"
+---
+
+# Air
+
+## The Problem Air Solves
+
+VS Code cold-starts slowly because everything initializes fresh each launch: extension host, language servers, file index. Updates require a full restart that kills open terminals and in-progress work. There is no mechanism to pre-stage work between sessions.
+
+## How Air Eliminates It
+
+Air is a persistent background daemon (like macOS Spotlight or Windows Search Indexer) that keeps running after you close the editor. It pre-downloads and PGP-verifies the next update between sessions. It pre-indexes workspace changes that happened while the editor was closed. It keeps language server warm caches available for instant load.
+
+When you launch Land, Air has already done the expensive work. The update was staged, verified, and ready.
+
+## What You Experience
+
+Cold start times under 200 ms. Updates apply between sessions with no interruption. You never see a workspace that "hasn't loaded yet." The next version is already downloaded and verified before you decide to update.
+
+## Key Technologies
+
+Air is written in Rust and communicates with Mountain through Vine's gRPC protocol. PGP signature verification ensures update integrity.
+
+## See Also
+
+- [Architecture Overview](/Doc/architecture)
+- [Mountain: Native Backend](/Doc/mountain)
+- [Local-First Protocol](/Doc/local-first-protocol)
+- [Source Code](https://github.com/CodeEditorLand/Air)

Source/Content/doc/air.md

@@ -0,0 +1,35 @@
+---
+title: "Cocoon"
+section: "Element"
+order: 12
+description: "The extension host that runs every VS Code extension unchanged on Effect-TS fibers"
+---
+
+# Cocoon
+
+## The Problem Cocoon Solves
+
+VS Code's extension host is a single Node.js process. One extension's activation event fires, takes 400 ms, and the entire editor freezes. One extension's `onDidChangeTextDocument` handler never resolves: every other handler in the process waits. One language server crashes and the extension host tries to restart it, blocking the event loop. Your cursor stops moving.
+
+Everything competes on one thread. There is no way to cancel an in-flight extension operation. There is no back-pressure. Extensions cannot be preempted.
+
+## How Cocoon Eliminates It
+
+Cocoon intercepts `require` and `import` at the Node.js module level and routes all VS Code API calls through a complete Effect-TS service layer. Extensions call `vscode.workspace.openTextDocument()` and get back a `Thenable<TextDocument>` exactly as documented. Internally, that call is a typed Effect running on a fiber scheduler that can be interrupted, raced with a timeout, run concurrently with other operations, and traced for performance diagnostics.
+
+Extensions are isolated into separate fiber scopes. One extension's hung Promise does not block another's fiber.
+
+## What You Experience
+
+50+ extensions activate concurrently. Language server crashes are handled in supervised scopes with automatic restart. No extension can freeze the editor. The full VS Code marketplace works without modification.
+
+## Key Technologies
+
+Cocoon runs on Node.js with Effect-TS providing the fiber runtime. It communicates with Mountain through Vine's gRPC protocol. TypeScript types are enforced end-to-end.
+
+## See Also
+
+- [Architecture Overview](/Doc/architecture)
+- [Extension Development](/Doc/extension-development)
+- [Mountain: Native Backend](/Doc/mountain)
+- [Source Code](https://github.com/CodeEditorLand/Cocoon)

Source/Content/doc/cocoon.md

@@ -0,0 +1,57 @@
+---
+title: "Common"
+section: "Element"
+order: 19
+description:
+    "The abstract foundation that makes every element testable in isolation."
+---
+
+# Common
+
+Every Element in Code Editor Land depends on shared contracts: data types,
+error enums, configuration schemas, trait definitions. Common is the crate
+that holds all of them, and it holds nothing else. No concrete
+implementations, no runtime behavior, no side effects.
+
+## The Problem
+
+VS Code modules import concrete implementations directly. Testing a single
+component means mocking entire subsystems: the file system, the window
+manager, the extension host. A unit test that should take milliseconds
+instead launches half the editor.
+
+This tight coupling also means that changing one module can silently break
+another. There is no compile-time guarantee that a contract is being
+respected, because there is no formal contract to begin with.
+
+## How Common Eliminates It
+
+Common defines pure abstract traits for every cross-element boundary. Each
+trait specifies inputs, outputs, and error types. Zero concrete code lives
+in this crate.
+
+When Element A depends on Element B, it depends on the trait defined in
+Common, not on B's implementation. The Rust compiler enforces the contract
+at build time. If B changes its signature, every consumer fails to compile
+immediately, not at runtime six months later.
+
+## What You Experience
+
+You can test any Element in complete isolation. Mock any trait, inject it
+into the component under test, and verify behavior without launching a
+window, a WebView, or a sidecar process. Tests run in milliseconds.
+
+Refactoring becomes safe. Rename a method on a trait and the compiler tells
+you every call site that needs updating. No grep, no "find all references"
+in an editor that may miss dynamic calls.
+
+## Key Technologies
+
+Rust, Trait Objects, Zero-Cost Abstractions, Compile-Time Contract
+Enforcement.
+
+## See Also
+
+- [Architecture Overview](/Doc/architecture)
+- [Mountain](/Doc/mountain)
+- [Source Code](https://github.com/CodeEditorLand/Common)

Source/Content/doc/common.md

@@ -0,0 +1,30 @@
+---
+title: "Echo"
+section: "Element"
+order: 16
+description: "The work-stealing scheduler that runs indexing, search, and builds on every CPU core"
+---
+
+# Echo
+
+## The Problem Echo Solves
+
+VS Code's background tasks (file indexing, symbol scanning, git blame, search) run in a single-threaded Node.js process. Heavy indexing blocks all other activity on that thread. The only escape is spawning more processes, which adds memory overhead and inter-process communication costs.
+
+## How Echo Eliminates It
+
+Echo is a lock-free concurrency runtime built on Rust's crossbeam-deque work-stealing scheduler. Every task submitted to Echo runs inside a supervised worker pool that spans all CPU cores. Tasks are work-stolen (idle threads pick up tasks from busy threads), supervised (every task has a parent scope with controlled crash propagation), and gracefully shut down (no task can outlive its scope).
+
+## What You Experience
+
+A 20-file refactor, a workspace-wide symbol search, and a test run can all happen in true parallel on separate CPU cores. The editor stays responsive throughout. Indexing, search, and builds run on every core in parallel while the UI thread never blocks.
+
+## Key Technologies
+
+Echo is written in Rust using crossbeam-deque for lock-free work stealing and tokio for async I/O.
+
+## See Also
+
+- [Architecture Overview](/Doc/architecture)
+- [Mountain: Native Backend](/Doc/mountain)
+- [Source Code](https://github.com/CodeEditorLand/Echo)

Source/Content/doc/echo.md

@@ -0,0 +1,30 @@
+---
+title: "Grove"
+section: "Element"
+order: 18
+description: "The WASM sandbox that isolates extensions with capability-based security"
+---
+
+# Grove
+
+## The Problem Grove Solves
+
+VS Code extensions run with full Node.js capabilities in a shared process. A malicious extension can read the file system, make network requests, and access other extensions' state. The "extension sandbox" is a policy document, not a technical boundary.
+
+## How Grove Eliminates It
+
+Grove runs extensions compiled to WebAssembly inside WASMtime with capability-based security. An extension can only touch resources explicitly granted to it: a specific directory, a network endpoint, a named IPC channel. No implicit ambient authority. The WASM sandbox is a technical boundary, not a policy document.
+
+## What You Experience
+
+The path to a marketplace where extensions can be run safely with zero trust, the same way mobile apps work on iOS and Android. An extension can only touch what you explicitly grant. The sandbox is enforced by the runtime, not by hope.
+
+## Key Technologies
+
+Grove is written in Rust using WASMtime for WebAssembly execution. It implements the VS Code API surface for WASM-compiled extensions.
+
+## See Also
+
+- [Architecture Overview](/Doc/architecture)
+- [Cocoon: Extension Host](/Doc/cocoon)
+- [Source Code](https://github.com/CodeEditorLand/Grove)

Source/Content/doc/grove.md

@@ -0,0 +1,62 @@
+---
+title: "Maintain"
+section: "Element"
+order: 25
+description:
+    "The build orchestrator with Rhai scripting and deterministic output."
+---
+
+# Maintain
+
+Maintain is the build orchestrator for Code Editor Land. It coordinates
+Rest, Output, SideCar, and every other build-time Element into a single
+reproducible pipeline. Build logic is written in Rhai scripts, not shell
+scripts, and every configuration is validated at compile time.
+
+## The Problem
+
+Build pipelines that depend on environment variables, shell conditionals,
+and platform-specific scripts become impossible to debug. A build passes on
+one machine and fails on another because of a missing `$PATH` entry or a
+difference in how `sed` handles newlines on macOS versus Linux. VS Code's
+build system spans Gulp tasks, shell scripts, and Node.js scripts scattered
+across dozens of files. Reproducing a failure requires replicating the exact
+environment, which is rarely documented.
+
+## How Maintain Eliminates It
+
+Maintain replaces shell scripts with Rhai, an embedded scripting language
+designed for Rust applications. Rhai scripts are sandboxed, deterministic,
+and cross-platform by design. They cannot access the file system, network,
+or environment variables unless explicitly granted permission through
+Maintain's capability system.
+
+Build configurations are Rust structs validated at compile time. A typo in
+a configuration key fails the build before any artifact is produced, not
+after twenty minutes of compilation.
+
+Maintain orchestrates the full pipeline: Rest compiles TypeScript, Output
+stores artifacts, SideCar selects binaries. Each step receives typed
+inputs and produces typed outputs. If a step fails, the error message
+identifies the exact input that caused the failure.
+
+## What You Experience
+
+You run a single command and the build either succeeds or fails with a
+clear, actionable error. The same command produces the same result on
+macOS, Linux, and Windows. No environment-specific workarounds. No "works
+on my machine" mysteries.
+
+Build scripts are readable. Rhai's syntax is close to Rust, so anyone who
+can read the application code can read the build logic.
+
+## Key Technologies
+
+Rust, Rhai Scripting, Compile-Time Configuration Validation, Deterministic
+Orchestration, Capability-Based Sandboxing.
+
+## See Also
+
+- [Architecture Overview](/Doc/architecture)
+- [Output](/Doc/output)
+- [Source Code](https://github.com/CodeEditorLand/Maintain)

Source/Content/doc/maintain.md

@@ -0,0 +1,59 @@
+---
+title: "Mist"
+section: "Element"
+order: 20
+description:
+    "The DNS sandbox that resolves *.editor.land locally."
+---
+
+# Mist
+
+Mist is the network boundary between Code Editor Land and the outside
+world. It creates a fully sandboxed DNS zone that resolves every
+`*.editor.land` domain to `127.0.0.1`. Nothing leaves your machine unless
+you explicitly allow it.
+
+## The Problem
+
+VS Code extensions, update checks, and telemetry endpoints all resolve
+against public DNS. Even with telemetry disabled, DNS queries still leak
+metadata about which extensions are installed, when the editor starts, and
+how often it phones home. There is no clean boundary between editor traffic
+and internet traffic.
+
+Developers working on airgapped machines or behind strict firewalls face a
+different failure mode: DNS resolution hangs for seconds before timing out,
+and the editor stutters while it waits.
+
+## How Mist Eliminates It
+
+Mist intercepts all DNS queries for the `*.editor.land` zone before they
+reach the system resolver. Every query resolves instantly to `127.0.0.1`.
+The editor's internal services (authentication, extension marketplace,
+update checks) communicate over loopback without any packet leaving the
+network interface.
+
+For domains outside the `*.editor.land` zone, Mist passes queries through
+to the system resolver unchanged. Your browser, terminal, and every other
+application behave exactly as before.
+
+## What You Experience
+
+The editor starts and operates without any public DNS dependency. No
+metadata leaks. No firewall warnings. No timeout delays on restricted
+networks.
+
+On airgapped machines, the editor works at full speed because it never
+waits for a DNS response that will never come. On corporate networks, IT
+sees zero outbound traffic from the editor process.
+
+## Key Technologies
+
+Rust, DNS-over-Loopback, Sandboxed Zone Resolution, Zero-Leak Network
+Boundary.
+
+## See Also
+
+- [Architecture Overview](/Doc/architecture)
+- [Air](/Doc/air)
+- [Source Code](https://github.com/CodeEditorLand/Mist)

Source/Content/doc/mist.md

@@ -0,0 +1,35 @@
+---
+title: "Mountain"
+section: "Element"
+order: 11
+description: "The native Rust backend that replaces Electron's main process with Tauri"
+---
+
+# Mountain
+
+## The Problem Mountain Solves
+
+VS Code runs on Electron: a bundled Chromium instance plus Node.js. Every window adds another renderer process heap. Three open windows means three Chromium processes, each carrying a full heap. Every OS interaction (file dialog, clipboard, window move) crosses a serialized JSON IPC pipe.
+
+The memory tax is not optional. Open VS Code with a medium project: 500 MB to 1.5 GB of RAM. Switch to another app: the memory stays allocated. The garbage collector fights a losing battle on a gigabyte heap.
+
+## How Mountain Eliminates It
+
+Mountain replaces Electron's main process entirely with a Rust binary using Tauri. The operating system's own WebView renders the UI: WKWebView on macOS, WebView2 on Windows, WebKitGTK on Linux. No bundled Chromium. No Node.js in the host process.
+
+Window management, file system access, process lifecycle, and authentication tokens all happen in Rust with zero IPC overhead. Auth tokens live in the OS keychain, not in a renderer process heap.
+
+## What You Experience
+
+Cold start in under 200 ms. RAM footprint 60-80% smaller per window. File operations respond in microseconds, not milliseconds. Where Electron takes 200 ms to open a dialog, Mountain takes 2.
+
+## Key Technologies
+
+Mountain is built with Rust and Tauri 2.0. It communicates with Cocoon and other sidecars through Vine's gRPC protocol. The Cargo workspace manages all native dependencies.
+
+## See Also
+
+- [Architecture Overview](/Doc/architecture)
+- [Cocoon: Extension Host](/Doc/cocoon)
+- [Vine: gRPC Protocol](/Doc/vine)
+- [Source Code](https://github.com/CodeEditorLand/Mountain)