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

--- # kernel.rs
STRUCTS:
struct Kernel
  PROPERTIES:
  context, engine, logger, cache, job_queue, scheduler, diagnostics
struct KernelBuilder
  PROPERTIES:
  context, engine, logger, cache, job_queue, scheduler, diagnostics

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

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

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

--- # backend/llvm.rs
  STRUCTS:
  struct CodeGenContext
    PROPERTIES:
    context, module, builder, runtime, env, counter
  struct LLVM
    PROPERTIES:
    context
  struct Runtime
    PROPERTIES:
    main, entry_block, printf, fmt_f64, fmt_i32, fmt_str

  FUNCTIONS:
  fn codegen_expr(expr: & Expr, ty: & Type, context: & mut CodeGenContext < 'ctx >)
  fn codegen_ir_value(val: IRVal, ctx: & mut CodeGenContext < 'ctx >)
  fn fmt_for_irval(val: & IRVal, context: & CodeGenContext < 'ctx >)
  fn lower_ast_to_ir(ast: & AST)
  fn lower_expr_to_ir(context: & mut CodeGenContext < 'ctx >, op: IROp)
  fn lower_expr_to_ir_value(expr: & Expr)
  fn lower_typed_expr_to_ir_value(expr: & TypedExpr)

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

--- # build/artifact.rs
  STRUCTS:
  struct Artifact
    PROPERTIES:
    path, bytes, kind
  struct CompiledArtifact
    PROPERTIES:
    ir, bundle

  ENUMS:
  enum ArtifactKind { Web, Loi }

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

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

--- # build/build_system.rs
  STRUCTS:
  struct BuildContext
    PROPERTIES:
    build_id, started_at, dir_root, dir_out, watch, clean, verbose
  struct BuildSystem
    PROPERTIES:
    context, registry, utters, bundle_service

    METHODS:
      fn new(kernel: Kernel)
      fn test()

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

    METHODS:
      fn new(manifest: BundleConfig)
      fn get_web_path(self, file: & FileMeta)
      fn get_loi_path(self, file: & FileMeta)
      fn get_stripped_base_name(self, meta: & FileMeta)

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

    METHODS:
      fn default()
  struct BundleService
    PROPERTIES:
    registry, utter_registry, symbols, manifest, resolver, optimizer

    METHODS:
      fn new(registry: Registry, manifest: BundleConfig, utter: UtterRegistry)
      fn rebuild_symbols(self)
      fn compile_all(self, files: & [FileMeta])
      fn compile(self, file: & FileMeta)

--- # cli/args.rs
  STRUCTS:
  struct CliArgs
    PROPERTIES:
    watch, input, output, concurrency

--- # cli/command.rs
  STRUCTS:
  struct BuildAllArgs
    PROPERTIES:
    target, flags
  struct BuildFlags
    PROPERTIES:
    force, ext, filter
  struct CommandMeta
    PROPERTIES:
    label, alias, description, hidden, weight
  struct ViewArgs
    PROPERTIES:
    target, flags
  struct ViewFlags
    PROPERTIES:
    name, number, sort

  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 }

--- # cli/controller.rs
  STRUCTS:
  struct CliController
    PROPERTIES:
    system, history_path, current_namespace, verbosity

    METHODS:
      fn new(system: BuildSystem)
      fn run(self)
      fn build_index(self)
      fn resolve_target(_registry: & 'a Registry, files: & [& 'a FileMeta], target: & BuildTarget)
      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
  STRUCTS:
  struct FileView
    PROPERTIES:
    namespace, index, filename, active, name, utter, version, tag, ext, capabilities
  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)
      fn header(text: & str)
      fn error(text: & str)
      fn success(text: & str)
      fn highlight(text: & str)

  ENUMS:
  enum ListFilter { Active, Archived, All }

--- # 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)
  struct CompilationCache
    PROPERTIES:
    cache

    METHODS:
      fn new()
  struct MemoryCache
    PROPERTIES:
    map

    METHODS:
      fn new()
  struct NetworkCache
  struct PersistentCache
    PROPERTIES:
    disk_path

    METHODS:
      fn new()

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

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

--- # compiler/config.rs
  STRUCTS:
  struct CompileConfig
    PROPERTIES:
    root, name, input, output, watch, concurrency

    METHODS:
      fn from(cfg: Config)
      fn default()
  struct Config
    PROPERTIES:
    root, name, input, output, watch, concurrency

    METHODS:
      fn default()
  struct ConfigResolver
    METHODS:
      fn resolve(sources: Vec < ConfigSource >)
      fn merge(base: Config, override_cfg: Config)
      fn load_file(_path: & Path)
      fn parse_cli(_args: Vec < String >)

  ENUMS:
  enum ConfigSource { Defaults, File(_0: PathBuf), Cli(_0: CliArgs), ReplOverrides }

--- # compiler/diagnostic.rs
  STRUCTS:
  struct CompilerEventBus
  struct Diagnostic
    PROPERTIES:
    message, code, span, severity, notes, suggestions

    METHODS:
      fn new(message: impl Into < String >, span: Span, severity: Severity)
      fn default()
      fn error(message: impl Into < String >, span: Span)
      fn warning(message: impl Into < String >, span: Span)
      fn with_note(self, note: impl Into < String >)
      fn with_suggestion(self, suggestion: impl Into < String >)
      fn with_code(self, code: impl Into < String >)
  struct DiagnosticStore
    PROPERTIES:
    halt_on_error, error_count, diagnostics

    METHODS:
      fn emit(self, diag: Diagnostic)
      fn check_halt(self)
      fn new(halt_on_error: bool)
      fn has_errors(self)
      fn clear(self)
      fn flush(self)
  struct Inspector
  struct Logger
    METHODS:
      fn log(self, msg: & str)
      fn test()
  struct Profiler
    METHODS:
      fn new()
  struct TraceSystem
    METHODS:
      fn new()

  ENUMS:
  enum Severity { Info, Warning, Error, Hint }

--- # compiler/engine.rs
  STRUCTS:
  struct CompileEngine
    PROPERTIES:
    state, config, stages

    METHODS:
      fn run_all(self)
      fn new(context: Arc < Context >, config: Arc < RwLock < CompileConfig > >, state: Arc < RwLock < CompileState > >)
      fn default()

--- # compiler/env.rs
  STRUCTS:
  struct Env
    PROPERTIES:
    root_dir, output_dir, mode, target, features, toolchain, cwd, timestamp

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

    METHODS:
      fn default()
  struct TargetConfig
    PROPERTIES:
    os, arch, abi

    METHODS:
      fn default()
  struct ToolchainPaths
    PROPERTIES:
    llvm_bin, linker, assembler, wasm_toolchain, custom_backend

    METHODS:
      fn default()

  ENUMS:
  enum Mode { Batch, Interactive, Watch }
  enum TargetArch { X86_64, AArch64, RISCV64, Unknown }
  enum TargetOS { Linux, MacOS, Windows, Unknown }

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

--- # compiler/execution.rs
  STRUCTS:
  struct JobQueue
    PROPERTIES:
    jobs

    METHODS:
      fn new()
  struct PluginSystem
  struct PrioritySystem
    PROPERTIES:
    priority_map

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

--- # compiler/mod.rs
  STRUCTS:
  struct Compiler
    PROPERTIES:
    pipelines

    METHODS:
      fn compile(self)

--- # 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, ir_cache, symbol_cache, timestamps, cache_version, current

    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:
    source, ast, registry, file_graph, dependency_graph, symbols, symbol_index, ir, ir_cache, lowered_cache, dirty_files, dirty_symbols, content_hashes, build_cache, compiler_version, ir_version

    METHODS:
      fn current_ir(self)
      fn current_lowered_ir(self)
      fn current_artifact(self)
      fn registry_is_empty(self)
      fn default()
  struct DependencyGraph
    PROPERTIES:
    forward, reverse, transitive_closure_cache, cycles
  struct FileGraph
    PROPERTIES:
    imports, dependents, topo_order, cycles
  struct IRCache
    PROPERTIES:
    per_file, per_symbol, dedup_cache, ir_versions, current
  struct LoweredCache
    PROPERTIES:
    per_file, per_symbol, backend_cache, opt_pass_version, current
  struct LoweredIR
    PROPERTIES:
    nodes
  struct SymbolIndex
    PROPERTIES:
    by_name, by_file, fqns, scope_stack

--- # 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, config, state, diagnostics, cache

    METHODS:
      fn new()

--- # context/context.rs
  STRUCTS:
  struct Context
    PROPERTIES:
    env, config, diagnostics, cache

    METHODS:
      fn new()

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

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

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

    METHODS:
      fn new()

--- # development/server.rs
  STRUCTS:
  struct BuildCommand
  struct CleanCommand
  struct CommandEvent
    PROPERTIES:
    command
  struct CompileServer
    PROPERTIES:
    engine, state, watcher, repl, events

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

  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)

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

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

