The Build System, Dead-Code Eliminator & Development Runner for Land 🏞️

Build pipelines that change behavior based on environment variables, implicit tool versions, or undeclared dependencies make debugging production issues impossible - the same commit produces different output on different machines. Maintain ensures deterministic builds: same commit, same output, guaranteed.

"Deterministic builds and tooling for a reproducible ecosystem."

Rust API Documentation 📖

Maintain is the Rust-based project maintenance toolkit for the Land 🏞️ Code Editor ecosystem. It provides three core capabilities: deterministic build orchestration driven by a single .vscode/land-config.json configuration file (loaded through an embedded Rhai engine), dead-code elimination through AST-level single-use variable inlining, and a development runner with hot-reload support.

Build pipelines that change behavior based on environment variables, implicit tool versions, or undeclared dependencies make debugging production issues impossible - the same commit produces different output on different machines. Maintain ensures deterministic builds: same commit, same output, guaranteed.

Maintain is engineered to:

1. Orchestrate Deterministic Builds - Provide a central build system for the entire Land ecosystem with named, config-driven build profiles (.vscode/land-config.json, resolved through an embedded Rhai engine), and type-safe configuration editing for Cargo.toml, JSON5, and Info.plist files.
2. Eliminate Dead Code - Analyse Rust source files via syn and inline let bindings that are used exactly once, are non-mutated, and have no closure-capture semantics - producing cleaner, more readable code without manual refactoring.
3. Run with Hot-Reload - Manage the development server lifecycle with profile-based configurations, environment variable resolution, and process management for rapid iteration.
4. Provide a Unified CLI - Deliver a single command-line interface with subcommands for build, eliminate, and run operations, making the toolkit accessible from shell scripts and CI pipelines alike.

Config-Driven Build Profiles - A single .vscode/land-config.json (JSON5, with comments and trailing commas) is the source of truth for workbench selection (Browser, Mountain, Electron, BrowserProxy), feature flags, binary configuration, and named build/run profiles. Build/Rhai/ConfigLoader.rs parses it; Build/Rhai/EnvironmentResolver.rs resolves environment variables dynamically against it.

Embedded Rhai Engine - Build/Rhai/CreateEngine.rs and Build/Rhai/RegisterUtilityFunctions.rs provide an in-process Rhai interpreter used internally by the config loader and environment resolver - there are no standalone .rhai script files to author or invoke.

Deterministic Build Orchestration - Central coordination of multi-stage builds across the Land ecosystem. The same commit produces the same output on every machine. Named profiles (resolved from land-config.json) and environment variable resolution ensure reproducibility.

AST-Level Dead-Code Elimination - Analyses Rust source files with syn and inlines single-use let bindings that meet strict safety criteria (non-mutated, no closure captures). Operates in dry-run mode for preview, supports glob-based file selection, and preserves comments and formatting with prettyplease reflow.

Type-Safe Configuration Editing - Compile-time checked editing of Cargo.toml (via toml_edit), JSON5 configuration files (via json5), and Info.plist files (via plist). Supports version bumps, dependency updates, and bundle identifier management.

Development Runner with Hot-Reload - Profile-based dev server management with environment variable integration, process lifecycle management, and Mountain ⛰️ development mode support.

Target Triple Resolution - Automatic detection of the current platform target triple (aarch64-apple-darwin, x86_64-unknown-linux-gnu, etc.) for cross-platform build configuration.

Unified CLI - Single binary (Maintain) with subcommands for all operations: build (debug/release/profile), eliminate (dead-code inline), and run (dev server, hot reload).

