--- ## backend/symbol/registry.rs
    ENUMS:
    enum SymbolKind { Constant, Variable, Function, Method, Component, Action, Style, Theme, Type, Interface, Unknown }

    STRUCTS:
    struct Symbol
      PROPERTIES:
      name: String, kind: SymbolKind, value: String, file: FileMeta, origin: String, metadata: HashMap < String , String >
    struct SymbolId
      PROPERTIES:
      name: String, origin: String
    struct SymbolRegistry
      PROPERTIES:
      table: HashMap < SymbolId , Symbol >, warnings: Vec < String >

      METHODS:
      fn new() -> Self
      fn build(
          self,
          registry: & Registry,
          engines: & HashMap < String , Box < dyn Utter > >
      )
      fn lookup(
          self,
          name: & str,
          origin: & str
      )
          -> Option < & Symbol >
      fn reset(
          self
      )
      fn build_step(
          self,
          stack: & FileStack,
          engine: & dyn Utter
      )
      fn build_all(
          self,
          registry: & Registry,
          engines: & HashMap < String , Box < dyn Utter > >
      )
      fn build_incremental(
          self,
          stack: & FileStack,
          engine: & dyn Utter
      )
      fn build_with_warnings(
          self,
          registry: & Registry,
          engines: & HashMap < String , Box < dyn Utter > >
      )
          -> Vec < String >
      fn add_symbols(
          self,
          symbols: Vec < Symbol >,
          source_file: & str
      )

--- ## backend/utter/handler.rs
    ENUMS:
    enum RenderTarget { Html, Css, Js, Ts, Json, Md, Loi }

    STRUCTS:
    struct GenericHandler
      PROPERTIES:
      target: RenderTarget

      METHODS:
      fn render_ir(
          self,
          ir: & IR
      )
          -> String
      fn handle(
          self,
          file: & FileMeta,
          utter: & dyn Utter,
          symbols: & SymbolRegistry
      )
          -> Result < IR , String >
      fn emit(
          self,
          ir: & IR
      )
          -> Result < String , String >

--- ## backend/utter/registry.rs
    STRUCTS:
    struct UtterRegistry
      PROPERTIES:
      utters: HashMap < String , Box < dyn Utter > >, handlers: HashMap < String , Box < dyn Handler > >

      METHODS:
      fn default() -> Self
      fn eq(
          self,
          other: & Self
      )
          -> bool
      fn new() -> Self
      fn get_utter(
          self,
          capability: & str
      )
          -> Option < & dyn Utter >