--- # frontend/ast.rs
  STRUCTS:
  struct AST
    PROPERTIES:
    program, stmts

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

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

  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 { Number(_0: HashF64), Unary(op: UnOp, expr: Box < Expr >), Binary(left: Box < Expr >, op: BinOp, right: Box < Expr >), Assign(left: Box < Expr >, right: Box < Expr >, op: AssignOp), 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 }

--- # frontend/lexer.rs
  FUNCTIONS:
  fn find_comment_end(input: & str)
  fn lex(input: & str)
  fn lex_number(chars: & mut std :: iter :: Peekable < std :: str :: Chars >)

--- # frontend/parser.rs
  STRUCTS:
  struct Parser
    METHODS:
      fn new()
      fn parse(self, tokens: TokenStream, diagnostics: & mut DiagnosticStore)
      fn parse_incremental(self, prev: & AST, tokens: & mut TokenStream, diagnostics: & mut DiagnosticStore)

  FUNCTIONS:
  fn is_assignable(expr: & Expr)
  fn is_expr_start(tok: Option < & Token >)
  fn kind_from_token(tok: & Token)
  fn looks_like_declaration(tokens: & mut Peekable < I >)
  fn parse(tokens: & mut TokenStream, diagnostics: & mut DiagnosticStore)
  fn parse_add_sub(tokens: & mut TokenStream, diagnostics: & mut DiagnosticStore)
  fn parse_and(tokens: & mut TokenStream, diagnostics: & mut DiagnosticStore)
  fn parse_array(tokens: & mut TokenStream, diagnostics: & mut DiagnosticStore)
  fn parse_assignment(tokens: & mut TokenStream, lhs: Option < Expr >, diagnostics: & mut DiagnosticStore)
  fn parse_comparison(tokens: & mut TokenStream, diagnostics: & mut DiagnosticStore)
  fn parse_equality(tokens: & mut TokenStream, diagnostics: & mut DiagnosticStore)
  fn parse_expr(tokens: & mut TokenStream, diagnostics: & mut DiagnosticStore)
  fn parse_incremental(prev: & AST, tokens: & mut TokenStream, diagnostics: & mut DiagnosticStore)
  fn parse_let(tokens: & mut TokenStream, diagnostics: & mut DiagnosticStore)
  fn parse_member_and_index_chain(expr: Expr, tokens: & mut TokenStream, diagnostics: & mut DiagnosticStore)
  fn parse_mul_div(tokens: & mut TokenStream, diagnostics: & mut DiagnosticStore)
  fn parse_or(tokens: & mut TokenStream, diagnostics: & mut DiagnosticStore)
  fn parse_postfix(tokens: & mut TokenStream, diagnostics: & mut DiagnosticStore)
  fn parse_power(tokens: & mut TokenStream, diagnostics: & mut DiagnosticStore)
  fn parse_primary(tokens: & mut TokenStream, diagnostics: & mut DiagnosticStore)
  fn parse_source(input: & str)
  fn parse_stmt(tokens: & mut TokenStream, diagnostics: & mut DiagnosticStore)
  fn parse_unary(tokens: & mut TokenStream, diagnostics: & mut 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 >)
  fn lex_line_note(lex: & mut Lexer < Token >)
  fn lex_raw_block(lex: & mut Lexer < Token >)