graph LR
    classDef maintain fill:#fce8ff,stroke:#9b59b6,stroke-width:2px,color:#2c0050;
    classDef script   fill:#cce8ff,stroke:#2980b9,stroke-width:1px,color:#003050;
    classDef config   fill:#fff3c0,stroke:#f39c12,stroke-width:1px,color:#5a3e00;
    classDef artifact fill:#d4f5d4,stroke:#27ae60,stroke-width:1px,color:#0a3a0a;

    subgraph MAINTAIN["Maintain 💪🏻 - Build System + Eliminator + Dev Runner"]
        direction TB
        subgraph BUILD["Source/Build/ - Build Orchestration"]
            BuildCLI["Build/CLI/Cli.rs ⚙️ clap subcommands: build · list-profiles · show-profile · validate-profile · resolve"]:::maintain
            BuildFn["Build/Fn.rs 🔨 build functions"]:::maintain
            TomlEdit["Build/TomlEdit.rs 📝 Cargo.toml editing"]:::maintain
            JsonEdit["Build/JsonEdit.rs 📋 JSON5 editing"]:::maintain
            PlistEdit["Build/PlistEdit.rs 📄 Info.plist editing"]:::maintain
            Pascalize["Build/Pascalize.rs 🔤 string conversion"]:::maintain
            GetTriple["Build/GetTauriTargetTriple.rs 🎯 target triple"]:::maintain
        end
        subgraph RHAI["Build/Rhai/ - Embedded Scripting + Config Loading"]
            ScriptRunner["ScriptRunner.rs 🚀 runs embedded Rhai expressions"]:::maintain
            ConfigLoader["ConfigLoader.rs 📦 parses .vscode/land-config.json"]:::maintain
            EnvResolver["EnvironmentResolver.rs 🌐 dynamic env var resolution"]:::maintain
            ScriptRunner --> ConfigLoader
            ScriptRunner --> EnvResolver
        end
        subgraph ELIMINATE["Source/Eliminate/ - Dead-Code Elimination"]
            ElimCLI["Eliminate/CLI.rs 🗑️ batch file processing"]:::maintain
            ElimFn["Eliminate/Fn.rs 🎯 entry point"]:::maintain
            ElimProcess["Eliminate/Process.rs 📂 file discovery + orchestration"]:::maintain
            Safe["Eliminate/Transform/Safe.rs 🛡️ safety checks"]:::maintain
            Inline["Eliminate/Transform/Inline/Eliminator.rs ✂️ AST inlining"]:::maintain
            Collect["Eliminate/Transform/Collect.rs 📊 usage counting"]:::maintain
            Count["Eliminate/Transform/Count.rs 🔢 node counting"]:::maintain
            Patch["Eliminate/Transform/Patch.rs 🧩 precise rewrites"]:::maintain
            ElimFn --> ElimProcess --> Safe --> Collect --> Count
            Collect --> Inline --> Patch
        end
        subgraph RUN["Source/Run/ - Development Runner"]
            RunCLI["Run/CLI/Cli.rs 🏃 profile-based runs"]:::maintain
            RunProcess["Run/Process.rs ⚡ process management"]:::maintain
            Profile["Run/Profile.rs 📊 perf profiling"]:::maintain
            Environment["Run/Environment.rs 🌍 env variable management"]:::maintain
        end

        BuildCLI --> BuildFn
        BuildCLI --> RHAI
        BuildCLI --> RUN
        BuildFn --> TomlEdit
        BuildFn --> JsonEdit
        BuildFn --> PlistEdit
    end

    subgraph SCRIPTS["Land/Maintain/ - Shell Script Entrypoints (repo root, outside this crate)"]
        DebugBuild["Debug/Build.sh 🔧 profile-aware debug build"]:::script
        ReleaseBuild["Release/Build.sh 🚀 cargo build --release"]:::script
        SignBundle["Script/SignBundle.sh 🔐 ad-hoc codesign + entitlements"]:::script
        DevRun["Debug/Run.sh ⛰️ hot-reload dev server"]:::script
    end

    subgraph TARGETS["Build Artifacts"]
        MountainBin["Mountain binary .app bundle"]:::artifact
        CargoTOML["Cargo.toml workspace config"]:::config
        PlistFile["Entitlements.plist + Info.plist"]:::config
    end

    BuildCLI -.invokes.-> DebugBuild
    BuildCLI -.invokes.-> ReleaseBuild
    DebugBuild --> SignBundle
    ReleaseBuild --> SignBundle
    SignBundle --> MountainBin
    TomlEdit --> CargoTOML
    PlistEdit --> PlistFile

Operation paths:

Element/Maintain/
├── Cargo.toml                       # Package manifest (bin + lib + tests)
├── build.rs                         # Build script
├── Source/
│   ├── main.rs                      # Binary entry point (bin: Maintain)
│   ├── Library.rs                   # Library root (exports Build, Eliminate, Run)
│   ├── Architecture.rs              # Platform detection and target triples
│   ├── Build/                       # Build orchestration and scripting
│   │   ├── mod.rs                   # Module re-exports
│   │   ├── CLI/                     # clap CLI (config-driven: build ·
│   │   │   ├── Cli.rs               #   list-profiles · show-profile ·
│   │   │   ├── Commands.rs          #   validate-profile · resolve)
│   │   │   ├── GetAllProfiles.rs
│   │   │   └── OutputFormat.rs
│   │   ├── Constant.rs              # File paths, env var names, delimiters
│   │   ├── Definition.rs            # Build type definitions
│   │   ├── Error.rs                 # Build error types
│   │   ├── Fn.rs                    # Build orchestration functions
│   │   ├── GetTauriTargetTriple.rs  # Target triple resolution
│   │   ├── JsonEdit.rs              # JSON5 config editing
│   │   ├── Logger.rs                # Build logging
│   │   ├── Pascalize.rs             # snake_case → PascalCase
│   │   ├── PlistEdit.rs             # Info.plist / Entitlements.plist editing
│   │   ├── Process/                 # Build process orchestration
│   │   │   ├── Process.rs
│   │   │   └── BuildPlistEnvironment.rs
│   │   ├── TomlEdit.rs              # Cargo.toml type-safe editing
│   │   ├── WordsFromPascal.rs       # Split PascalCase into words
│   │   └── Rhai/                    # Embedded Rhai engine + config loader
│   │       ├── mod.rs
│   │       ├── ConfigLoader.rs      # Parses .vscode/land-config.json
│   │       ├── CreateEngine.rs      # Rhai engine construction
│   │       ├── EnvironmentResolver.rs  # Dynamic env var resolution
│   │       ├── RegisterUtilityFunctions.rs  # Rhai helper functions
│   │       └── ScriptRunner.rs      # Rhai script execution
│   ├── Eliminate/                   # Dead-code elimination (AST-level inlining)
│   │   ├── mod.rs                   # Module re-exports
│   │   ├── CLI.rs                   # CLI (--path, --glob, --dry-run)
│   │   ├── Constant.rs              # Defaults (MaxSize, DefaultGlob)
│   │   ├── Definition.rs            # Options, Stats structures
│   │   ├── Error.rs                 # Elimination error types
│   │   ├── Fn.rs                    # Top-level entry point
│   │   ├── Logger.rs                # Colored logging
│   │   ├── Process.rs               # File discovery and orchestration
│   │   └── Transform/               # AST transformation pipeline
│   │       ├── mod.rs               # Pipeline orchestration
│   │       ├── Collect.rs           # Usage-site collection
│   │       ├── CollectBlockPatches.rs
│   │       ├── CollectInnerBlockPatches.rs
│   │       ├── Count.rs             # AST node counting
│   │       ├── Inline/              # Inline single-use bindings
│   │       │   ├── Eliminator.rs
│   │       │   ├── Substitutor.rs
│   │       │   └── Tests.rs
│   │       ├── Patch.rs             # Precise file rewrites
│   │       ├── PreservePass.rs
│   │       ├── Run.rs
│   │       ├── RunPreserve.rs
│   │       ├── Safe.rs              # Safety checks (mutation, captures)
│   │       ├── StmtNestedBlock.rs
│   │       ├── StmtTokensMatch.rs
│   │       ├── StmtToText.rs
│   │       ├── TryBlockPreserve.rs
│   │       ├── TryItemPreserve.rs
│   │       └── TryPatchSource.rs
│   └── Run/                         # Development runner
│       ├── mod.rs                   # Module re-exports
│       ├── CLI/                     # CLI (config-driven: run ·
│       │   ├── Cli.rs               #   list-profiles · show-profile ·
│       │   ├── Commands.rs          #   validate-profile · resolve)
│       │   └── OutputFormat.rs
│       ├── Constant.rs              # Run module constants
│       ├── Definition.rs            # Type definitions
│       ├── Environment.rs           # Environment variable management
│       ├── Error.rs                 # Error types
│       ├── Fn.rs                    # Main entry point
│       ├── Logger.rs                # Logging utilities
│       ├── Process.rs               # Process management
│       └── Profile.rs               # Profile resolution
├── tests/
│   ├── Eliminate.rs                 # Top-level test declarations
│   ├── test_rhai_config.rs          # Rhai config loading tests
│   └── Eliminate/
│       ├── Syntactic.rs             # Unit tests for transform pipeline
│       ├── Integration.rs           # Integration test runner
│       └── Integration/             # Integration test cases
│           ├── BinaryParens.rs
│           ├── BlockIntoIfLet.rs
│           ├── BorrowInline.rs
│           ├── CastExpr.rs
│           ├── Chain.rs
│           ├── ClosureCaptureKept.rs
│           ├── ClosureLocal.rs
│           ├── Idempotent.rs
│           ├── IfGuard.rs
│           ├── LoopUri.rs
│           ├── MatchScrutinee.rs
│           ├── MtimeChain.rs
│           ├── MultiUseKept.rs
│           ├── NegatedBool.rs
│           ├── NestedScope.rs
│           ├── QuestionMark.rs
│           ├── Shadow.rs
│           ├── Simple.rs
│           ├── StructLiteral.rs
│           └── TypeAnnotation.rs
├── examples/
│   └── test_rhai_config.rs          # Rhai configuration example
└── Documentation/
    ├── GitHub/
    │   └── DeepDive.md              # Deep-dive technical documentation
    └── Rust/
        └── doc/                     # Cargo doc output