--- ## backend/utter/utter.rs
    FUNCTIONS:
    fn get_language_definitions() -> Vec < GenericUtter >

    STRUCTS:
    struct GenericUtter
      PROPERTIES:
      name: String, config: LanguageConfig

      METHODS:
      fn new(
          config: LanguageConfig
      )
          -> Self
      fn fmt(
          self,
          f: & mut std :: fmt :: Formatter < '_ >
      )
          -> std :: fmt :: Result
      fn name(
          self
      )
          -> & str
      fn flags(
          self
      )
          -> UtterFlags
      fn to_ir(
          self,
          metadata: & FileMeta,
          symbols: & SymbolRegistry
      )
          -> Result < IR , String >
      fn get_exported_symbols(
          self,
          metadata: & FileMeta
      )
          -> Vec < Symbol >
      fn as_any(
          self
      )
          -> & dyn Any
      fn as_any_mut(
          self
      )
          -> & mut dyn Any
    struct LanguageConfig
      PROPERTIES:
      name: String, flags: UtterFlags, symbol_patterns: Vec < (& 'static str , SymbolKind) >, to_ir: Option < ToIrFn >

      METHODS:
      fn default() -> Self
    struct UtterFlags
      PROPERTIES:
      browser_dom: bool, allow_network: bool, fs_access: bool, db_access: bool

      METHODS:
      fn default() -> Self

--- # backend/link_with_clang.rs
  FUNCTIONS:
  fn link_with_clang(
      input_bc: & Path,
      output_exe: & Path
  )
      -> Result < () , String >

--- # backend/llvm.rs
  FUNCTIONS:
  fn codegen_binary(
      context: & mut CodeGenContext < 'ctx >,
      left: IRVal,
      op: BinOp,
      right: IRVal
  )
      -> Result < BasicValueEnum < 'ctx > , String >
  fn codegen_expr(
      expr: & Expr,
      ty: & Type,
      context: & mut CodeGenContext < 'ctx >
  )
      -> BasicValueEnum < 'ctx >
  fn codegen_ir_op(
      context: & mut CodeGenContext < 'ctx >,
      op: IROp
  )
      -> Result < () , String >
  fn codegen_ir_value(
      val: IRVal,
      ctx: & mut CodeGenContext < 'ctx >
  )
      -> BasicValueEnum < 'ctx >
  fn fmt_for_irval(
      val: & IRVal,
      context: & CodeGenContext < 'ctx >
  )
      -> BasicValueEnum < 'ctx >
  fn lower_ast_to_ir(
      ast: & AST
  )
      -> Result < Vec < IROp > , CompileError >
  fn lower_expr_to_ir(
      expr: Expr
  )
      -> Result < Vec < IROp > , CompileError >
  fn lower_expr_to_ir_inner(
      expr: Expr,
      ops: & mut Vec < IROp >,
      temp_counter: & mut usize
  )
      -> Result < IRVal , CompileError >
  fn lower_expr_to_ir_value(
      expr: & Expr
  )
      -> IRVal
  fn lower_typed_expr_to_ir_value(
      expr: & TypedExpr
  )
      -> IRVal
  fn new_temp(
      counter: & mut usize
  )
      -> IRVal

  STRUCTS:
  struct CodeGenContext
    PROPERTIES:
    context: & 'ctx Context, module: Module < 'ctx >, builder: Builder < 'ctx >, runtime: Runtime < 'ctx >, env: HashMap < String , PointerValue < 'ctx > >, last_value: Option < BasicValueEnum < 'ctx > >, counter: usize
  struct LLVM
    PROPERTIES:
    context: CodeGenContext < 'ctx >
  struct Runtime
    PROPERTIES:
    main: FunctionValue < 'ctx >, entry_block: BasicBlock < 'ctx >, printf: FunctionValue < 'ctx >, fmt_f64: PointerValue < 'ctx >, fmt_i32: PointerValue < 'ctx >, fmt_str: PointerValue < 'ctx >

--- # build/args.rs
  ENUMS:
  enum BuildTarget { ByName(_0: String), ByIndex(_0: usize) }

--- # build/artifact.rs
  ENUMS:
  enum ArtifactKind { Web, Loi }

  STRUCTS:
  struct Artifact
    PROPERTIES:
    path: PathBuf, bytes: Vec < u8 >, kind: ArtifactKind
  struct CompiledArtifact
    PROPERTIES:
    ir: IR, bundle: Vec < Artifact >

--- # build/asset_optimizer.rs
  STRUCTS:
  struct AssetOptimizer
    PROPERTIES:
    minify: bool, remove_comments: bool

    METHODS:
    fn minify_js(
        self,
        source: & str
    )
        -> String
    fn optimize(
        self,
        ir: IR,
        ext: & str
    )
        -> IR
    fn strip_comments(
        self,
        content: & str,
        lang: & str
    )
        -> String

--- # build/build_system.rs
  STRUCTS:
  struct BuildContext
    PROPERTIES:
    build_id: u64, started_at: Instant, dir_root: PathBuf, dir_out: PathBuf, watch: bool, clean: bool, verbose: bool
  struct BuildSystem
    PROPERTIES:
    context: BuildContext, registry: Registry, utters: UtterRegistry, bundle_service: BundleService

    METHODS:
    fn new(
        kernel: Kernel
    )
        -> Self
    fn test() -> Self

--- # build/output_resolver.rs
  STRUCTS:
  struct OutputResolver
    PROPERTIES:
    manifest: BundleConfig

    METHODS:
    fn new(
        manifest: BundleConfig
    )
        -> Self
    fn get_web_path(
        self,
        file: & FileMeta
    )
        -> Option < PathBuf >
    fn get_loi_path(
        self,
        file: & FileMeta
    )
        -> PathBuf
    fn get_stripped_base_name(
        self,
        meta: & FileMeta
    )
        -> String

--- # build/service.rs
  STRUCTS:
  struct BundleConfig
    PROPERTIES:
    dir_root: PathBuf, dir_out: PathBuf, strip_namespace: bool, strip_tag: bool, strip_utter: bool, strip_variant: bool, strip_version: bool, minify: bool, remove_comments: bool

    METHODS:
    fn default() -> Self
  struct BundleService
    PROPERTIES:
    registry: Registry, utter_registry: UtterRegistry, symbols: SymbolRegistry, manifest: BundleConfig, resolver: OutputResolver, optimizer: AssetOptimizer

    METHODS:
    fn new(
        registry: Registry,
        manifest: BundleConfig,
        utter: UtterRegistry
    )
        -> Self
    fn rebuild_symbols(
        self
    )
    fn compile_all(
        self,
        files: & [FileMeta]
    )
        -> Vec < Result < (FileMeta , CompiledArtifact) , String > >
    fn compile(
        self,
        file: & FileMeta
    )
        -> Result < CompiledArtifact , String >

--- # cli/args.rs
  STRUCTS:
  struct CliArgs
    PROPERTIES:
    watch: bool, input: Option < PathBuf >, output: Option < PathBuf >, concurrency: Option < usize >

--- # cli/command.rs
  ENUMS:
  enum Command { Mode(_0: String), List(_0: ListFilter), Tree, History(_0: Option < String >), CapabilityMap, Diff(_0: String, _1: String), Build(_0: BuildTarget), BuildAll(_0: BuildAllArgs), View(_0: ViewArgs), Clear, Help, Exit }
  enum SortOrder { Asc, Desc }

  STRUCTS:
  struct BuildAllArgs
    PROPERTIES:
    target: Option < BuildTarget >, flags: BuildFlags
  struct BuildFlags
    PROPERTIES:
    force: bool, ext: Option < String >, filter: Option < String >
  struct CommandMeta
    PROPERTIES:
    label: & 'static str, alias: Option < & 'static str >, description: & 'static str, hidden: bool, weight: u32
  struct ViewArgs
    PROPERTIES:
    target: Option < BuildTarget >, flags: ViewFlags
  struct ViewFlags
    PROPERTIES:
    name: Option < String >, number: Option < i32 >, sort: Option < SortOrder >

--- # cli/controller.rs
  STRUCTS:
  struct CliController
    PROPERTIES:
    system: BuildSystem, history_path: PathBuf, current_namespace: Vec < String >, verbosity: u8

    METHODS:
    fn new(
        system: BuildSystem
    )
        -> Self
    fn run(
        self
    )
    fn build_index(
        self
    )
        -> Vec < & FileMeta >
    fn resolve_target(
        _registry: & 'a Registry,
        files: & [& 'a FileMeta],
        target: & BuildTarget
    )
        -> Option < & 'a FileMeta >
    fn handle_build(
        self,
        target: & BuildTarget
    )
    fn handle_build_all(
        self,
        target: & BuildAllArgs
    )
    fn handle_view(
        self,
        args: & ViewArgs,
        ui: & dyn RegistryUI
    )

--- # cli/display.rs
  ENUMS:
  enum ListFilter { Active, Archived, All }

  STRUCTS:
  struct FileView
    PROPERTIES:
    namespace: String, index: usize, filename: String, active: String, name: String, utter: String, version: String, tag: String, ext: String, capabilities: String
  struct RegistryRenderer
    METHODS:
    fn render_file_contents(
        self,
        path: & std :: path :: Path,
        contents: & str
    )
    fn render_header(
        self,
        registry: & Registry
    )
    fn render_shortcuts(
        self
    )
    fn render_list(
        self,
        registry: & Registry,
        filter: ListFilter
    )
    fn render_tree(
        self,
        registry: & Registry
    )
    fn render_version_history(
        self,
        registry: & Registry,
        target: Option < & str >
    )
    fn render_capability_map(
        self,
        registry: & Registry
    )
    fn render_diff(
        self,
        registry: & Registry,
        a: & str,
        b: & str
    )
    fn render_error(
        self,
        text: String
    )
  struct Theme
    METHODS:
    fn light_grey(
        text: & str
    )
        -> String
    fn header(
        text: & str
    )
        -> String
    fn error(
        text: & str
    )
        -> String
    fn success(
        text: & str
    )
        -> String
    fn highlight(
        text: & str
    )
        -> String

--- # compiler/addon.rs
  STRUCTS:
  struct BackendRegistry
  struct PassRegistry
  struct PipelineExtensions

--- # compiler/bundler.rs
  STRUCTS:
  struct OutputEmitter

--- # compiler/cache.rs
  STRUCTS:
  struct CachePolicy
    METHODS:
    fn should_invalidate(
        self,
        _key: & str
    )
        -> bool
  struct CompilationCache
    PROPERTIES:
    cache: HashMap < String , Vec < u8 > >

    METHODS:
    fn new() -> Self
  struct MemoryCache
    PROPERTIES:
    map: HashMap < String , String >

    METHODS:
    fn new() -> Self
  struct NetworkCache
  struct PersistentCache
    PROPERTIES:
    disk_path: Option < PathBuf >

    METHODS:
    fn new() -> Self

--- # compiler/compile.rs
  FUNCTIONS:
  fn compile(
      _system_context: & Context,
      ir: & [IROp],
      out_base: & Path,
      module_name: & str
  )
      -> Result < String , String >

--- # compiler/compile_project.rs
  FUNCTIONS:
  fn compile_file(
      kernel: & Kernel,
      path: & Path,
      output_dir: & Path
  )
      -> Result < () , Error >
  fn compile_project(
      kernel: & Kernel,
      config: & CompileConfig
  )
      -> Result < () , Vec < Error > >

--- # compiler/config.rs
  ENUMS:
  enum CompileStage { Parse, Analyze, Lower, Backend }
  enum CompileTarget { Build, Jit, IR, Codegen }
  enum ConfigSource { Defaults, File(_0: PathBuf), Cli(_0: CliArgs), ReplOverrides }

  STRUCTS:
  struct CompileConfig
    PROPERTIES:
    root: PathBuf, name: String, input: PathBuf, output: PathBuf, watch: bool, concurrency: usize, target: CompileTarget, stage: CompileStage

    METHODS:
    fn from(
        cfg: Config
    )
        -> Self
    fn default() -> Self
  struct Config
    PROPERTIES:
    target: CompileTarget, stage: CompileStage, root: PathBuf, name: String, input: Option < PathBuf >, output: Option < PathBuf >, watch: bool, concurrency: usize

    METHODS:
    fn default() -> Self
  struct ConfigResolver
    METHODS:
    fn resolve(
        sources: Vec < ConfigSource >
    )
        -> Config
    fn merge(
        base: Config,
        overlay: Config
    )
        -> Config
    fn load_file(
        _path: & Path
    )
        -> Config
    fn parse_cli(
        _args: Vec < String >
    )
        -> Config
    fn from_cli(
        base: & Config,
        cli: CliArgs
    )
        -> Config

--- # compiler/diagnostic.rs
  ENUMS:
  enum Severity { Info, Warning, Error, Hint }

  STRUCTS:
  struct CompilerEventBus
  struct Diagnostic
    PROPERTIES:
    message: String, code: Option < String >, span: Span, severity: Severity, notes: Vec < String >, suggestions: Vec < String >

    METHODS:
    fn new(
        message: impl Into < String >,
        span: Span,
        severity: Severity
    )
        -> Self
    fn default() -> Self
    fn error(
        message: impl Into < String >,
        span: Span
    )
        -> Self
    fn warning(
        message: impl Into < String >,
        span: Span
    )
        -> Self
    fn with_note(
        self,
        note: impl Into < String >
    )
        -> Self
    fn with_suggestion(
        self,
        suggestion: impl Into < String >
    )
        -> Self
    fn with_code(
        self,
        code: impl Into < String >
    )
        -> Self
  struct DiagnosticError
    METHODS:
    fn fmt(
        self,
        f: & mut fmt :: Formatter < '_ >
    )
        -> fmt :: Result
  struct DiagnosticStore
    PROPERTIES:
    halt_on_error: bool, error_count: usize, diagnostics: VecDeque < Diagnostic >

    METHODS:
    fn to_compile_error(
        self,
        stage: & str
    )
        -> CompileError
    fn emit(
        self,
        diag: Diagnostic
    )
        -> bool
    fn check_halt(
        self
    )
        -> Result < () , CompileError >
    fn new(
        halt_on_error: bool
    )
        -> Self
    fn has_errors(
        self
    )
        -> bool
    fn clear(
        self
    )
    fn flush(
        self
    )
  struct Inspector
  struct Logger
    METHODS:
    fn log(
        self,
        msg: & str
    )
    fn test() -> Self
  struct Profiler
    METHODS:
    fn new() -> Self
  struct TraceSystem
    METHODS:
    fn new() -> Self

--- # compiler/engine.rs
  STRUCTS:
  struct CompileEngine
    PROPERTIES:
    state: Arc < RwLock < CompileState > >, config: Arc < RwLock < CompileConfig > >, stages: Vec < Box < dyn Stage > >

    METHODS:
    fn parse(
        self
    )
    fn analyze(
        self
    )
    fn lower(
        self
    )
    fn backend(
        self
    )
    fn build(
        self
    )
    fn run_all(
        self
    )
        -> Result < () , () >
    fn new(
        context: Arc < Context >,
        config: Arc < RwLock < CompileConfig > >,
        state: Arc < RwLock < CompileState > >
    )
        -> Self
    fn default() -> Self

--- # compiler/env.rs
  ENUMS:
  enum Mode { Batch, Interactive, Watch }
  enum TargetArch { X86_64, AArch64, RISCV64, Unknown }
  enum TargetOS { Linux, MacOS, Windows, Unknown }

  STRUCTS:
  struct Env
    PROPERTIES:
    root_dir: PathBuf, output_dir: PathBuf, mode: Mode, target: TargetConfig, features: FeatureFlags, toolchain: ToolchainPaths, cwd: PathBuf, timestamp: u64

    METHODS:
    fn default() -> Self
  struct FeatureFlags
    PROPERTIES:
    incremental: bool, parallel_frontend: bool, parallel_codegen: bool, aggressive_cache: bool, debug_symbols: bool, hot_reload: bool

    METHODS:
    fn default() -> Self
  struct TargetConfig
    PROPERTIES:
    os: TargetOS, arch: TargetArch, abi: Option < String >

    METHODS:
    fn default() -> Self
  struct ToolchainPaths
    PROPERTIES:
    llvm_bin: Option < PathBuf >, linker: Option < PathBuf >, assembler: Option < PathBuf >, wasm_toolchain: Option < PathBuf >, custom_backend: Option < PathBuf >

    METHODS:
    fn default() -> Self

--- # compiler/error.rs
  ENUMS:
  enum Error { Io(_0: String), Lexer(_0: String), Parser(_0: String), Analysis(_0: String), Backend(_0: String) }

--- # compiler/execution.rs
  STRUCTS:
  struct JobQueue
    PROPERTIES:
    jobs: Arc < Mutex < Vec < String > > >

    METHODS:
    fn new() -> Self
  struct PluginSystem
  struct PrioritySystem
    PROPERTIES:
    priority_map: HashMap < String , u8 >

    METHODS:
    fn new() -> Self
  struct TaskScheduler
    METHODS:
    fn new() -> Self
    fn schedule(
        self,
        f: F
    )

--- # compiler/mod.rs
  STRUCTS:
  struct Compiler
    PROPERTIES:
    pipelines: Vec < Box < dyn Pipeline > >

    METHODS:
    fn compile(
        self
    )
        -> Result < () , Compiler >

--- # compiler/runtime.rs
  STRUCTS:
  struct IRRuntime
  struct LoweringRuntime
  struct SymbolRuntime

--- # compiler/safety.rs
  STRUCTS:
  struct FallbackPipeline
  struct RecoverySystem

--- # compiler/scale.rs
  STRUCTS:
  struct BuildFarm
  struct DistributedCompiler

--- # compiler/state.rs
  STRUCTS:
  struct BuildCache
    PROPERTIES:
    object_cache: HashMap < u64 , Vec < u8 > >, ir_cache: HashMap < u64 , IR >, symbol_cache: HashMap < u64 , Vec < u8 > >, timestamps: HashMap < PathBuf , u64 >, cache_version: u32, current: Option < BuildArtifact >

    METHODS:
    fn insert_artifact(
        self,
        hash: u64,
        artifact: Vec < u8 >
    )
    fn insert_ir(
        self,
        hash: u64,
        ir: IR
    )
    fn insert_symbol(
        self,
        hash: u64,
        output: Vec < u8 >
    )
    fn set_current(
        self,
        artifact: BuildArtifact
    )
  struct CompileState
    PROPERTIES:
    registry: Registry, file_graph: FileGraph, dependency_graph: DependencyGraph, symbols: SymbolRegistry, symbol_index: SymbolIndex, dirty_files: HashSet < Uuid >, dirty_symbols: HashSet < SymbolId >, content_hashes: HashMap < PathBuf , u64 >, source: Option < String >, current_ast: Option < AST >, current_ir: Option < IR >, current_lowered_ir: Option < LoweredIR >, current_artifact: Option < BuildArtifact >, caches: CompilerCaches, compiler_version: String, ir_version: u32

    METHODS:
    fn current_ir(
        self
    )
        -> Option < IR >
    fn current_ast(
        self
    )
        -> Option < AST >
    fn current_lowered_ir(
        self
    )
        -> Option < LoweredIR >
    fn current_artifact(
        self
    )
        -> Option < BuildArtifact >
    fn registry_is_empty(
        self
    )
        -> bool
    fn default() -> Self
  struct CompilerCaches
    PROPERTIES:
    build: BuildCache, lowered: LoweredCache
  struct DependencyGraph
    PROPERTIES:
    forward: HashMap < SymbolId , HashSet < SymbolId > >, reverse: HashMap < SymbolId , HashSet < SymbolId > >, transitive_closure_cache: HashMap < SymbolId , HashSet < SymbolId > >, cycles: Vec < Vec < SymbolId > >
  struct FileGraph
    PROPERTIES:
    imports: HashMap < Uuid , Vec < Uuid > >, dependents: HashMap < Uuid , Vec < Uuid > >, topo_order: Vec < Uuid >, cycles: Vec < Vec < Uuid > >
  struct IRCache
    PROPERTIES:
    per_file: HashMap < Uuid , IR >, per_symbol: HashMap < SymbolId , IR >, dedup_cache: HashMap < u64 , IR >, ir_versions: HashMap < Uuid , u32 >, current: Option < IR >
  struct LoweredCache
    PROPERTIES:
    per_file: HashMap < Uuid , Vec < LoweredOp > >, per_symbol: HashMap < SymbolId , Vec < LoweredOp > >, backend_cache: HashMap < String , Vec < u8 > >, opt_pass_version: u32, current: Option < LoweredIR >
  struct LoweredIR
    PROPERTIES:
    nodes: Vec < IROp >
  struct SymbolIndex
    PROPERTIES:
    by_name: HashMap < String , Vec < SymbolId > >, by_file: HashMap < Uuid , Vec < SymbolId > >, fqns: HashMap < String , SymbolId >, scope_stack: Vec < Vec < SymbolId > >

--- # compiler/types.rs
  ENUMS:
  enum BuildArtifact { Object(_0: Vec < u8 >), Llvm(_0: Vec < u8 >), Wasm(_0: Vec < u8 >), Bytecode(_0: Vec < u8 >) }

--- # context/compile.rs
  STRUCTS:
  struct CompileContext
    PROPERTIES:
    env: Env, config: Config, state: CompileState, diagnostics: DiagnosticStore, cache: MemoryCache

    METHODS:
    fn new() -> Self

--- # context/context.rs
  STRUCTS:
  struct Context
    PROPERTIES:
    env: Env, config: Config, diagnostics: Arc < RwLock < DiagnosticStore > >, cache: MemoryCache

    METHODS:
    fn new() -> Self

--- # context/fs.rs
  STRUCTS:
  struct FS
    PROPERTIES:
    root: PathBuf, cwd: PathBuf, cache_dir: PathBuf, build_dir: PathBuf

    METHODS:
    fn source_path(
        self,
        file: & str
    )
        -> PathBuf
    fn cache_path(
        self
    )
        -> PathBuf
    fn build_path(
        self
    )
        -> PathBuf

--- # context/test.rs
  STRUCTS:
  struct TestContext
    PROPERTIES:
    logger: Logger, cache: MemoryCache, diagnostics: DiagnosticStore

    METHODS:
    fn new() -> Self

--- # development/server.rs
  ENUMS:
  enum Command { Build(_0: BuildCommand), Rebuild(_0: RebuildCommand), Clean(_0: CleanCommand), Inspect(_0: InspectCommand), Exit }
  enum Event { FileChanged(_0: FileChangedEvent), Command(_0: CommandEvent) }
  enum FileChangeKind { Created, Modified, Deleted }

  FUNCTIONS:
  fn start(
      kernel: Kernel
  )
  fn start_server(
      kernel: Kernel,
      config: CompileConfig
  )

  STRUCTS:
  struct BuildCommand
  struct CleanCommand
  struct CommandEvent
    PROPERTIES:
    command: Command
  struct CompileServer
    PROPERTIES:
    engine: CompileEngine, state: CompileState, watcher: Option < FileWatcher >, repl: Option < Repl >, events: CompilerEventBus

    METHODS:
    fn new(
        engine: CompileEngine,
        state: CompileState,
        watcher: Option < FileWatcher >,
        repl: Option < Repl >
    )
        -> Self
    fn run(
        self
    )
    fn execute(
        self,
        cmd: CommandEvent
    )
    fn rebuild(
        self,
        event: FileChangedEvent
    )
    fn next_event(
        self
    )
        -> Event
  struct FileChangedEvent
    PROPERTIES:
    path: PathBuf, kind: FileChangeKind
  struct InspectCommand
  struct RebuildCommand
  struct Repl

--- # development/watcher.rs
  STRUCTS:
  struct ChangeDetector
    METHODS:
    fn detect(
        self,
        old: & str,
        new: & str
    )
        -> bool
  struct FileWatcher
    METHODS:
    fn watch(
        kernel: Kernel,
        config: CompileConfig
    )
        -> Result < () , String >
  struct HotReloadManager
    METHODS:
    fn reload(
        self
    )
  struct IncrementalCompiler
    METHODS:
    fn invalidate(
        self,
        file: & str
    )

--- # diagnostics/mod.rs
  FUNCTIONS:
  fn diagnostics()

--- # frontend/ast.rs
  ENUMS:
  enum AssignOp { Assign, Immutable, Dynamic }
  enum BinOp { Add, Sub, Mul, Div, Eq, Neq, Lt, Gt, And, Or, Assign, Mod, Power }
  enum DeclKind { MutableStatic, ImmutableStatic, Dynamic }
  enum Expr { Identifier(name: String), Assign(left: Box < Expr >, right: Box < Expr >, op: AssignOp), Number(_0: HashF64), Unary(op: UnOp, expr: Box < Expr >), Binary(left: Box < Expr >, op: BinOp, right: Box < Expr >), Bool(_0: bool), String(_0: String), Var(_0: String), Array(_0: Vec < Expr >), Call(callee: Box < Expr >, args: Vec < Expr >), Index(target: Box < Expr >, index: Box < Expr >), Member(target: Box < Expr >, field: String) }
  enum Stmt { Let(name: String, kind: DeclKind, value: Expr), Print(expr: Expr), ExprStmt(expr: Expr), Function(name: String, params: Vec < String >, body: Vec < Stmt >), Return(value: Option < Expr >), If(condition: Expr, then_branch: Vec < Stmt >, else_branch: Option < Vec < Stmt > >), While(condition: Expr, body: Vec < Stmt >), Loop(body: Vec < Stmt >), For(iterator: String, iterable: Expr, body: Vec < Stmt >), DoWhile(body: Vec < Stmt >, condition: Expr), Block(body: Vec < Stmt >) }
  enum UnOp { Neg, Not, AddrOf }

  STRUCTS:
  struct AST
    PROPERTIES:
    program: Program, stmts: Vec < Stmt >

    METHODS:
    fn new(
        stmts: Vec < Stmt >
    )
        -> Self
    fn to_sexpr(
        self
    )
        -> String
  struct HashF64
    METHODS:
    fn eq(
        self,
        other: & Self
    )
        -> bool
    fn hash(
        self,
        state: & mut H
    )
    fn fmt(
        self,
        f: & mut fmt :: Formatter < '_ >
    )
        -> fmt :: Result
  struct Program
    PROPERTIES:
    stmts: Vec < Stmt >, modules: Vec < Module >, globals: Vec < Stmt >, entry: Option < Block >

    METHODS:
    fn new(
        stmts: Vec < Stmt >
    )
        -> Self
    fn default() -> Self

--- # frontend/lexer.rs
  FUNCTIONS:
  fn find_comment_end(
      input: & str
  )
      -> Option < usize >
  fn lex(
      input: & str
  )
      -> Result < Vec < Token > , String >
  fn lex_number(
      chars: & mut std :: iter :: Peekable < std :: str :: Chars >
  )
      -> Result < f64 , String >

--- # frontend/parser.rs
  FUNCTIONS:
  fn flatten_assign(
      expr: Expr
  )
      -> Expr
  fn is_assignable(
      expr: & Expr
  )
      -> bool
  fn is_expr_start(
      tok: Option < & Token >
  )
      -> bool
  fn is_simple_var(
      expr: & Expr
  )
      -> bool
  fn kind_from_token(
      tok: & Token
  )
      -> DeclKind
  fn looks_like_declaration(
      tokens: & mut Peekable < I >
  )
      -> bool
  fn parse(
      tokens: & mut TokenStream,
      diagnostics: & mut DiagnosticStore
  )
      -> Result < AST , DiagnosticStore >
  fn parse_add_sub(
      tokens: & mut TokenStream,
      diagnostics: & mut DiagnosticStore
  )
      -> Result < Expr , String >
  fn parse_and(
      tokens: & mut TokenStream,
      diagnostics: & mut DiagnosticStore
  )
      -> Result < Expr , String >
  fn parse_array(
      tokens: & mut TokenStream,
      diagnostics: & mut DiagnosticStore
  )
      -> Result < Expr , String >
  fn parse_assignment(
      tokens: & mut TokenStream,
      lhs: Option < Expr >,
      diagnostics: & mut DiagnosticStore
  )
      -> Result < Expr , String >
  fn parse_comparison(
      tokens: & mut TokenStream,
      diagnostics: & mut DiagnosticStore
  )
      -> Result < Expr , String >
  fn parse_equality(
      tokens: & mut TokenStream,
      diagnostics: & mut DiagnosticStore
  )
      -> Result < Expr , String >
  fn parse_expr(
      tokens: & mut TokenStream,
      diagnostics: & mut DiagnosticStore
  )
      -> Result < Expr , String >
  fn parse_incremental(
      prev: & AST,
      tokens: & mut TokenStream,
      diagnostics: & mut DiagnosticStore
  )
      -> Result < AST , DiagnosticStore >
  fn parse_let(
      tokens: & mut TokenStream,
      diagnostics: & mut DiagnosticStore
  )
      -> Result < Stmt , String >
  fn parse_member_and_index_chain(
      expr: Expr,
      tokens: & mut TokenStream,
      diagnostics: & mut DiagnosticStore
  )
      -> Result < Expr , String >
  fn parse_mul_div(
      tokens: & mut TokenStream,
      diagnostics: & mut DiagnosticStore
  )
      -> Result < Expr , String >
  fn parse_or(
      tokens: & mut TokenStream,
      diagnostics: & mut DiagnosticStore
  )
      -> Result < Expr , String >
  fn parse_postfix(
      tokens: & mut TokenStream,
      diagnostics: & mut DiagnosticStore
  )
      -> Result < Expr , String >
  fn parse_power(
      tokens: & mut TokenStream,
      diagnostics: & mut DiagnosticStore
  )
      -> Result < Expr , String >
  fn parse_primary(
      tokens: & mut TokenStream,
      diagnostics: & mut DiagnosticStore
  )
      -> Result < Expr , String >
  fn parse_program(
      tokens: & mut TokenStream,
      diagnostics: & mut DiagnosticStore
  )
      -> Result < AST , DiagnosticStore >
  fn parse_stmt(
      tokens: & mut TokenStream,
      diagnostics: & mut DiagnosticStore
  )
      -> Result < Stmt , String >
  fn parse_unary(
      tokens: & mut TokenStream,
      diagnostics: & mut DiagnosticStore
  )
      -> Result < Expr , String >

  STRUCTS:
  struct Parser
    METHODS:
    fn new() -> Self
    fn parse(
        self,
        tokens: TokenStream,
        diagnostics: & mut DiagnosticStore
    )
        -> Result < AST , DiagnosticStore >
    fn parse_incremental(
        self,
        prev: & AST,
        tokens: & mut TokenStream,
        diagnostics: & mut DiagnosticStore
    )
        -> Result < AST , DiagnosticStore >

--- # frontend/token.rs
  ENUMS:
  enum Token { Eq, Neq, Immutable, Dynamic, EqualsColon, Or, And, Inc, Dec, Floor, Ge, Le, Assign, Not, Ampersand, Colon, Pipe, Plus, Minus, Slash, Gt, Lt, Star, Mod, Power, Dot, LBrace, RBrace, LBracket, RBracket, LParen, RParen, Semicolon, Comma, LineNote, BlockNote, RawStart, RawEnd, Let, Dependency, Package, Module, Public, Private, Print, If, ElseIf, Else, Unless, Switch, Case, Default, Match, Pipeline, Function, Yield, Next, Return, Do, Loop, Until, While, For, Of, In, Break, Continue, Is, Assert, Try, Catch, Finally, Throw, Enum, Struct, Trait, Impl, As, True, False, OrAlias, AndAlias, Ident(_0: String), Number(_0: f64), String(_0: String), Error, EOF }

  FUNCTIONS:
  fn lex_block_note(
      lex: & mut Lexer < Token >
  )
      -> logos :: Filter < () >
  fn lex_line_note(
      lex: & mut Lexer < Token >
  )
      -> logos :: Filter < () >
  fn lex_raw_block(
      lex: & mut Lexer < Token >
  )
      -> logos :: Filter < () >

--- # frontend/token_seeds.rs
  ENUMS:
  enum Identifiers_06 { Dependency, Package, Module, Public, Private, Print, If, ElseIf, Else, Unless, Switch, Case, Default, Match, Pipeline, Function, Yield, Next, Return, Do, Loop, Until, While, For, Of, In, Break, Continue, Is, Assert, Try, Catch, Finally, Throw, Enum, Struct, Trait, Impl, As, True, False, OrAlias, AndAlias, Let }
  enum Meta { LineNote, BlockNote, RawStart, RawEnd }
  enum Meta_05 { LineNote, BlockNote, RawStart, RawEnd }
  enum MultiChar_02 { Eq, Neq, Immutable, Dynamic, EqualsColon, Or, And, Inc, Dec, Floor, Ge, Le }
  enum SingleChar_03 { Assign, Not, Ampersand, Colon, Pipe, Plus, Minus, Slash, Gt, Lt, Star, Mod, Power }
  enum Structural_04 { Dot, LBrace, RBrace, LBracket, RBracket, LParen, RParen, Semicolon, Comma }

--- # frontend/types.rs
  STRUCTS:
  struct Lexer
    PROPERTIES:
    state: LexerState, config: LexerConfig
  struct LexerConfig
    PROPERTIES:
    allow_unicode_identifiers: bool, allow_raw_strings: bool, comment_support: bool
  struct LexerState
    PROPERTIES:
    position: usize, line: usize, column: usize
  struct TokenStream
    PROPERTIES:
    tokens: Vec < Token >, pos: usize

--- # middle/ir.rs
  ENUMS:
  enum IROp { ExprStmt(expr: IRVal), Temp(value: IRVal), Unary(op: UnOp, value: IRVal), Array(values: Vec < IRVal >), Assign(name: String, value: IRVal), Expr(value: IRVal), Print(value: IRVal), Declare(name: String, value: IRVal, mutable: bool, dynamic: bool), Return(value: Option < IRVal >), Nop, Binary(left: IRVal, op: BinOp, right: IRVal), Module(body: Vec < IROp >), Function(name: String, params: Vec < (String , Type) >, body: Vec < IROp >, return_type: Type), Block(body: Vec < IROp >), Load(name: String), If(condition: IRVal, then_branch: Vec < IROp >, else_branch: Vec < IROp >, scope_id: usize), Call(name: String, args: Vec < IRVal >), ExternalCall(namespace: String, function: String, args: Vec < IRVal >), ModuleScope(name: String, body: Vec < IROp >), While(condition: IRVal, body: Vec < IROp >), DoWhile(body: Vec < IROp >, condition: IRVal), Loop(body: Vec < IROp >), For(iterator: String, iterable: IRVal, body: Vec < IROp >), ControlFlow, Lowered(_0: LoweredOp) }
  enum LoweredOp { Binary(target: String, left: String, op: Op, right: String), Move(target: String, source: String), Label(_0: String), Jump(_0: String), JumpIf(condition: String, label: String), Nop }
  enum Op { Add, Sub, Mul, Div, Cmp, Neg }
  enum RegionKind { Native, JavaScript, TypeScript, JSX, SQL, Python, Shader, Unknown(_0: String) }
  enum RegionMode { Passthrough, CompileAndInject, Dual }

  FUNCTIONS:
  fn expr_to_irval(
      expr: Expr
  )
      -> IRVal
  fn to_typed_expr(
      expr: Expr
  )
      -> TypedExpr

  STRUCTS:
  struct BasicBlock
    PROPERTIES:
    ops: Vec < IROp >
  struct FunctionIR
    PROPERTIES:
    name: String, blocks: Vec < BasicBlock >
  struct IR
    PROPERTIES:
    raw: String, nodes: Vec < IROp >, symbols: HashMap < String , Symbol >, metadata: HashMap < String , String >, ops: Vec < IROp >, modules: Vec < ModuleIR >, functions: Vec < FunctionIR >

    METHODS:
    fn fmt(
        self,
        f: & mut fmt :: Formatter < '_ >
    )
        -> fmt :: Result
    fn new() -> Self
    fn from_module(
        module: ModuleIR
    )
        -> Self
    fn from_ops(
        ops: Vec < IROp >
    )
        -> Self
    fn with_metadata(
        self,
        key: impl Into < String >,
        value: impl Into < String >
    )
        -> Self
    fn raw(
        content: impl Into < String >
    )
        -> Self
    fn default() -> Self
    fn new_from_ops(
        ops: Vec < IROp >
    )
        -> Self
    fn with_stage(
        self,
        stage: & str
    )
        -> Self
  struct ModuleIR
    PROPERTIES:
    name: String, functions: Vec < FunctionIR >, globals: Vec < IROp >, exports: Vec < String >
  struct RegionBlock
    PROPERTIES:
    kind: RegionKind, source: String, output: Option < Vec < u8 > >, mode: RegionMode
  struct TypedExpr
    PROPERTIES:
    expr: Expr, ty: Type, span: Span

--- # middle/semantic.rs
  FUNCTIONS:
  fn analyze(
      ast: AST
  )
      -> Result < Vec < IROp > , String >
  fn analyze_block(
      block: Vec < Stmt >,
      symbols: & mut HashMap < String , Type >
  )
      -> Result < Vec < IROp > , String >
  fn analyze_stmt(
      stmt: Stmt,
      symbols: & mut HashMap < String , Type >
  )
      -> Result < Vec < IROp > , String >
  fn annotate_types(
      expr: & mut Expr,
      symbol_table: & HashMap < String , Type >
  )
      -> Type
  fn infer_type(
      expr: & Expr,
      symbols: & HashMap < String , Type >
  )
      -> Result < Type , String >
  fn one(
      op: IROp
  )
      -> Vec < IROp >
  fn wrap_to_irval(
      expr: Expr,
      symbols: & HashMap < String , Type >,
      _span: Span
  )
      -> Result < IRVal , String >
  fn wrap_typed(
      expr: Expr,
      symbols: & HashMap < String , Type >,
      span: Span
  )
      -> Result < TypedExpr , String >

  STRUCTS:
  struct SemanticAnalyzer
    PROPERTIES:
    symbols: HashMap < String , Type >, scope_counter: AtomicUsize

    METHODS:
    fn new() -> Self
    fn analyze(
        ast: AST
    )
        -> Result < Vec < IROp > , String >
    fn analyze_block(
        block: Vec < Stmt >,
        symbols: & mut HashMap < String , Type >
    )
        -> Result < Vec < IROp > , String >

--- # middle/types.rs
  ENUMS:
  enum IRVal { Number(_0: HashF64), Bool(_0: bool), Str(_0: String), Var(_0: String), Temp(_0: String), Unit }
  enum LoweredExpr { Value(_0: IRVal), Op(_0: IROp) }
  enum ModuleItem { Function(_0: Function), Struct(_0: Struct), Enum(_0: Enum), Const(_0: Stmt), Use(_0: Import) }
  enum TopLevelItem { Module(_0: Module), Function(_0: Function), Struct(_0: Struct), Enum(_0: Enum), Const(_0: Stmt), Use(_0: Import), Stmt(_0: Stmt) }
  enum Type { I32, F64, Bool, Str, Void, Ptr(_0: Box < Type >), Array(_0: Box < Type >), Return, Unknown }

  STRUCTS:
  struct Block
    PROPERTIES:
    stmts: Vec < Stmt >
  struct Enum
    PROPERTIES:
    name: String, variants: Vec < Variant >
  struct Field
    PROPERTIES:
    name: String, ty: Type
  struct Function
    PROPERTIES:
    name: String, params: Vec < Param >, body: Block
  struct Import
    PROPERTIES:
    path: Vec < String >, alias: Option < String >, glob: bool
  struct Module
    PROPERTIES:
    name: String, items: Vec < ModuleItem >
  struct Param
    PROPERTIES:
    name: String, ty: Option < Type >
  struct Span
    PROPERTIES:
    file: PathBuf, start: usize, end: usize
  struct Struct
    PROPERTIES:
    name: String, fields: Vec < Field >
  struct Variant
    PROPERTIES:
    name: String, fields: Vec < Type >

--- # pipeline/backend.rs
  ENUMS:
  enum BackendTarget { Bytecode, LLVM, WASM }
  enum OptimizationLevel { None, Basic, Aggressive }

  STRUCTS:
  struct BackendPipeline
    PROPERTIES:
    llvm_context: Mutex < inkwell :: context :: Context >, metadata: Metadata, context: Arc < Context >, config: Arc < RwLock < CompileConfig > >, state: Arc < RwLock < CompileState > >, target: BackendTarget, opt_level: OptimizationLevel, codegen_config: CodegenConfig, debug: bool

    METHODS:
    fn new(
        context: Arc < Context >,
        config: Arc < RwLock < CompileConfig > >,
        state: Arc < RwLock < CompileState > >
    )
        -> Self
    fn with_name(
        name: & str,
        context: Arc < Context >,
        config: Arc < RwLock < CompileConfig > >,
        state: Arc < RwLock < CompileState > >
    )
        -> Self
    fn with_target(
        self,
        target: BackendTarget
    )
        -> Self
    fn with_opt_level(
        self,
        level: OptimizationLevel
    )
        -> Self
    fn with_codegen_config(
        self,
        cfg: CodegenConfig
    )
        -> Self
    fn with_debug(
        self,
        debug: bool
    )
        -> Self
    fn run(
        self,
        ir: IR
    )
        -> Vec < u8 >
    fn codegen(
        self,
        ir: IR
    )
        -> Result < Vec < u8 > , CompileError >
    fn codegen_llvm(
        self,
        ir: IR
    )
        -> Result < Vec < u8 > , CompileError >
    fn codegen_wasm(
        self,
        ir: IR
    )
        -> Result < Vec < u8 > , CompileError >
    fn create_native_target_machine(
        self
    )
        -> Result < TargetMachine , CompileError >
    fn emit_node(
        self,
        node: IROp
    )
    fn emit_bytecode(
        self,
        ir: IR
    )
        -> Vec < u8 >
    fn emit_llvm(
        self,
        _ir: IR
    )
        -> Vec < u8 >
    fn emit_wasm(
        self,
        _ir: IR
    )
        -> Vec < u8 >
    fn default() -> Self
  struct CodegenConfig
    PROPERTIES:
    emit_debug_info: bool, inline_functions: bool, vectorize: bool

--- # pipeline/frontend.rs
  STRUCTS:
  struct FrontendFeatures
    PROPERTIES:
    enable_macros: bool, enable_jsx_like_blocks: bool, strict_mode: bool
  struct FrontendPipeline
    PROPERTIES:
    metadata: Metadata, context: Arc < Context >, config: Arc < RwLock < CompileConfig > >, state: Arc < RwLock < CompileState > >, lexer: Arc < RwLock < Lexer > >, parser: Arc < RwLock < Parser > >, features: FrontendFeatures

    METHODS:
    fn new(
        context: Arc < Context >,
        config: Arc < RwLock < CompileConfig > >,
        state: Arc < RwLock < CompileState > >
    )
        -> Self
    fn with_name(
        name: & str,
        context: Arc < Context >,
        config: Arc < RwLock < CompileConfig > >,
        state: Arc < RwLock < CompileState > >
    )
        -> Self
    fn with_features(
        self,
        features: FrontendFeatures
    )
        -> Self
    fn perform_compilation(
        self
    )
        -> Result < AST , DiagnosticStore >
    fn default() -> Self

--- # pipeline/middle.rs
  FUNCTIONS:
  fn lower_atomic(
      expr: Expr
  )
      -> Result < IRVal , CompileError >
  fn lower_expr_as_op(
      expr: Expr
  )
      -> Result < IROp , CompileError >
  fn lower_expr_as_value(
      expr: Expr
  )
      -> Result < IRVal , CompileError >

  STRUCTS:
  struct IRConfig
    PROPERTIES:
    preserve_raw_blocks: bool, optimize_early: bool
  struct MiddleFeatures
    PROPERTIES:
    enable_type_checking: bool, enable_macro_expansion: bool, enable_dead_code_analysis: bool
  struct MiddlePipeline
    PROPERTIES:
    metadata: Metadata, context: Arc < Context >, config: Arc < RwLock < CompileConfig > >, state: Arc < RwLock < CompileState > >, ir_config: IRConfig, features: MiddleFeatures, temp_counter: std :: sync :: atomic :: AtomicUsize, symbols: HashMap < String , SymbolInfo >

    METHODS:
    fn new(
        context: Arc < Context >,
        config: Arc < RwLock < CompileConfig > >,
        state: Arc < RwLock < CompileState > >
    )
        -> Self
    fn with_name(
        name: & str,
        context: Arc < Context >,
        config: Arc < RwLock < CompileConfig > >,
        state: Arc < RwLock < CompileState > >
    )
        -> Self
    fn with_ir_config(
        self,
        config: IRConfig
    )
        -> Self
    fn with_features(
        self,
        features: MiddleFeatures
    )
        -> Self
    fn run(
        self,
        engine: & CompileEngine
    )
        -> Result < () , CompileError >
    fn lower_ast(
        self,
        ast: AST
    )
        -> Result < Vec < IROp > , CompileError >
    fn lower_expr(
        self,
        expr: Expr
    )
        -> Result < LoweredExpr , CompileError >
    fn lower_expr_stmt(
        self,
        expr: Expr
    )
        -> Result < IROp , CompileError >
    fn lower_stmt(
        self,
        stmt: Stmt
    )
        -> Result < IROp , CompileError >
    fn lower_op(
        self,
        op: IROp
    )
        -> Result < IROp , CompileError >
    fn expr_to_irval_from_value(
        self,
        val: IRVal
    )
        -> Result < IRVal , CompileError >
    fn handle_assignment(
        self,
        left: Expr,
        right: Expr,
        op: AssignOp,
        span: Option < Span >
    )
        -> Result < IROp , CompileError >
    fn expr_to_irval(
        self,
        expr: Expr
    )
        -> Result < IRVal , CompileError >
    fn name(
        self
    )
        -> & str
    fn resolve_symbols(
        self,
        _ast: & AST
    )
    fn emit_temp(
        self
    )
        -> String
    fn default() -> Self
  struct SymbolInfo
    PROPERTIES:
    is_mutable: bool, is_initialized: bool, declared_at: Option < Span >

--- # pipeline/mod.rs
  ENUMS:
  enum CompileError { Frontend(_0: String), Middle(_0: String), Backend(_0: String), Stage(stage: String, source: Box < dyn std :: error :: Error >) }

  STRUCTS:
  struct Metadata
    PROPERTIES:
    name: String, version: String

    METHODS:
    fn default() -> Self

--- # pipeline/runner.rs
  STRUCTS:
  struct PipelineRunner
    PROPERTIES:
    stages: Vec < Box < dyn Stage > >

    METHODS:
    fn new() -> Self
    fn add_stage(
        self,
        stage: S
    )
    fn run(
        self,
        engine: & CompileEngine
    )
        -> Result < () , CompileError >

--- # registry/extended.rs
  ENUMS:
  enum WebTarget { Html, Css, Js }

  FUNCTIONS:
  fn extract_web_target(
      name: & str
  )
      -> Option < WebTarget >
  fn web_target(
      ext: & str
  )
      -> Option < WebTarget >

--- # registry/file_meta.rs
  STRUCTS:
  struct FileMeta
    PROPERTIES:
    id: Uuid, filename: String, namespace: String, name: String, utter: Option < String >, version: u32, tag: Option < String >, variant: Option < String >, ext: String, path: PathBuf, active: bool, capabilities: Vec < String >

    METHODS:
    fn default() -> Self
    fn identity(
        self
    )
        -> GroupKey
    fn group_key(
        self
    )
        -> GroupKey
    fn new(
        stem: & str,
        filename: String,
        path: PathBuf,
        dedup: bool
    )
        -> Self
    fn from_path(
        path: & Path,
        _root: & Path
    )
        -> Self
    fn get_name(
        input: & str
    )
        -> String
    fn get_namespace(
        input: & str
    )
        -> String
    fn parse_namespace(
        input: & str
    )
        -> (Option < String > , & str)
    fn get_utter(
        identity_part: & str
    )
        -> Option < String >
    fn get_version(
        meta: & str
    )
        -> u32
    fn get_variant(
        stem: & str
    )
        -> Option < String >
    fn get_tag(
        stem: & str
    )
        -> Option < String >
    fn get_ext(
        filename: & str
    )
        -> String
    fn capabilities(
        self,
        parsed: & ParsedPath
    )
        -> Vec < String >
    fn infer_capabilities(
        ext: & str
    )
        -> Vec < String >
    fn get_fs_name(
        self
    )
        -> String
    fn wrapped_extension(
        self
    )
        -> Option < & str >
    fn is_loi(
        self
    )
        -> bool
    fn is_wrapped_loi(
        self
    )
        -> bool
    fn mock(
        filename: & str
    )
        -> Self
  struct GroupKey
    PROPERTIES:
    namespace: String, name: String, utter: Option < String >, variant: Option < String >, ext: String
  struct ParsedPath
    PROPERTIES:
    variant: Option < String >, version: u32, is_versioned: bool, is_ui: bool

    METHODS:
    fn from(
        path: & Path
    )
        -> Self

--- # registry/registry.rs
  STRUCTS:
  struct FileStack
    PROPERTIES:
    files: Vec < FileMeta >, active_file: FileMeta

    METHODS:
    fn group_key(
        self
    )
        -> GroupKey
  struct Registry
    PROPERTIES:
    files: HashMap < Uuid , FileMeta >, files_archive: Vec < FileMeta >, from_files: Vec < FileMeta >, stacks: Vec < FileStack >, active_by_group: HashMap < GroupKey , Uuid >

    METHODS:
    fn new() -> Self
    fn is_empty(
        self
    )
        -> bool
    fn from_files(
        files: Vec < FileMeta >
    )
        -> Self
    fn add_file(
        self,
        meta: FileMeta
    )
    fn build_source(
        root: & Path
    )
        -> Vec < FileMeta >
    fn organize(
        files: Vec < FileMeta >
    )
        -> Vec < FileStack >
    fn scan(
        root: impl Into < PathBuf >
    )
        -> Self
    fn is_active(
        self,
        f: & FileMeta
    )
        -> bool
    fn find_active_by_name(
        self,
        name: & str
    )
        -> Option < & FileMeta >
    fn compare_stacks(
        a: & FileMeta,
        b: & FileMeta
    )
        -> std :: cmp :: Ordering
    fn list_all(
        self
    )

--- # init.rs
FUNCTIONS:
fn init() -> Kernel

--- # kernel.rs
STRUCTS:
struct Kernel
  PROPERTIES:
  context: Arc < Context >, engine: Arc < CompileEngine >, logger: Arc < Logger >, cache: Arc < MemoryCache >, job_queue: Arc < JobQueue >, scheduler: TaskScheduler, diagnostics: Arc < RwLock < DiagnosticStore > >
struct KernelBuilder
  PROPERTIES:
  context: Option < Arc < Context > >, engine: Option < Arc < CompileEngine > >, logger: Option < Arc < Logger > >, cache: Option < Arc < MemoryCache > >, job_queue: Option < Arc < JobQueue > >, scheduler: Option < TaskScheduler >, diagnostics: Option < Arc < RwLock < DiagnosticStore > > >

  METHODS:
  fn new() -> Self
  fn context(
      self,
      context: Arc < Context >
  )
      -> Self
  fn engine(
      self,
      engine: Arc < CompileEngine >
  )
      -> Self
  fn logger(
      self,
      logger: Arc < Logger >
  )
      -> Self
  fn cache(
      self,
      cache: Arc < MemoryCache >
  )
      -> Self
  fn job_queue(
      self,
      queue: Arc < JobQueue >
  )
      -> Self
  fn scheduler(
      self,
      scheduler: TaskScheduler
  )
      -> Self
  fn diagnostics(
      self,
      diagnostics: Arc < RwLock < DiagnosticStore > >
  )
      -> Self
  fn build(
      self
  )
      -> Kernel
struct KernelContext
  PROPERTIES:
  context: Arc < Context >, logger: Arc < Logger >, cache: Arc < MemoryCache >, job_queue: Arc < JobQueue >, scheduler: Arc < TaskScheduler >, diagnostics: Arc < DiagnosticStore >

--- # main.rs
FUNCTIONS:
fn main()

--- # EMPTY FILES
  /Users/future/KB/project/app/loi/src/backend/symbol/mod.rs
  /Users/future/KB/project/app/loi/src/backend/utter/mod.rs
  /Users/future/KB/project/app/loi/src/backend/mod.rs
  /Users/future/KB/project/app/loi/src/build/mod.rs
  /Users/future/KB/project/app/loi/src/cli/mod.rs
  /Users/future/KB/project/app/loi/src/context/mod.rs
  /Users/future/KB/project/app/loi/src/development/mod.rs
  /Users/future/KB/project/app/loi/src/frontend/display.rs
  /Users/future/KB/project/app/loi/src/frontend/mod.rs
  /Users/future/KB/project/app/loi/src/interface/engine_provider.rs
  /Users/future/KB/project/app/loi/src/interface/fs.rs
  /Users/future/KB/project/app/loi/src/interface/mod.rs
  /Users/future/KB/project/app/loi/src/middle/mod.rs
  /Users/future/KB/project/app/loi/src/middle/optimize.rs
  /Users/future/KB/project/app/loi/src/pipeline/stage.rs
  /Users/future/KB/project/app/loi/src/registry/display.rs
  /Users/future/KB/project/app/loi/src/registry/mod.rs
  /Users/future/KB/project/app/loi/src/registry/test_utils.rs
  /Users/future/KB/project/app/loi/src/ui/mod.rs
  /Users/future/KB/project/app/loi/src/lib.rs