--- # 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, config
  struct LexerConfig
    PROPERTIES:
    allow_unicode_identifiers, allow_raw_strings, comment_support
  struct LexerState
    PROPERTIES:
    position, line, column
  struct TokenStream
    PROPERTIES:
    tokens, pos

--- # middle/ir.rs
  STRUCTS:
  struct IR
    PROPERTIES:
    raw, nodes, symbols, metadata

    METHODS:
      fn default()
      fn fmt(self, f: & mut fmt :: Formatter < '_ >)
      fn new()
      fn raw(content: impl Into < String >)
      fn structured()
      fn is_raw(self)
  struct RegionBlock
    PROPERTIES:
    kind, source, output, mode
  struct TypedExpr
    PROPERTIES:
    expr, ty, span

  ENUMS:
  enum IROp { Return(value: Option < IRVal >), Declare(name: String, value: IRVal, mutable: bool, dynamic: bool), Nop, Binary(target: String, 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 >), Assign(name: String, value: IRVal), Load(name: String), If(condition: IRVal, then_branch: Vec < IROp >, else_branch: Vec < IROp >, scope_id: usize), Call(name: String, args: Vec < IRVal >), Print(value: 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 >), ExprStmt(expr: IRVal), 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)
  fn to_typed_expr(expr: Expr)

--- # middle/semantic.rs
  STRUCTS:
  struct SemanticAnalyzer
    PROPERTIES:
    symbols, scope_counter

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

  FUNCTIONS:
  fn analyze(ast: AST)
  fn analyze_block(block: Vec < Stmt >, symbols: & mut HashMap < String , Type >)
  fn analyze_stmt(stmt: Stmt, symbols: & mut HashMap < String , Type >)
  fn annotate_types(expr: & mut Expr, symbol_table: & HashMap < String , Type >)
  fn infer_type(expr: & Expr, symbols: & HashMap < String , Type >)
  fn one(op: IROp)
  fn wrap_to_irval(expr: Expr, symbols: & HashMap < String , Type >, _span: Span)
  fn wrap_typed(expr: Expr, symbols: & HashMap < String , Type >, span: Span)

--- # middle/types.rs
  STRUCTS:
  struct Block
    PROPERTIES:
    stmts
  struct Enum
    PROPERTIES:
    name, variants
  struct Field
    PROPERTIES:
    name, ty
  struct Function
    PROPERTIES:
    name, params, body
  struct Import
    PROPERTIES:
    path, alias, glob
  struct Module
    PROPERTIES:
    name, items
  struct Param
    PROPERTIES:
    name, ty
  struct Span
    PROPERTIES:
    file, start, end
  struct Struct
    PROPERTIES:
    name, fields
  struct Variant
    PROPERTIES:
    name, fields

  ENUMS:
  enum IRVal { Number(_0: HashF64), Bool(_0: bool), Str(_0: String), Var(_0: String) }
  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 }