Maintain 💪🏻 serves as the project maintenance toolkit for the entire Land 🏞️ ecosystem, providing three complementary capabilities that span the development lifecycle:

Maintain orchestrates builds across all Land elements. Its build CLI subcommand resolves a named profile from .vscode/land-config.json (workbench, features, environment variables); the sibling shell scripts under Land/Maintain/ (Debug/Build.sh, Release/Build.sh, Script/SignBundle.sh) compile and code-sign the Mountain binary. The embedded Rhai engine backs the config loader and environment resolver - it is not a user-facing scripting surface. Configuration editors modify Cargo.toml (version bumps, dependency updates), JSON5 configs, and Info.plist/Entitlements.plist files. Maintain resolves environment variables dynamically for build-time configuration.

The Eliminate module operates independently on any Rust source tree, providing AST-level dead-code removal with a dry-run mode for preview. It is designed to be idempotent - running it twice produces the same output.

• Rust 1.95.0 or later (edition 2024)

To add Maintain as a dependency:

[dependencies]
Maintain = { git = "https://github.com/CodeEditorLand/Maintain.git", branch = "Current" }

Or install the CLI globally:

cargo install Maintain

At the Land monorepo root, Maintain is invoked through shell scripts that live in Land/Maintain/ (outside this crate) and read .vscode/land-config.json:

# Debug build (profile-aware, auto-signs the .app afterward)
sh Maintain/Debug/Build.sh --profile debug-electron

# Development runner with hot reload
sh Maintain/Debug/Run.sh

# Release build
sh Maintain/Release/Build.sh

# Ad-hoc re-sign of an already-built .app
BundleLevel=debug sh Maintain/Script/SignBundle.sh

As a binary with subcommands (config-driven build/run, resolved from land-config.json):

# Build operations
cargo run --bin Maintain -- build --profile debug-mountain
cargo run --bin Maintain -- list-profiles --verbose
cargo run --bin Maintain -- show-profile debug-mountain
cargo run --bin Maintain -- resolve --profile debug-mountain --format table

# Dead-code elimination
cargo run --bin Maintain -- eliminate --path ./Source --glob "**/*.rs"
cargo run --bin Maintain -- eliminate --path ./Source/Foo.rs --dry-run

# Development runner
cargo run --bin Maintain -- run --profile debug-mountain --hot-reload

use Maintain::{Build, Eliminate, Run};

// Build CLI (config-driven, reads .vscode/land-config.json)
let Cli = Build::CLI::Cli::Cli::try_parse_from(["Maintain", "build", "--profile", "debug-mountain"])?;
Cli.execute()?;

// Dead-code elimination
let Options = Eliminate::Definition::Options {
	MaxSize:Eliminate::Constant::DefaultMaxSize,
	InlineComments:false,
	DryRun:true,
};
Eliminate::Process::Process(std::path::Path::new("./Source"), "**/*.rs", &Options)?;

// Development runner (config-driven, reads .vscode/land-config.json)
let Cli = Run::CLI::Cli::Cli::try_parse_from(["Maintain", "run", "--profile", "debug-mountain"])?;
Cli.execute()?;

Maintain enforces safety at multiple layers:

Maintain is designed to be compatible with:

• Rust API Documentation 📖

• Architecture Overview - Land system architecture
• Why Rust - Why Rust for build tooling
• Mountain - Native desktop shell
• Grove - Rust/WASM extension host
• Rest - HTTP/REST API Server for Land
• Output - Build Output & Artifact Management for Land

This project is released into the public domain under the Creative Commons CC0 Universal license. You are free to use, modify, distribute, and build upon this work for any purpose, without any restrictions. For the full legal text, see the LICENSE file.

Stay updated with our progress! See CHANGELOG.md for a history of changes.

Land 🏞️ is proud to be an open-source endeavor. Our journey is significantly supported by the organizations and projects that believe in the future of open-source software.

This project is funded through NGI0 Commons Fund, a fund established by NLnet with financial support from the European Commission's Next Generation Internet program. Learn more at the NLnet project page.

Land	PlayForm	NLnet	NGI0 Commons Fund

Project Maintainers: Source Open (Source/Open@editor.land) | GitHub Repository | Report an Issue | Security Policy