--- # pipeline/backend.rs
  STRUCTS:
  struct BackendPipeline
    PROPERTIES:
    llvm_context, metadata, context, config, state, target, opt_level, codegen_config, debug

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

  ENUMS:
  enum BackendTarget { Bytecode, LLVM, WASM }
  enum OptimizationLevel { None, Basic, Aggressive }

--- # pipeline/frontend.rs
  STRUCTS:
  struct FrontendFeatures
    PROPERTIES:
    enable_macros, enable_jsx_like_blocks, strict_mode
  struct FrontendPipeline
    PROPERTIES:
    metadata, context, config, state, lexer, parser, features

    METHODS:
      fn new(context: Arc < Context >, config: Arc < RwLock < CompileConfig > >, state: Arc < RwLock < CompileState > >)
      fn with_name(name: & str, context: Arc < Context >, config: Arc < RwLock < CompileConfig > >, state: Arc < RwLock < CompileState > >)
      fn with_features(self, features: FrontendFeatures)
      fn perform_compilation(self)
      fn run(self, engine: & CompileEngine)
      fn name(self)
      fn default()

--- # pipeline/middle.rs
  STRUCTS:
  struct IRConfig
    PROPERTIES:
    preserve_raw_blocks, optimize_early
  struct MiddleFeatures
    PROPERTIES:
    enable_type_checking, enable_macro_expansion, enable_dead_code_analysis
  struct MiddlePipeline
    PROPERTIES:
    metadata, context, config, state, ir_config, features

    METHODS:
      fn new(context: Arc < Context >, config: Arc < RwLock < CompileConfig > >, state: Arc < RwLock < CompileState > >)
      fn with_name(name: & str, context: Arc < Context >, config: Arc < RwLock < CompileConfig > >, state: Arc < RwLock < CompileState > >)
      fn with_ir_config(self, config: IRConfig)
      fn with_features(self, features: MiddleFeatures)
      fn run(self, engine: & CompileEngine)
      fn resolve_symbols(self, _ast: & AST)
      fn lower_ast(self, ast: AST)
      fn default()

--- # pipeline/mod.rs
  STRUCTS:
  struct Metadata
    PROPERTIES:
    name, version

    METHODS:
      fn default()

  ENUMS:
  enum CompileError { Frontend(_0: String), Middle(_0: String), Backend(_0: String), Stage(stage: String, source: Box < dyn std :: error :: Error >) }

--- # pipeline/runner.rs
  STRUCTS:
  struct PipelineRunner
    PROPERTIES:
    stages

    METHODS:
      fn new()
      fn add_stage(self, stage: S)
      fn run(self, engine: & CompileEngine)

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

  FUNCTIONS:
  fn extract_web_target(name: & str)
  fn web_target(ext: & str)

--- # registry/file_meta.rs
  STRUCTS:
  struct FileMeta
    PROPERTIES:
    id, filename, namespace, name, utter, version, tag, variant, ext, path, active, capabilities

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

    METHODS:
      fn from(path: & Path)

--- # registry/registry.rs
  STRUCTS:
  struct FileStack
    PROPERTIES:
    files, active_file

    METHODS:
      fn group_key(self)
  struct Registry
    PROPERTIES:
    files, files_archive, from_files, stacks, active_by_group

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

--- ## backend/symbol/registry.rs
    STRUCTS:
    struct Symbol
      PROPERTIES:
      name, kind, value, file, origin, metadata
    struct SymbolId
      PROPERTIES:
      name, origin
    struct SymbolRegistry
      PROPERTIES:
      table, warnings

      METHODS:
          fn new()
          fn build(self, registry: & Registry, engines: & HashMap < String , Box < dyn Utter > >)
          fn lookup(self, name: & str, origin: & str)
          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 > >)
          fn add_symbols(self, symbols: Vec < Symbol >, source_file: & str)

    ENUMS:
    enum SymbolKind { Constant, Variable, Function, Method, Component, Action, Style, Theme, Type, Interface, Unknown }

--- ## backend/utter/handler.rs
    STRUCTS:
    struct GenericHandler
      PROPERTIES:
      target

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

    ENUMS:
    enum RenderTarget { Html, Css, Js, Ts, Json, Md, Loi }

--- ## backend/utter/registry.rs
    STRUCTS:
    struct UtterRegistry
      PROPERTIES:
      utters, handlers

      METHODS:
          fn default()
          fn eq(self, other: & Self)
          fn new()
          fn get_utter(self, capability: & str)

--- ## backend/utter/utter.rs
    STRUCTS:
    struct GenericUtter
      PROPERTIES:
      name, config

      METHODS:
          fn new(config: LanguageConfig)
          fn fmt(self, f: & mut std :: fmt :: Formatter < '_ >)
          fn name(self)
          fn flags(self)
          fn to_ir(self, metadata: & FileMeta, symbols: & SymbolRegistry)
          fn get_exported_symbols(self, metadata: & FileMeta)
          fn as_any(self)
          fn as_any_mut(self)
    struct LanguageConfig
      PROPERTIES:
      name, flags, symbol_patterns, to_ir

      METHODS:
          fn default()
    struct UtterFlags
      PROPERTIES:
      browser_dom, allow_network, fs_access, db_access

      METHODS:
          fn default()

    FUNCTIONS:
    fn get_language_definitions()

--- # EMPTY FILES
/Users/future/KB/project/app/loi/src/lib.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/backend/symbol/mod.rs
/Users/future/KB/project/app/loi/src/backend/utter/mod.rs
