@jalvin/compiler 2.0.32 → 2.0.33

package/dist/codegen/index.js

@@ -0,0 +1,2207 @@
+"use strict";
+// ─────────────────────────────────────────────────────────────────────────────
+// Jalvin Code Generator — AST → TypeScript/TSX
+//
+// Design principles:
+//   • component declarations  → React functional components (TSX)
+//   • data class              → class with auto-generated copy(), equals(), toString()
+//   • sealed class            → TypeScript discriminated union + base class
+//   • extension functions     → module-level functions with receiver as first param,
+//                               augmented onto the prototype via declaration merging
+//   • launch {}               → void-returning async IIFE  (fire-and-forget)
+//   • async {}                → Promise<T>-returning async IIFE
+//   • suspend fun             → async function
+//   • Bibi(...)               → runtime Bibi() helper (HTTP client)
+//   • StateFlow / ViewModel   → @jalvin/runtime types
+// ─────────────────────────────────────────────────────────────────────────────
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeGenerator = exports.DEFAULT_CODEGEN_OPTIONS = void 0;
+exports.generate = generate;
+const fs = __importStar(require("node:fs"));
+const nodePath = __importStar(require("node:path"));
+const AST = __importStar(require("../ast.js"));
+const diagnostics_js_1 = require("../diagnostics.js");
+const lexer_js_1 = require("../lexer.js");
+const parser_js_1 = require("../parser.js");
+// ---------------------------------------------------------------------------
+// Code writer — thin abstraction over string concatenation that tracks
+// indentation and emits source-map line hints.
+// ---------------------------------------------------------------------------
+class Writer {
+    buf = "";
+    indent = 0;
+    INDENT = "  ";
+    /** line mapping: output line → input line (1-based) */
+    lineMap = [];
+    currentLine = 1;
+    write(text) {
+        this.buf += text;
+    }
+    writeLine(text = "") {
+        this.buf += text + "\n";
+        this.lineMap.push(this.currentLine);
+        this.currentLine++;
+    }
+    writeIndented(text) {
+        this.buf += this.INDENT.repeat(this.indent) + text;
+    }
+    writeIndentedLine(text = "") {
+        this.buf += this.INDENT.repeat(this.indent) + text + "\n";
+        this.lineMap.push(this.currentLine);
+        this.currentLine++;
+    }
+    pushIndent() { this.indent++; }
+    popIndent() { this.indent = Math.max(0, this.indent - 1); }
+    get output() { return this.buf; }
+    setSourceLine(line) { this.currentLine = line + 1; }
+}
+exports.DEFAULT_CODEGEN_OPTIONS = {
+    jsx: false,
+    module: "esm",
+    emitTypes: false,
+    runtimeImport: "@jalvin/runtime",
+};
+class CodeGenerator {
+    w = new Writer();
+    opts;
+    hasComponents = false;
+    runtimeSymbolsNeeded = new Set();
+    /** Names of component functions — used to detect Compose-style calls and emit them as JSX */
+    componentNames = new Set();
+    /**
+     * Param names for components resolved from imported local .jalvin files.
+     * Maps component name → ordered list of param names.
+     */
+    componentParamNames = new Map();
+    /** True when the program contains `import @jalvin/ui.*` — used to detect UI primitive calls */
+    hasUiStarImport = false;
+    /** Operator overload resolutions from the type checker */
+    operatorOverloadMap = new Map();
+    /** Type map from the type checker */
+    typeMap = new Map();
+    /**
+     * Registry of extension functions declared on primitive receiver types.
+     * Maps receiverTypeName → Map<methodName, generatedFnName>
+     * Populated during top-level emit; used at call sites for rewriting.
+     */
+    primitiveExtensions = new Map();
+    /**
+     * When a scoped star import exists (e.g. import @jalvin/runtime.*), contains the
+     * set of external symbol names to emit as named imports from that package instead
+     * of a namespace import. Empty if namespace-import behavior is used.
+     */
+    externalStarCandidates = new Set();
+    /** Module specifiers whose symbols are already covered by a named star-import expansion. */
+    handledStarImportModules = new Set();
+    constructor(opts = {}) {
+        this.opts = { ...exports.DEFAULT_CODEGEN_OPTIONS, ...opts };
+    }
+    generate(program, operatorOverloads, typeMap) {
+        if (operatorOverloads)
+            this.operatorOverloadMap = operatorOverloads;
+        if (typeMap)
+            this.typeMap = typeMap;
+        // Pre-scan for components (local declarations OR @jalvin/ui imports)
+        this.hasComponents = program.declarations.some((d) => d.kind === "ComponentDecl" ||
+            (d.kind === "ClassDecl" && d.body?.members.some((m) => m.kind === "ComponentDecl"))) || program.imports.some((imp) => imp.path[0] === "@jalvin" && imp.path[1] === "ui");
+        // Collect component names for Compose-style call detection
+        this.componentNames = new Set();
+        this.componentParamNames = new Map();
+        for (const decl of program.declarations) {
+            if (decl.kind === "ComponentDecl")
+                this.componentNames.add(decl.name);
+            if (decl.kind === "ClassDecl" && decl.body) {
+                for (const m of decl.body.members) {
+                    if (m.kind === "ComponentDecl")
+                        this.componentNames.add(m.name);
+                }
+            }
+        }
+        this.hasUiStarImport = false;
+        for (const imp of program.imports) {
+            // Named imports from @jalvin/ui are component functions
+            if (imp.path[0] === "@jalvin" && imp.path[1] === "ui" && !imp.star) {
+                this.componentNames.add(imp.path[imp.path.length - 1]);
+            }
+            // Star import from @jalvin/ui — UI primitives won't be in componentNames
+            if (imp.path[0] === "@jalvin" && imp.path[1] === "ui" && imp.star) {
+                this.hasUiStarImport = true;
+            }
+        }
+        // Resolve component fun symbols from locally imported .jalvin files
+        const sourceRoot = this.opts.sourceRoot ?? process.cwd();
+        this.resolveLocalComponentImports(program, sourceRoot);
+        // Pre-compute external star-import candidates (before emitting anything)
+        this.externalStarCandidates = new Set();
+        this.handledStarImportModules = new Set();
+        const scopedStarImports = program.imports.filter((imp) => imp.star && imp.path[0].startsWith("@"));
+        if (scopedStarImports.length === 1) {
+            // Only resolve when there's exactly one scoped star import — with multiple
+            // star imports we can't safely split external names across packages.
+            const referencedNames = this.gatherReferencedNames(program);
+            const localBindings = this.gatherAllLocalBindings(program);
+            for (const name of referencedNames) {
+                if (!localBindings.has(name) && !JS_GLOBAL_NAMES.has(name)) {
+                    this.externalStarCandidates.add(name);
+                }
+            }
+        }
+        // Emit header
+        this.emitHeader(program);
+        // Declarations
+        for (const decl of program.declarations) {
+            this.emitTopLevelDecl(decl);
+            this.w.writeLine();
+        }
+        // Patch in runtime import if needed
+        const preamble = this.buildPreamble();
+        const code = preamble + this.w.output;
+        return {
+            code,
+            lineMap: this.w.lineMap,
+            isJsx: false, // DOM-based emit — no JSX
+        };
+    }
+    // ── Preamble & imports ─────────────────────────────────────────────────────
+    buildPreamble() {
+        const lines = [];
+        // No React import — @jalvin/ui is DOM-based.
+        // Emit compiler-injected runtime symbols, but only those NOT already covered
+        // by a star-import's named-import expansion (to avoid duplicate imports).
+        const alreadyCovered = this.handledStarImportModules.has(this.opts.runtimeImport)
+            ? this.externalStarCandidates
+            : new Set();
+        const needed = [...this.runtimeSymbolsNeeded].filter((s) => !alreadyCovered.has(s));
+        if (needed.length > 0) {
+            lines.push(`import { ${needed.sort().join(", ")} } from "${this.opts.runtimeImport}";`);
+        }
+        return lines.length > 0 ? lines.join("\n") + "\n\n" : "";
+    }
+    emitHeader(program) {
+        const sourceRoot = this.opts.sourceRoot ?? process.cwd();
+        // Re-emit user imports as ES imports
+        for (const imp of program.imports) {
+            // Build module specifier.
+            //
+            // Scoped packages (@org/pkg.Symbol): symbol is an export from the package,
+            // strip the last segment.
+            //   import @jalvin/ui.Column       → import { Column } from "@jalvin/ui"
+            //   import @jalvin/runtime.*       → import * as runtime from "@jalvin/runtime"
+            //
+            // Local imports (a.b.C): check whether the preceding segments already
+            // resolve to a file on disk.
+            //   import src.models.Rotation     → src/models/Rotation.ts does NOT exist
+            //                                    → import { Rotation } from "src/models/Rotation"
+            //   import src.models.css.Css      → src/models/css.ts DOES exist
+            //                                    → import { Css } from "src/models/css"
+            const isScoped = imp.path[0].startsWith("@");
+            let moduleSpecifier;
+            if (imp.star) {
+                // Star import — the entire path is the module.
+                moduleSpecifier = isScoped
+                    ? imp.path[0] + "/" + imp.path.slice(1).join("/")
+                    : imp.path.join("/");
+            }
+            else if (isScoped) {
+                // @org/pkg.Symbol → strip symbol from path.
+                const moduleParts = imp.path.slice(0, -1);
+                moduleSpecifier = moduleParts[0] + "/" + moduleParts.slice(1).join("/");
+            }
+            else {
+                // Non-scoped import: prefer local-file convention unless this looks like
+                // an installed npm package path (e.g. cubing/twisty.TwistyPlayer).
+                const precedingParts = imp.path.slice(0, -1);
+                const precedingRelPath = precedingParts.join("/");
+                const fileExts = [".ts", ".tsx", ".jalvin"];
+                const precedingIsFile = precedingParts.length > 0 && fileExts.some((ext) => fs.existsSync(nodePath.join(sourceRoot, precedingRelPath + ext)));
+                const looksLikeNpmPackage = this.isLikelyNodeModuleImport(imp.path, sourceRoot);
+                moduleSpecifier = precedingIsFile
+                    ? precedingRelPath // src.models.css.Css → "src/models/css"
+                    : looksLikeNpmPackage
+                        ? precedingRelPath // cubing.twisty.TwistyPlayer → "cubing/twisty"
+                        : imp.path.join("/"); // src.models.Rotation → "src/models/Rotation"
+            }
+            if (imp.star && isScoped && this.externalStarCandidates.size > 0) {
+                // Named-import expansion of a scoped star import.
+                // Emit explicit named imports for each external symbol used in the file so
+                // that symbols like `ViewModel`, `mutableStateOf` are directly in scope.
+                const symbols = [...this.externalStarCandidates].sort();
+                this.w.writeIndentedLine(`import { ${symbols.join(", ")} } from "${moduleSpecifier}";`);
+                this.handledStarImportModules.add(moduleSpecifier);
+            }
+            else if (imp.star) {
+                // Fallback: namespace import (multiple scoped star imports or no candidates).
+                this.w.writeIndentedLine(`import * as ${imp.path[imp.path.length - 1]} from "${moduleSpecifier}";`);
+            }
+            else if (imp.alias) {
+                const named = imp.path[imp.path.length - 1];
+                this.w.writeIndentedLine(`import { ${named} as ${imp.alias} } from "${moduleSpecifier}";`);
+            }
+            else {
+                this.w.writeIndentedLine(`import { ${imp.path[imp.path.length - 1]} } from "${moduleSpecifier}";`);
+            }
+        }
+        if (program.imports.length > 0)
+            this.w.writeLine();
+    }
+    /**
+     * Heuristic for non-scoped imports: if the first path segment resolves to an
+     * installed package in node_modules, treat the import as npm/ESM and strip
+     * the trailing symbol name from the module specifier.
+     */
+    isLikelyNodeModuleImport(pathParts, sourceRoot) {
+        if (pathParts.length < 2)
+            return false;
+        const packageName = pathParts[0];
+        let dir = sourceRoot;
+        while (true) {
+            const packageJson = nodePath.join(dir, "node_modules", packageName, "package.json");
+            if (fs.existsSync(packageJson))
+                return true;
+            const parent = nodePath.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+        return false;
+    }
+    // ── Top-level declarations ─────────────────────────────────────────────────
+    /** Emit a @deprecated JSDoc block if the declaration has @Nuked. */
+    emitAnnotations(mods) {
+        for (const ann of mods.annotations) {
+            if (ann.name === "Nuked") {
+                const reason = ann.args ? ` ${ann.args.replace(/^["']|["']$/g, "")}` : "";
+                this.w.writeIndentedLine(`/** @deprecated${reason} */`);
+            }
+            // Other annotations are silently ignored for now (pass-through model)
+        }
+    }
+    emitTopLevelDecl(decl) {
+        switch (decl.kind) {
+            case "FunDecl":
+                this.emitFunDecl(decl, false);
+                break;
+            case "ComponentDecl":
+                this.emitComponentDecl(decl);
+                break;
+            case "ClassDecl":
+                this.emitClassDecl(decl);
+                break;
+            case "DataClassDecl":
+                this.emitDataClassDecl(decl);
+                break;
+            case "SealedClassDecl":
+                this.emitSealedClassDecl(decl);
+                break;
+            case "EnumClassDecl":
+                this.emitEnumClassDecl(decl);
+                break;
+            case "InterfaceDecl":
+                this.emitInterfaceDecl(decl);
+                break;
+            case "ObjectDecl":
+                this.emitObjectDecl(decl);
+                break;
+            case "TypeAliasDecl":
+                this.emitTypeAliasDecl(decl);
+                break;
+            case "PropertyDecl":
+                this.emitPropertyDecl(decl, false);
+                break;
+            case "ExtensionFunDecl":
+                this.emitExtensionFunDecl(decl);
+                break;
+            case "DestructuringDecl":
+                this.emitDestructuringDecl(decl, false);
+                break;
+        }
+    }
+    // ── function declarations ──────────────────────────────────────────────────
+    emitFunDecl(decl, memberOf) {
+        this.emitAnnotations(decl.modifiers);
+        const isSuspend = AST.isSuspend(decl.modifiers);
+        const vis = memberOf ? this.visibilityPrefix(decl.modifiers) : this.exportPrefix(decl.modifiers);
+        const asyncKw = isSuspend ? "async " : "";
+        const typeParams = this.emitTypeParamsStr(decl.typeParams);
+        const params = this.emitParamsStr(decl.params);
+        const retType = decl.returnType && this.opts.emitTypes
+            ? `: ${this.emitTypeRef(decl.returnType)}`
+            : "";
+        if (!decl.body) {
+            // Abstract / interface method
+            this.w.writeIndentedLine(`${vis}${asyncKw}${decl.name}${typeParams}(${params})${retType};`);
+            return;
+        }
+        if (decl.body.kind === "Block") {
+            if (memberOf) {
+                this.w.writeIndentedLine(`${vis}${asyncKw}${decl.name}${typeParams}(${params})${retType} {`);
+            }
+            else {
+                this.w.writeIndentedLine(`${vis}${asyncKw}function ${decl.name}${typeParams}(${params})${retType} {`);
+            }
+            this.w.pushIndent();
+            this.emitBlock(decl.body);
+            this.w.popIndent();
+            this.w.writeIndentedLine(`}`);
+        }
+        else {
+            // Expression body
+            if (memberOf) {
+                this.w.writeIndentedLine(`${vis}${asyncKw}${decl.name}${typeParams}(${params})${retType} {`);
+            }
+            else {
+                this.w.writeIndentedLine(`${vis}${asyncKw}function ${decl.name}${typeParams}(${params})${retType} {`);
+            }
+            this.w.pushIndent();
+            this.w.writeIndentedLine(`return ${this.emitExpr(decl.body)};`);
+            this.w.popIndent();
+            this.w.writeIndentedLine(`}`);
+        }
+    }
+    emitMemberFunDecl(decl) {
+        const isSuspend = AST.isSuspend(decl.modifiers);
+        const vis = this.visibilityPrefix(decl.modifiers);
+        const asyncKw = isSuspend ? "async " : "";
+        const typeParams = this.emitTypeParamsStr(decl.typeParams);
+        const params = this.emitParamsStr(decl.params);
+        const retType = decl.returnType && this.opts.emitTypes
+            ? `: ${this.emitTypeRef(decl.returnType)}`
+            : "";
+        if (!decl.body) {
+            this.w.writeIndentedLine(`${vis}${asyncKw}${decl.name}${typeParams}(${params})${retType};`);
+            return;
+        }
+        if (decl.body.kind === "Block") {
+            this.w.writeIndentedLine(`${vis}${asyncKw}${decl.name}${typeParams}(${params})${retType} {`);
+            this.w.pushIndent();
+            this.emitBlock(decl.body);
+            this.w.popIndent();
+            this.w.writeIndentedLine(`}`);
+        }
+        else {
+            this.w.writeIndentedLine(`${vis}${asyncKw}${decl.name}${typeParams}(${params})${retType} {`);
+            this.w.pushIndent();
+            this.w.writeIndentedLine(`return ${this.emitExpr(decl.body)};`);
+            this.w.popIndent();
+            this.w.writeIndentedLine(`}`);
+        }
+    }
+    // ── component declarations → React function components ────────────────────
+    emitComponentDecl(decl) {
+        this.emitAnnotations(decl.modifiers);
+        this.hasComponents = true;
+        const vis = this.exportPrefix(decl.modifiers);
+        const params = this.emitComponentPropsStr(decl.params);
+        // Props interface
+        if (decl.params.length > 0) {
+            this.w.writeIndentedLine(`interface ${decl.name}Props {`);
+            this.w.pushIndent();
+            for (const p of decl.params) {
+                const optional = p.defaultValue ? "?" : "";
+                const typeStr = this.opts.emitTypes ? this.emitTypeRef(p.type) : "any";
+                this.w.writeIndentedLine(`readonly ${p.name}${optional}: ${typeStr};`);
+            }
+            this.w.popIndent();
+            this.w.writeIndentedLine(`}`);
+            this.w.writeLine();
+        }
+        const propsParam = decl.params.length > 0
+            ? `{ ${decl.params.map((p) => p.name + (p.defaultValue ? ` = ${this.emitExpr(p.defaultValue)}` : "")).join(", ")} }: ${decl.name}Props`
+            : "";
+        this.w.writeIndentedLine(`${vis}function ${decl.name}(${propsParam}) {`);
+        this.w.pushIndent();
+        this.emitComponentBlock(decl.body);
+        this.w.popIndent();
+        this.w.writeIndentedLine(`}`);
+    }
+    /**
+     * Emit the body of a `component fun` block.
+     * The last statement is emitted in tail position — if it is an expression,
+     * an if/else chain, or a when block, the innermost UI call is implicitly
+     * returned (Kotlin-style implicit return of the last expression).
+     */
+    emitComponentBlock(block) {
+        const stmts = block.statements;
+        for (let i = 0; i < stmts.length; i++) {
+            const stmt = stmts[i];
+            if (i === stmts.length - 1) {
+                this.emitTailStmt(stmt);
+            }
+            else {
+                this.emitStmt(stmt);
+            }
+        }
+    }
+    /** Emit a statement in tail position, adding implicit return where applicable. */
+    emitTailStmt(stmt) {
+        if (stmt.kind === "ExprStmt") {
+            // Implicit return: last expression in a component block
+            this.w.writeIndentedLine(`return ${this.emitExpr(stmt.expr)};`);
+        }
+        else if (stmt.kind === "IfStmt") {
+            this.emitIfStmtWithTailReturn(stmt);
+        }
+        else if (stmt.kind === "WhenStmt") {
+            this.emitWhenStmtWithTailReturn(stmt);
+        }
+        else {
+            this.emitStmt(stmt);
+        }
+    }
+    /** Emit a block in tail position, treating its last statement as a tail expression. */
+    emitTailBlock(block) {
+        const stmts = block.statements;
+        for (let i = 0; i < stmts.length; i++) {
+            const stmt = stmts[i];
+            if (i === stmts.length - 1) {
+                this.emitTailStmt(stmt);
+            }
+            else {
+                this.emitStmt(stmt);
+            }
+        }
+    }
+    /** Like emitIfStmt but with tail-return applied recursively to each branch body. */
+    emitIfStmtWithTailReturn(stmt) {
+        this.w.writeIndentedLine(`if (${this.emitExpr(stmt.condition)}) {`);
+        this.w.pushIndent();
+        this.emitTailBlock(stmt.then);
+        this.w.popIndent();
+        if (stmt.else) {
+            if (stmt.else.kind === "IfStmt") {
+                this.w.writeIndented(`} else `);
+                this.emitIfStmtWithTailReturn(stmt.else);
+            }
+            else {
+                this.w.writeIndentedLine(`} else {`);
+                this.w.pushIndent();
+                this.emitTailBlock(stmt.else);
+                this.w.popIndent();
+                this.w.writeIndentedLine(`}`);
+            }
+        }
+        else {
+            this.w.writeIndentedLine(`}`);
+        }
+    }
+    /** Like emitWhenStmt but with tail-return applied recursively to each branch body. */
+    emitWhenStmtWithTailReturn(stmt) {
+        const subjectVar = stmt.subject ? "__when_subject__" : null;
+        if (stmt.subject) {
+            const binding = stmt.subject.binding ?? subjectVar;
+            this.w.writeIndentedLine(`const ${binding} = ${this.emitExpr(stmt.subject.expr)};`);
+        }
+        let first = true;
+        for (const branch of stmt.branches) {
+            if (branch.isElse) {
+                this.w.writeIndentedLine(first ? `{` : `} else {`);
+            }
+            else {
+                const cond = branch.conditions.map((c) => this.emitWhenCondition(c, subjectVar ?? "")).join(" || ");
+                this.w.writeIndentedLine(first ? `if (${cond}) {` : `} else if (${cond}) {`);
+            }
+            first = false;
+            this.w.pushIndent();
+            if (branch.body.kind === "Block") {
+                this.emitTailBlock(branch.body);
+            }
+            else {
+                this.w.writeIndentedLine(`return ${this.emitExpr(branch.body)};`);
+            }
+            this.w.popIndent();
+        }
+        this.w.writeIndentedLine(`}`);
+    }
+    // ── regular class ──────────────────────────────────────────────────────────
+    emitClassDecl(decl) {
+        this.emitAnnotations(decl.modifiers);
+        const vis = this.exportPrefix(decl.modifiers);
+        const abstract = decl.modifiers.modifiers.includes("abstract") ? "abstract " : "";
+        const typeParams = this.emitTypeParamsStr(decl.typeParams);
+        const superTypes = this.emitSuperTypesStr(decl.superTypes);
+        this.w.writeIndentedLine(`${vis}${abstract}class ${decl.name}${typeParams}${superTypes} {`);
+        this.w.pushIndent();
+        // The first supertype's delegateArgs become the `super(args)` call inside the constructor.
+        const superDelegateArgs = decl.superTypes[0]?.delegateArgs ?? null;
+        if (decl.primaryConstructor) {
+            const initBlocks = decl.body?.members.filter((m) => m.kind === "InitBlock") ?? [];
+            this.emitPrimaryConstructorProps(decl.primaryConstructor.params, initBlocks, superDelegateArgs);
+        }
+        else if (superDelegateArgs !== null) {
+            // No primary constructor but the supertype has explicit delegation args —
+            // emit a minimal constructor that forwards them to super().
+            const superArgsStr = superDelegateArgs.map((a) => this.emitExpr(a.value)).join(", ");
+            this.w.writeIndentedLine(`constructor() {`);
+            this.w.pushIndent();
+            this.w.writeIndentedLine(`super(${superArgsStr});`);
+            this.w.popIndent();
+            this.w.writeIndentedLine(`}`);
+        }
+        if (decl.body) {
+            this.emitClassBody(decl.body);
+        }
+        this.w.popIndent();
+        this.w.writeIndentedLine(`}`);
+    }
+    // ── data class → class with copy/equals/toString ──────────────────────────
+    emitDataClassDecl(decl, kindName) {
+        this.emitAnnotations(decl.modifiers);
+        const vis = this.exportPrefix(decl.modifiers);
+        const typeParams = this.emitTypeParamsStr(decl.typeParams);
+        const superTypes = this.emitSuperTypesStr(decl.superTypes);
+        const props = decl.primaryConstructor.params;
+        this.w.writeIndentedLine(`${vis}class ${decl.name}${typeParams}${superTypes} {`);
+        this.w.pushIndent();
+        // Discriminant for sealed class sub-types
+        if (kindName) {
+            this.w.writeIndentedLine(`readonly __kind = "${kindName}" as const;`);
+        }
+        // Constructor params → readonly properties
+        for (const p of props) {
+            const t = this.opts.emitTypes ? `: ${this.emitTypeRef(p.type)}` : "";
+            this.w.writeIndentedLine(`readonly ${p.name}${t};`);
+        }
+        this.w.writeLine();
+        // Constructor
+        const ctorParams = props.map((p) => {
+            const t = this.opts.emitTypes ? `: ${this.emitTypeRef(p.type)}` : "";
+            return `${p.name}${t}`;
+        }).join(", ");
+        this.w.writeIndentedLine(`constructor(${ctorParams}) {`);
+        this.w.pushIndent();
+        // Emit super() with actual delegation args (or empty call if delegateArgs is []).
+        const dataSuperDelegateArgs = decl.superTypes[0]?.delegateArgs ?? null;
+        if (dataSuperDelegateArgs !== null) {
+            const superArgsStr = dataSuperDelegateArgs.map((a) => this.emitExpr(a.value)).join(", ");
+            this.w.writeIndentedLine(`super(${superArgsStr});`);
+        }
+        for (const p of props) {
+            this.w.writeIndentedLine(`this.${p.name} = ${p.name};`);
+        }
+        this.w.popIndent();
+        this.w.writeIndentedLine(`}`);
+        this.w.writeLine();
+        // copy()
+        const copyParams = props.map((p) => {
+            const t = this.opts.emitTypes ? `: ${this.emitTypeRef(p.type)}` : "";
+            return `${p.name}${t} = this.${p.name}`;
+        }).join(", ");
+        const copyArgs = props.map((p) => p.name).join(", ");
+        this.w.writeIndentedLine(`copy(${copyParams}): ${decl.name} {`);
+        this.w.pushIndent();
+        this.w.writeIndentedLine(`return new ${decl.name}(${copyArgs});`);
+        this.w.popIndent();
+        this.w.writeIndentedLine(`}`);
+        this.w.writeLine();
+        // equals()
+        this.runtimeSymbolsNeeded.add("jalvinEquals");
+        const eqChecks = props.map((p) => `jalvinEquals(this.${p.name}, other.${p.name})`).join(" && ") || "true";
+        this.w.writeIndentedLine(`equals(other: unknown): boolean {`);
+        this.w.pushIndent();
+        this.w.writeIndentedLine(`if (!(other instanceof ${decl.name})) return false;`);
+        this.w.writeIndentedLine(`return ${eqChecks};`);
+        this.w.popIndent();
+        this.w.writeIndentedLine(`}`);
+        this.w.writeLine();
+        // toString()
+        const toStringParts = props.map((p) => `${p.name}=\${this.${p.name}}`).join(", ");
+        this.w.writeIndentedLine(`toString(): string {`);
+        this.w.pushIndent();
+        this.w.writeIndentedLine(`return \`${decl.name}(${toStringParts})\`;`);
+        this.w.popIndent();
+        this.w.writeIndentedLine(`}`);
+        this.w.writeLine();
+        // hashCode() — djb2
+        this.w.writeIndentedLine(`hashCode(): number {`);
+        this.w.pushIndent();
+        this.w.writeIndentedLine(`let h = 17;`);
+        for (const p of props) {
+            this.w.writeIndentedLine(`h = h * 31 + String(this.${p.name}).split("").reduce((a, c) => (a * 31 + c.charCodeAt(0)) >>> 0, 0);`);
+        }
+        this.w.writeIndentedLine(`return h >>> 0;`);
+        this.w.popIndent();
+        this.w.writeIndentedLine(`}`);
+        if (decl.body) {
+            this.w.writeLine();
+            this.emitClassBody(decl.body);
+        }
+        this.w.popIndent();
+        this.w.writeIndentedLine(`}`);
+    }
+    // ── sealed class → TS abstract class + namespace merging ──────────────────
+    emitSealedClassDecl(decl) {
+        this.emitAnnotations(decl.modifiers);
+        const vis = this.exportPrefix(decl.modifiers);
+        const typeParams = this.emitTypeParamsStr(decl.typeParams);
+        const subDecls = [];
+        const otherMembers = [];
+        if (decl.body) {
+            for (const member of decl.body.members) {
+                if (member.kind === "ClassDecl" ||
+                    member.kind === "DataClassDecl" ||
+                    member.kind === "ObjectDecl") {
+                    subDecls.push(member);
+                }
+                else if (member.kind !== "InitBlock") {
+                    otherMembers.push(member);
+                }
+            }
+        }
+        // Emit the abstract base class (only non-subtype members in the body)
+        this.w.writeIndentedLine(`${vis}abstract class ${decl.name}${typeParams} {`);
+        this.w.pushIndent();
+        this.w.writeIndentedLine(`abstract readonly __kind: string;`);
+        for (const member of otherMembers) {
+            this.emitClassMember(member);
+            this.w.writeLine();
+        }
+        this.w.popIndent();
+        this.w.writeIndentedLine(`}`);
+        this.w.writeLine();
+        if (subDecls.length === 0)
+            return;
+        // Emit non-object sub-declarations at module level (before namespace)
+        for (const sub of subDecls) {
+            if (sub.kind === "DataClassDecl") {
+                this.emitDataClassDecl(sub, sub.name);
+                this.w.writeLine();
+            }
+            else if (sub.kind === "ClassDecl") {
+                this.emitClassDecl(sub);
+                this.w.writeLine();
+            }
+        }
+        // Emit namespace merging so SealedClass.SubType is accessible
+        this.w.writeIndentedLine(`${vis}namespace ${decl.name} {`);
+        this.w.pushIndent();
+        for (const sub of subDecls) {
+            if (sub.kind === "ObjectDecl") {
+                // Singleton object — emit inline in namespace with __kind discriminant
+                const superStr = sub.superTypes.length > 0
+                    ? this.emitSuperTypesStr(sub.superTypes)
+                    : ` extends ${decl.name}`;
+                const membersArr = [];
+                membersArr.push(`readonly __kind = "${sub.name}" as const;`);
+                if (sub.body) {
+                    for (const m of sub.body.members) {
+                        if (m.kind !== "InitBlock")
+                            membersArr.push(this.captureClassMember(m));
+                    }
+                }
+                const membersStr = membersArr.join(" ");
+                this.w.writeIndentedLine(`export const ${sub.name} = new (class${superStr} { ${membersStr} })();`);
+            }
+            else {
+                // DataClassDecl / ClassDecl — already emitted at module level, re-export
+                this.w.writeIndentedLine(`export { ${sub.name} };`);
+            }
+        }
+        this.w.popIndent();
+        this.w.writeIndentedLine(`}`);
+    }
+    // ── enum class → TypeScript const enum + class ────────────────────────────
+    emitEnumClassDecl(decl) {
+        const vis = this.exportPrefix(decl.modifiers);
+        const typeParams = this.emitTypeParamsStr(decl.typeParams);
+        // Emit the enum as a TypeScript class with static singleton instances.
+        // This preserves the `EnumClass.ENTRY` access pattern and allows
+        // methods/properties to be attached to entries.
+        this.w.writeIndentedLine(`${vis}class ${decl.name}${typeParams} {`);
+        this.w.pushIndent();
+        // Private constructor so entries are the only instances
+        if (decl.primaryConstructor && decl.primaryConstructor.params.length > 0) {
+            const ctorParams = decl.primaryConstructor.params
+                .map((p) => {
+                const ro = p.propertyKind === "val" ? "readonly " : "";
+                const type = this.opts.emitTypes ? `: ${this.emitTypeRef(p.type)}` : "";
+                return `${ro}${p.name}${type}`;
+            })
+                .join(", ");
+            this.w.writeIndentedLine(`private constructor(${ctorParams}) {}`);
+        }
+        else {
+            this.w.writeIndentedLine(`private constructor(readonly name: string, readonly ordinal: number) {}`);
+        }
+        this.w.writeLine();
+        // Static entry instances
+        for (let i = 0; i < decl.entries.length; i++) {
+            const entry = decl.entries[i];
+            const args = entry.args.length > 0
+                ? entry.args.map((a) => this.emitExpr(a.value)).join(", ")
+                : `"${entry.name}", ${i}`;
+            this.w.writeIndentedLine(`static readonly ${entry.name} = new ${decl.name}(${args});`);
+        }
+        if (decl.entries.length > 0) {
+            this.w.writeLine();
+            // values() helper
+            const entryList = decl.entries.map((e) => `${decl.name}.${e.name}`).join(", ");
+            this.w.writeIndentedLine(`static values(): ${decl.name}[] { return [${entryList}]; }`);
+            this.w.writeIndentedLine(`static valueOf(name: string): ${decl.name} {`);
+            this.w.pushIndent();
+            this.w.writeIndentedLine(`const v = ${decl.name}.values().find(e => e.name === name);`);
+            this.w.writeIndentedLine(`if (!v) throw new Error(\`No enum constant ${decl.name}.\${name}\`);`);
+            this.w.writeIndentedLine(`return v;`);
+            this.w.popIndent();
+            this.w.writeIndentedLine(`}`);
+        }
+        if (decl.body) {
+            this.w.writeLine();
+            this.emitClassBody(decl.body);
+        }
+        this.w.popIndent();
+        this.w.writeIndentedLine(`}`);
+    }
+    // ── destructuring declaration — val (a, b) = expr ─────────────────────────
+    emitDestructuringDecl(decl, _memberOf) {
+        const kw = decl.mutable ? "let" : "const";
+        const names = decl.names.map((n) => n ?? "_").join(", ");
+        const init = this.emitExpr(decl.initializer);
+        this.w.writeIndentedLine(`${kw} [${names}] = ${init};`);
+    }
+    // ── interface ──────────────────────────────────────────────────────────────
+    emitInterfaceDecl(decl) {
+        this.emitAnnotations(decl.modifiers);
+        const vis = this.exportPrefix(decl.modifiers);
+        const typeParams = this.emitTypeParamsStr(decl.typeParams);
+        const superTypes = decl.superTypes.length > 0
+            ? ` extends ${decl.superTypes.map((s) => this.emitTypeRef(s.type)).join(", ")}`
+            : "";
+        this.w.writeIndentedLine(`${vis}interface ${decl.name}${typeParams}${superTypes} {`);
+        this.w.pushIndent();
+        if (decl.body) {
+            for (const member of decl.body.members) {
+                this.emitClassMember(member);
+            }
+        }
+        this.w.popIndent();
+        this.w.writeIndentedLine(`}`);
+    }
+    // ── object declaration → singleton ────────────────────────────────────────
+    emitObjectDecl(decl) {
+        if (!decl.name) {
+            // Anonymous object — emitted inline
+            return;
+        }
+        this.emitAnnotations(decl.modifiers);
+        const vis = this.exportPrefix(decl.modifiers);
+        const superTypes = this.emitSuperTypesStr(decl.superTypes);
+        this.w.writeIndentedLine(`${vis}const ${decl.name} = new (class${superTypes} {`);
+        this.w.pushIndent();
+        this.emitClassBody(decl.body);
+        this.w.popIndent();
+        this.w.writeIndentedLine(`})();`);
+    }
+    // ── type alias ─────────────────────────────────────────────────────────────
+    emitTypeAliasDecl(decl) {
+        const vis = this.exportPrefix(decl.modifiers);
+        const typeParams = this.emitTypeParamsStr(decl.typeParams);
+        this.w.writeIndentedLine(`${vis}type ${decl.name}${typeParams} = ${this.emitTypeRef(decl.type)};`);
+    }
+    // ── extension functions ────────────────────────────────────────────────────
+    // Emitted as standalone free functions with receiver as explicit first param.
+    // For class types, also patched onto the prototype for dot-call syntax.
+    // For primitive types, call sites are rewritten via `primitiveExtensions`.
+    emitExtensionFunDecl(decl) {
+        const isSuspend = AST.isSuspend(decl.modifiers);
+        const asyncKw = isSuspend ? "async " : "";
+        const receiverType = this.emitTypeRef(decl.receiver);
+        const typeParams = this.emitTypeParamsStr(decl.typeParams);
+        const params = this.emitParamsStr(decl.params);
+        const retType = decl.returnType && this.opts.emitTypes
+            ? `: ${this.emitTypeRef(decl.returnType)}`
+            : "";
+        const fnName = `__ext_${receiverType.replace(/[^a-zA-Z0-9_]/g, "_")}_${decl.name}`;
+        // Emit as a free function: receiver is the first explicit parameter `$receiver`.
+        // Inside the function body, `this` is rebound to `$receiver` so Jalvin's
+        // `this.prop` references work correctly.
+        this.w.writeIndentedLine(`${asyncKw}function ${fnName}${typeParams}($receiver: ${receiverType}${params ? ", " + params : ""})${retType} {`);
+        this.w.pushIndent();
+        if (decl.body.kind === "Block") {
+            this.w.writeIndentedLine(`return (function(this: ${receiverType})${retType} {`);
+            this.w.pushIndent();
+            this.emitBlock(decl.body);
+            this.w.popIndent();
+            this.w.writeIndentedLine(`}).call($receiver);`);
+        }
+        else {
+            this.w.writeIndentedLine(`return (function(this: ${receiverType})${retType} { return ${this.emitExpr(decl.body)}; }).call($receiver);`);
+        }
+        this.w.popIndent();
+        this.w.writeIndentedLine(`}`);
+        this.w.writeLine();
+        const simpleReceiverName = this.receiverClassName(decl.receiver);
+        if (simpleReceiverName) {
+            if (PRIMITIVE_TYPES.has(simpleReceiverName)) {
+                // Register for call-site rewriting — cannot patch primitive prototypes
+                if (!this.primitiveExtensions.has(simpleReceiverName)) {
+                    this.primitiveExtensions.set(simpleReceiverName, new Map());
+                }
+                this.primitiveExtensions.get(simpleReceiverName).set(decl.name, fnName);
+            }
+            else {
+                // Class types — prototype monkey-patch for dot-call syntax
+                this.w.writeIndentedLine(`// Extension: ${receiverType}.${decl.name}`);
+                this.w.writeIndentedLine(`(${simpleReceiverName}.prototype as any).${decl.name} = function(this: ${receiverType}, ...args: unknown[]) { return (${fnName} as Function)(this, ...args); };`);
+            }
+        }
+    }
+    receiverClassName(ref) {
+        if (ref.kind === "SimpleTypeRef")
+            return ref.name[ref.name.length - 1] ?? null;
+        if (ref.kind === "GenericTypeRef")
+            return ref.base.name[ref.base.name.length - 1] ?? null;
+        return null;
+    }
+    /**
+     * Maps a JType to the primitive receiver type name used as a key
+     * in `primitiveExtensions` (e.g. JType `{ tag: "string" }` → `"String"`).
+     * Returns null for non-primitive / unknown types.
+     */
+    jTypeToReceiverName(type) {
+        const tagToReceiverName = {
+            string: "String",
+            int: "Int",
+            long: "Long",
+            float: "Float",
+            double: "Double",
+            boolean: "Boolean",
+            char: "Char",
+        };
+        return tagToReceiverName[type.tag] ?? null;
+    }
+    classHasInvokeOperator(decl) {
+        if (!decl.body)
+            return false;
+        return decl.body.members.some((m) => m.kind === "FunDecl" &&
+            m.name === "invoke" &&
+            m.modifiers.modifiers.includes("operator"));
+    }
+    // ── property declaration ───────────────────────────────────────────────────
+    emitPropertyDecl(decl, member, isLocal = false) {
+        this.emitAnnotations(decl.modifiers);
+        const vis = member ? this.visibilityPrefix(decl.modifiers) : isLocal ? "" : this.exportPrefix(decl.modifiers);
+        const isConst = decl.modifiers.modifiers.includes("const");
+        const isLateinit = decl.modifiers.modifiers.includes("lateinit");
+        // `const val` → `const` at module level; inside classes treated as `static readonly`
+        const kw = member
+            ? (decl.mutable ? "" : "readonly ")
+            : (isConst ? "const " : decl.mutable ? "let " : "const ");
+        const type = decl.type && this.opts.emitTypes ? `: ${this.emitTypeRef(decl.type)}` : "";
+        if (decl.delegate) {
+            // Delegated property — wrap in a getter/setter pair using the delegate
+            this.runtimeSymbolsNeeded.add("delegate");
+            const delegateExpr = this.emitExpr(decl.delegate);
+            if (member) {
+                this.w.writeIndentedLine(`${vis}get ${decl.name}()${type} { return delegate(${delegateExpr}, "${decl.name}", this).getValue(); }`);
+                if (decl.mutable) {
+                    this.w.writeIndentedLine(`${vis}set ${decl.name}(v: any) { delegate(${delegateExpr}, "${decl.name}", this).setValue(v); }`);
+                }
+            }
+            else {
+                this.w.writeIndentedLine(`${kw}${decl.name}${type} = ${delegateExpr};`);
+            }
+            return;
+        }
+        const init = decl.initializer ? ` = ${this.emitExpr(decl.initializer)}` : (isLateinit ? "" : "");
+        if (member) {
+            const modStr = isConst ? "static readonly " : decl.mutable ? "" : "readonly ";
+            this.w.writeIndentedLine(`${vis}${modStr}${decl.name}${type}${init};`);
+        }
+        else {
+            this.w.writeIndentedLine(`${vis}${kw}${decl.name}${type}${init};`);
+        }
+        if (decl.getter) {
+            this.emitPropertyAccessor("get", decl.name, decl.getter, member, type);
+        }
+        if (decl.setter) {
+            this.emitPropertyAccessor("set", decl.name, decl.setter, member, type);
+        }
+    }
+    emitPropertyAccessor(kind, name, acc, member, type) {
+        const retOrParam = kind === "get" ? type : `(value: any)`;
+        const vis = this.visibilityPrefix(acc.modifiers);
+        this.w.writeIndentedLine(`${vis}${kind} ${name}()${retOrParam} {`);
+        this.w.pushIndent();
+        if (acc.body) {
+            if (acc.body.kind === "Block")
+                this.emitBlock(acc.body);
+            else
+                this.w.writeIndentedLine(`return ${this.emitExpr(acc.body)};`);
+        }
+        this.w.popIndent();
+        this.w.writeIndentedLine(`}`);
+    }
+    // ── class body ─────────────────────────────────────────────────────────────
+    emitClassBody(body) {
+        for (const member of body.members) {
+            // InitBlocks are emitted inside the constructor by emitPrimaryConstructorProps
+            if (member.kind === "InitBlock")
+                continue;
+            this.emitClassMember(member);
+            this.w.writeLine();
+        }
+    }
+    emitClassMember(member) {
+        switch (member.kind) {
+            case "FunDecl":
+                this.emitMemberFunDecl(member);
+                break;
+            case "ComponentDecl":
+                this.emitComponentDecl(member);
+                break;
+            case "PropertyDecl":
+                this.emitPropertyDecl(member, true);
+                break;
+            case "ClassDecl":
+                this.emitClassDecl(member);
+                break;
+            case "DataClassDecl":
+                this.emitDataClassDecl(member);
+                break;
+            case "SealedClassDecl":
+                this.emitSealedClassDecl(member);
+                break;
+            case "EnumClassDecl":
+                this.emitEnumClassDecl(member);
+                break;
+            case "ObjectDecl":
+                this.emitObjectDecl(member);
+                break;
+            case "CompanionObject":
+                this.emitCompanionObject(member);
+                break;
+            case "InitBlock": /* handled in constructor */ break;
+            case "SecondaryConstructor":
+                this.emitSecondaryConstructor(member);
+                break;
+            case "ExtensionFunDecl":
+                this.emitExtensionFunDecl(member);
+                break;
+        }
+    }
+    emitPrimaryConstructorProps(params, initBlocks, superDelegateArgs) {
+        for (const p of params) {
+            if (p.propertyKind) {
+                const ro = p.propertyKind === "val" ? "readonly " : "";
+                const type = this.opts.emitTypes ? `: ${this.emitTypeRef(p.type)}` : "";
+                this.w.writeIndentedLine(`${ro}${p.name}${type};`);
+            }
+        }
+        // Constructor
+        const ctorParams = params.map((p) => {
+            const ro = p.propertyKind === "val" ? "readonly " : p.propertyKind === "var" ? "" : "";
+            const type = this.opts.emitTypes ? `: ${this.emitTypeRef(p.type)}` : "";
+            const def = p.defaultValue ? ` = ${this.emitExpr(p.defaultValue)}` : "";
+            return `${p.name}${type}${def}`;
+        });
+        this.w.writeIndentedLine(`constructor(${ctorParams.join(", ")}) {`);
+        this.w.pushIndent();
+        // super() call must be the first statement if there is a supertype.
+        if (superDelegateArgs !== null && superDelegateArgs !== undefined) {
+            const superArgsStr = superDelegateArgs.map((a) => this.emitExpr(a.value)).join(", ");
+            this.w.writeIndentedLine(`super(${superArgsStr});`);
+        }
+        for (const p of params) {
+            if (p.propertyKind) {
+                this.w.writeIndentedLine(`this.${p.name} = ${p.name};`);
+            }
+        }
+        // Emit init{} blocks inside the constructor, in declaration order
+        for (const ib of (initBlocks ?? [])) {
+            this.emitBlock(ib.body);
+        }
+        this.w.popIndent();
+        this.w.writeIndentedLine(`}`);
+        this.w.writeLine();
+    }
+    emitCompanionObject(co) {
+        // Emit companion object members as `static` members of the outer class so that
+        // `MyClass.factoryMethod()` works directly (standard semantics).
+        for (const member of co.body.members) {
+            if (member.kind === "FunDecl") {
+                const vis = this.visibilityPrefix(member.modifiers);
+                const params = this.emitParamsStr(member.params);
+                const retType = member.returnType && this.opts.emitTypes
+                    ? `: ${this.emitTypeRef(member.returnType)}` : "";
+                const asyncKw = AST.isSuspend(member.modifiers) ? "async " : "";
+                if (member.body) {
+                    if (member.body.kind === "Block") {
+                        this.w.writeIndentedLine(`${vis}static ${asyncKw}${member.name}(${params})${retType} {`);
+                        this.w.pushIndent();
+                        this.emitBlock(member.body);
+                        this.w.popIndent();
+                        this.w.writeIndentedLine(`}`);
+                    }
+                    else {
+                        this.w.writeIndentedLine(`${vis}static ${asyncKw}${member.name}(${params})${retType} { return ${this.emitExpr(member.body)}; }`);
+                    }
+                }
+                else {
+                    this.w.writeIndentedLine(`${vis}static abstract ${member.name}(${params})${retType};`);
+                }
+            }
+            else if (member.kind === "PropertyDecl") {
+                const vis = this.visibilityPrefix(member.modifiers);
+                const kw = member.mutable ? "" : "readonly ";
+                const typeAnn = member.type && this.opts.emitTypes ? `: ${this.emitTypeRef(member.type)}` : "";
+                const init = member.initializer ? ` = ${this.emitExpr(member.initializer)}` : "";
+                this.w.writeIndentedLine(`${vis}static ${kw}${member.name}${typeAnn}${init};`);
+            }
+        }
+    }
+    emitSecondaryConstructor(ctor) {
+        const params = this.emitParamsStr(ctor.params);
+        this.w.writeIndentedLine(`constructor(${params}) {`);
+        this.w.pushIndent();
+        if (ctor.delegation) {
+            const args = ctor.delegateArgs.map((a) => this.emitExpr(a.value)).join(", ");
+            this.w.writeIndentedLine(`${ctor.delegation}(${args});`);
+        }
+        this.emitBlock(ctor.body);
+        this.w.popIndent();
+        this.w.writeIndentedLine(`}`);
+    }
+    // ── Statements ─────────────────────────────────────────────────────────────
+    emitBlock(block) {
+        for (const stmt of block.statements) {
+            this.emitStmt(stmt);
+        }
+    }
+    emitStmt(stmt) {
+        switch (stmt.kind) {
+            case "Block":
+                this.w.writeIndentedLine(`{`);
+                this.w.pushIndent();
+                this.emitBlock(stmt);
+                this.w.popIndent();
+                this.w.writeIndentedLine(`}`);
+                break;
+            case "PropertyDecl":
+                this.emitPropertyDecl(stmt, false, true);
+                break;
+            case "DestructuringDecl":
+                this.emitDestructuringDecl(stmt, false);
+                break;
+            case "ExprStmt":
+                this.w.writeIndentedLine(`${this.emitExpr(stmt.expr)};`);
+                break;
+            case "ReturnStmt": {
+                const val = stmt.value ? ` ${this.emitExpr(stmt.value)}` : "";
+                this.w.writeIndentedLine(`return${val};`);
+                break;
+            }
+            case "ThrowStmt":
+                this.w.writeIndentedLine(`throw ${this.emitExpr(stmt.value)};`);
+                break;
+            case "BreakStmt":
+                this.w.writeIndentedLine(stmt.label ? `break ${stmt.label};` : `break;`);
+                break;
+            case "ContinueStmt":
+                this.w.writeIndentedLine(stmt.label ? `continue ${stmt.label};` : `continue;`);
+                break;
+            case "IfStmt":
+                this.emitIfStmt(stmt);
+                break;
+            case "WhenStmt":
+                this.emitWhenStmt(stmt);
+                break;
+            case "ForStmt":
+                this.emitForStmt(stmt);
+                break;
+            case "WhileStmt":
+                this.w.writeIndentedLine(`while (${this.emitExpr(stmt.condition)}) {`);
+                this.w.pushIndent();
+                this.emitBlock(stmt.body);
+                this.w.popIndent();
+                this.w.writeIndentedLine(`}`);
+                break;
+            case "DoWhileStmt":
+                this.w.writeIndentedLine(`do {`);
+                this.w.pushIndent();
+                this.emitBlock(stmt.body);
+                this.w.popIndent();
+                this.w.writeIndentedLine(`} while (${this.emitExpr(stmt.condition)});`);
+                break;
+            case "TryCatchStmt":
+                this.emitTryCatch(stmt);
+                break;
+            case "LabeledStmt":
+                this.w.writeIndentedLine(`${stmt.label}:`);
+                this.emitStmt(stmt.body);
+                break;
+        }
+    }
+    emitIfStmt(stmt) {
+        this.w.writeIndentedLine(`if (${this.emitExpr(stmt.condition)}) {`);
+        this.w.pushIndent();
+        this.emitBlock(stmt.then);
+        this.w.popIndent();
+        if (stmt.else) {
+            if (stmt.else.kind === "IfStmt") {
+                this.w.writeIndented(`} else `);
+                this.emitIfStmt(stmt.else);
+            }
+            else {
+                this.w.writeIndentedLine(`} else {`);
+                this.w.pushIndent();
+                this.emitBlock(stmt.else);
+                this.w.popIndent();
+                this.w.writeIndentedLine(`}`);
+            }
+        }
+        else {
+            this.w.writeIndentedLine(`}`);
+        }
+    }
+    emitWhenStmt(stmt) {
+        // when(subject) { is Foo -> ... else -> ... }
+        // Compiles to a series of if/else-if chains
+        const subjectVar = stmt.subject ? "__when_subject__" : null;
+        if (stmt.subject) {
+            const binding = stmt.subject.binding ?? subjectVar;
+            this.w.writeIndentedLine(`const ${binding} = ${this.emitExpr(stmt.subject.expr)};`);
+        }
+        let first = true;
+        for (const branch of stmt.branches) {
+            if (branch.isElse) {
+                this.w.writeIndentedLine(first ? `{` : `} else {`);
+            }
+            else {
+                const cond = branch.conditions.map((c) => this.emitWhenCondition(c, subjectVar ?? "")).join(" || ");
+                this.w.writeIndentedLine(first ? `if (${cond}) {` : `} else if (${cond}) {`);
+            }
+            first = false;
+            this.w.pushIndent();
+            if (branch.body.kind === "Block") {
+                this.emitBlock(branch.body);
+            }
+            else {
+                this.w.writeIndentedLine(`${this.emitExpr(branch.body)};`);
+            }
+            this.w.popIndent();
+        }
+        this.w.writeIndentedLine(`}`);
+    }
+    emitWhenCondition(cond, subject) {
+        switch (cond.kind) {
+            case "WhenIsCondition": {
+                // Qualified name (e.g. UiState.Loading) → use __kind discriminant
+                // Single name (e.g. BibiError) → use instanceof
+                const isQualified = cond.type.kind === "SimpleTypeRef" && cond.type.name.length > 1;
+                const check = isQualified
+                    ? `(${subject} as any).__kind === "${cond.type.kind === "SimpleTypeRef" ? cond.type.name[cond.type.name.length - 1] : ""}"`
+                    : `${subject} instanceof ${this.emitTypeRef(cond.type)}`;
+                return cond.negated ? `!(${check})` : check;
+            }
+            case "WhenInCondition": {
+                const check = `(${this.emitExpr(cond.expr)}).includes(${subject})`;
+                return cond.negated ? `!(${check})` : check;
+            }
+            case "WhenExprCondition":
+                return subject
+                    ? `${subject} === ${this.emitExpr(cond.expr)}`
+                    : this.emitExpr(cond.expr);
+        }
+    }
+    emitForStmt(stmt) {
+        const iter = this.emitExpr(stmt.iterable);
+        if (typeof stmt.binding === "string") {
+            this.w.writeIndentedLine(`for (const ${stmt.binding} of ${iter}) {`);
+        }
+        else if (stmt.binding.kind === "TupleDestructure") {
+            const names = stmt.binding.names.map((n) => n ?? "_").join(", ");
+            this.w.writeIndentedLine(`for (const [${names}] of ${iter}) {`);
+        }
+        else {
+            const { key, value } = stmt.binding;
+            // Use .entries() for JS Map (Map<K,V>), Object.entries() for plain objects
+            const iterableType = this.typeMap.get(stmt.iterable);
+            const isMap = iterableType?.tag === "class" && iterableType.name === "Map";
+            const entries = isMap ? `${iter}.entries()` : `Object.entries(${iter})`;
+            this.w.writeIndentedLine(`for (const [${key}, ${value}] of ${entries}) {`);
+        }
+        this.w.pushIndent();
+        this.emitBlock(stmt.body);
+        this.w.popIndent();
+        this.w.writeIndentedLine(`}`);
+    }
+    emitTryCatch(stmt) {
+        this.w.writeIndentedLine(`try {`);
+        this.w.pushIndent();
+        this.emitBlock(stmt.body);
+        this.w.popIndent();
+        for (const c of stmt.catches) {
+            this.w.writeIndentedLine(`} catch (${c.name}: unknown) {`);
+            this.w.pushIndent();
+            // Narrow type
+            if (this.opts.emitTypes) {
+                this.w.writeIndentedLine(`if (!(${c.name} instanceof ${this.emitTypeRef(c.type)})) throw ${c.name};`);
+            }
+            this.emitBlock(c.body);
+            this.w.popIndent();
+        }
+        if (stmt.finally) {
+            this.w.writeIndentedLine(`} finally {`);
+            this.w.pushIndent();
+            this.emitBlock(stmt.finally);
+            this.w.popIndent();
+        }
+        this.w.writeIndentedLine(`}`);
+    }
+    // ── Expressions ────────────────────────────────────────────────────────────
+    emitExpr(expr) {
+        switch (expr.kind) {
+            case "IntLiteralExpr": return String(expr.value);
+            case "LongLiteralExpr": return `BigInt(${expr.value})`;
+            case "FloatLiteralExpr":
+            case "DoubleLiteralExpr": return String(expr.value);
+            case "BooleanLiteralExpr": return String(expr.value);
+            case "NullLiteralExpr": return "null";
+            case "StringLiteralExpr":
+                return expr.raw
+                    ? `\`${expr.value}\``
+                    : JSON.stringify(expr.value);
+            case "StringTemplateExpr":
+                return this.emitStringTemplate(expr);
+            case "NameExpr":
+                // Ensure Int/Long companion objects are imported from the runtime
+                if (expr.name === "Int" || expr.name === "Long") {
+                    this.runtimeSymbolsNeeded.add(expr.name);
+                }
+                // Unit singleton emits as undefined (matches Kotlin/JVM void semantics)
+                if (expr.name === "Unit")
+                    return "undefined";
+                return expr.name;
+            case "ThisExpr": return "this";
+            case "SuperExpr": return "super";
+            case "ParenExpr": return `(${this.emitExpr(expr.expr)})`;
+            case "UnaryExpr":
+                return expr.prefix
+                    ? `${this.unaryOpStr(expr.op)}${this.emitExpr(expr.operand)}`
+                    : `${this.emitExpr(expr.operand)}${this.unaryOpStr(expr.op)}`;
+            case "BinaryExpr": {
+                const opMethod = this.operatorOverloadMap.get(expr);
+                if (opMethod) {
+                    const l = this.emitExpr(expr.left);
+                    const r = this.emitExpr(expr.right);
+                    // `compareTo` overloads: wrap result in a comparison against 0
+                    if (opMethod === "compareTo") {
+                        const cmpOp = expr.op;
+                        return `(${l}.compareTo(${r}) ${cmpOp} 0)`;
+                    }
+                    // `contains` overloads: `element in collection` → `collection.contains(element)`
+                    if (opMethod === "contains") {
+                        return `${r}.contains(${l})`;
+                    }
+                    if (opMethod === "!contains") {
+                        return `!${r}.contains(${l})`;
+                    }
+                    // Generic operator overload: emit as method call `left.method(right)`
+                    return `${l}.${opMethod}(${r})`;
+                }
+                // `==` → structural equality, `!=` → negation
+                if (expr.op === "==" || expr.op === "!=") {
+                    this.runtimeSymbolsNeeded.add("jalvinEquals");
+                    const eq = `jalvinEquals(${this.emitExpr(expr.left)}, ${this.emitExpr(expr.right)})`;
+                    return expr.op === "==" ? eq : `!${eq}`;
+                }
+                // `in` / `!in` without a user-defined operator: use JS `in` / array includes
+                if (expr.op === "in") {
+                    return `${this.emitExpr(expr.right)}.includes?.(${this.emitExpr(expr.left)}) ?? (${this.emitExpr(expr.left)} in ${this.emitExpr(expr.right)})`;
+                }
+                if (expr.op === "!in") {
+                    return `!(${this.emitExpr(expr.right)}.includes?.(${this.emitExpr(expr.left)}) ?? (${this.emitExpr(expr.left)} in ${this.emitExpr(expr.right)}))`;
+                }
+                return `(${this.emitExpr(expr.left)} ${this.binaryOpStr(expr.op)} ${this.emitExpr(expr.right)})`;
+            }
+            case "AssignExpr":
+                return `${this.emitExpr(expr.target)} = ${this.emitExpr(expr.value)}`;
+            case "CompoundAssignExpr":
+                return `${this.emitExpr(expr.target)} ${expr.op} ${this.emitExpr(expr.value)}`;
+            case "IncrDecrExpr":
+                return expr.prefix
+                    ? `${expr.op}${this.emitExpr(expr.target)}`
+                    : `${this.emitExpr(expr.target)}${expr.op}`;
+            case "MemberExpr":
+                return `${this.emitExpr(expr.target)}.${expr.member}`;
+            case "SafeMemberExpr":
+                return `${this.emitExpr(expr.target)}?.${expr.member}`;
+            case "IndexExpr":
+                return `${this.emitExpr(expr.target)}[${this.emitExpr(expr.index)}]`;
+            case "NotNullExpr":
+                // Runtime check
+                this.runtimeSymbolsNeeded.add("notNull");
+                return `notNull(${this.emitExpr(expr.expr)})`;
+            case "SafeCallExpr": {
+                // x?.() — safe invocation of a nullable function value
+                const callee = this.emitExpr(expr.callee);
+                const restArgs = [];
+                for (const a of expr.args) {
+                    restArgs.push(a.spread ? `...${this.emitExpr(a.value)}` : this.emitExpr(a.value));
+                }
+                if (expr.trailingLambda)
+                    restArgs.push(this.emitLambdaExpr(expr.trailingLambda));
+                return `${callee}?.(${restArgs.join(", ")})`;
+            }
+            case "ElvisExpr": {
+                // left ?? right  (null coalescing)
+                return `(${this.emitExpr(expr.left)} ?? ${this.emitExpr(expr.right)})`;
+            }
+            case "CallExpr":
+                return this.emitCallExpr(expr);
+            case "LambdaExpr":
+                return this.emitLambdaExpr(expr);
+            case "IfExpr":
+                return this.emitIfExpr(expr);
+            case "WhenExpr":
+                return this.emitWhenExpr(expr);
+            case "TryCatchExpr":
+                return this.emitTryCatchExpr(expr);
+            case "TypeCheckExpr":
+                return `${expr.negated ? "!(" : ""}${this.emitExpr(expr.expr)} instanceof ${this.emitTypeRef(expr.type)}${expr.negated ? ")" : ""}`;
+            case "TypeCastExpr":
+                // Unsafe cast — emit as `(expr as Type)` which is stripped at runtime
+                return `(${this.emitExpr(expr.expr)} as unknown as ${this.emitTypeRef(expr.type)})`;
+            case "SafeCastExpr": {
+                this.runtimeSymbolsNeeded.add("safeCast");
+                return `safeCast(${this.emitExpr(expr.expr)}, ${this.emitTypeRef(expr.type)})`;
+            }
+            case "RangeExpr": {
+                this.runtimeSymbolsNeeded.add("range");
+                return `range(${this.emitExpr(expr.from)}, ${this.emitExpr(expr.to)}, ${expr.inclusive})`;
+            }
+            case "LaunchExpr": {
+                // fire-and-forget → void IIFE
+                const stmts = this.captureBlock(expr.body);
+                return `(async () => { ${stmts} })()`;
+            }
+            case "AsyncExpr": {
+                // returns Promise<T>
+                const stmts = this.captureBlock(expr.body);
+                return `(async () => { ${stmts} })()`;
+            }
+            case "CollectionLiteralExpr":
+                return this.emitCollectionLiteral(expr);
+            case "ObjectExpr":
+                return this.emitObjectExpr(expr);
+            case "ReturnExpr": {
+                const val = expr.value ? ` ${this.emitExpr(expr.value)}` : "";
+                return `((() => { return${val}; })())`;
+            }
+            case "BreakExpr": return "undefined /* break */";
+            case "ContinueExpr": return "undefined /* continue */";
+            case "JsxElement":
+                return this.emitJsxElement(expr);
+            default:
+                return "undefined";
+        }
+    }
+    // ── JSX ──────────────────────────────────────────────────────────────────
+    emitJsxElement(expr) {
+        const attrsStr = expr.attrs.length > 0
+            ? " " + expr.attrs.map((a) => this.emitJsxAttr(a)).join(" ")
+            : "";
+        if (expr.children.length === 0) {
+            return `<${expr.tag}${attrsStr} />`;
+        }
+        const children = expr.children.map((c) => this.emitJsxChild(c)).join("");
+        return `<${expr.tag}${attrsStr}>${children}</${expr.tag}>`;
+    }
+    emitJsxAttr(attr) {
+        // Map HTML attribute names to React prop names
+        const name = attr.name === "class" ? "className"
+            : attr.name === "for" ? "htmlFor"
+                : attr.name;
+        if (attr.value === null)
+            return name;
+        if (typeof attr.value === "string")
+            return `${name}="${attr.value}"`;
+        return `${name}={${this.emitExpr(attr.value)}}`;
+    }
+    emitJsxChild(child) {
+        switch (child.kind) {
+            case "JsxElement": return this.emitJsxElement(child);
+            case "JsxExprChild": return `{${this.emitExpr(child.expr)}}`;
+            case "JsxTextChild": return child.text;
+        }
+    }
+    emitStringTemplate(expr) {
+        const inner = expr.parts.map((p) => {
+            if (p.kind === "LiteralPart") {
+                return p.value.replace(/`/g, "\\`").replace(/\\/g, "\\\\");
+            }
+            return `\${${this.emitExpr(p.expr)}}`;
+        }).join("");
+        return `\`${inner}\``;
+    }
+    emitCallExpr(expr) {
+        // Rewrite infix numeric extension calls that JS numbers don't natively have:
+        //   `a.downTo(b)` → `downTo(a, b)`   `a.until(b)` → `range(a, b, false)`
+        //   `range.step(n)` → `step(range, n)`
+        if (expr.callee.kind === "MemberExpr" &&
+            (expr.callee.member === "downTo" || expr.callee.member === "until" || expr.callee.member === "step")) {
+            const obj = this.emitExpr(expr.callee.target);
+            const arg = expr.args.length > 0 ? this.emitExpr(expr.args[0].value) : "0";
+            if (expr.callee.member === "downTo") {
+                this.runtimeSymbolsNeeded.add("downTo");
+                return `downTo(${obj}, ${arg})`;
+            }
+            if (expr.callee.member === "until") {
+                this.runtimeSymbolsNeeded.add("range");
+                return `range(${obj}, ${arg}, false)`;
+            }
+            if (expr.callee.member === "step") {
+                this.runtimeSymbolsNeeded.add("step");
+                return `step(${obj}, ${arg})`;
+            }
+        }
+        // Rewrite calls on primitive-receiver extension functions.
+        // `str.truncate(30)` where `String.truncate` is a user extension → `__ext_string_truncate(str, 30)`
+        if (expr.callee.kind === "MemberExpr") {
+            const scopeMember = expr.callee.member;
+            // Scope function call rewriting: `x.let { ... }` → `let_(x, ...)`
+            // `x.apply { ... }` → `apply(x, function(this:any) { ... })`
+            if (scopeMember === "let" || scopeMember === "also" || scopeMember === "apply" || scopeMember === "run" || scopeMember === "takeIf" || scopeMember === "takeUnless") {
+                const receiver = this.emitExpr(expr.callee.target);
+                const lambda = expr.trailingLambda ??
+                    (expr.args.length === 1 && expr.args[0].value.kind === "LambdaExpr"
+                        ? expr.args[0].value
+                        : null);
+                if (lambda) {
+                    if (scopeMember === "let") {
+                        this.runtimeSymbolsNeeded.add("let_");
+                        return `let_(${receiver}, ${this.emitLambdaExpr(lambda)})`;
+                    }
+                    if (scopeMember === "also") {
+                        this.runtimeSymbolsNeeded.add("also");
+                        return `also(${receiver}, ${this.emitLambdaExpr(lambda)})`;
+                    }
+                    if (scopeMember === "apply") {
+                        this.runtimeSymbolsNeeded.add("apply");
+                        const body = this.captureBlockStatements(lambda.body);
+                        return `apply(${receiver}, function(this: any) { ${body} })`;
+                    }
+                    if (scopeMember === "run") {
+                        this.runtimeSymbolsNeeded.add("run_");
+                        const body = this.captureBlockStatements(lambda.body);
+                        return `run_(${receiver}, function(this: any) { ${body} })`;
+                    }
+                    if (scopeMember === "takeIf") {
+                        this.runtimeSymbolsNeeded.add("takeIf");
+                        return `takeIf(${receiver}, ${this.emitLambdaExpr(lambda)})`;
+                    }
+                    if (scopeMember === "takeUnless") {
+                        this.runtimeSymbolsNeeded.add("takeUnless");
+                        return `takeUnless(${receiver}, ${this.emitLambdaExpr(lambda)})`;
+                    }
+                }
+            }
+            // `with(x) { ... }` is a free function handled via seedBuiltins; but rewrite if emitted as member
+        }
+        // Rewrite calls on primitive-receiver extension functions.
+        // `str.truncate(30)` where `String.truncate` is a user extension → `__ext_string_truncate(str, 30)`
+        if (expr.callee.kind === "MemberExpr") {
+            const receiverType = this.typeMap.get(expr.callee.target);
+            const memberName = expr.callee.member;
+            if (receiverType) {
+                const tsTypeName = this.jTypeToReceiverName(receiverType);
+                if (tsTypeName) {
+                    const extMap = this.primitiveExtensions.get(tsTypeName);
+                    if (extMap?.has(memberName)) {
+                        const fnName = extMap.get(memberName);
+                        const receiver = this.emitExpr(expr.callee.target);
+                        const restArgs = expr.args.map((a) => a.spread ? `...${this.emitExpr(a.value)}` : this.emitExpr(a.value));
+                        if (expr.trailingLambda)
+                            restArgs.push(this.emitLambdaExpr(expr.trailingLambda));
+                        return `${fnName}(${[receiver, ...restArgs].join(", ")})`;
+                    }
+                }
+            }
+        }
+        const callee = this.emitExpr(expr.callee);
+        const typeArgs = expr.typeArgs.length > 0
+            ? `<${expr.typeArgs.map((t) => t.star ? "*" : this.emitTypeRef(t.type)).join(", ")}>`
+            : "";
+        // Rewrite top-level `with(obj) { ... }` → `with_(obj, function(this: any) { ... })`
+        if (expr.callee.kind === "NameExpr" && expr.callee.name === "with" &&
+            (expr.trailingLambda || (expr.args.length === 2 && expr.args[1].value.kind === "LambdaExpr"))) {
+            const obj = expr.args.length > 0 ? this.emitExpr(expr.args[0].value) : "undefined";
+            const lambda = expr.trailingLambda ??
+                expr.args[1].value;
+            this.runtimeSymbolsNeeded.add("with_");
+            const body = this.captureBlockStatements(lambda.body);
+            return `with_(${obj}, function(this: any) { ${body} })`;
+        }
+        // Rewrite top-level `run { ... }` (no receiver) — just call the lambda
+        if (expr.callee.kind === "NameExpr" && expr.callee.name === "run" &&
+            expr.args.length === 0 && expr.trailingLambda) {
+            return `(${this.emitLambdaExpr(expr.trailingLambda)})()`;
+        }
+        // Handle named arguments by reordering them to match positional parameters
+        const calleeType = this.typeMap.get(expr.callee);
+        // Compose-style component call: Column(modifier = ...) { ... } → Column({ modifier: ... }, [children])
+        // Also catches star-imported @jalvin/ui primitives (Row, Button, etc.) whose type is T_UNKNOWN
+        if (expr.callee.kind === "NameExpr" && (this.componentNames.has(expr.callee.name) ||
+            (this.hasUiStarImport && (!calleeType || calleeType.tag === "unknown") && /^[A-Z]/.test(expr.callee.name)))) {
+            return this.emitComposeCallAsDom(expr);
+        }
+        let finalArgs = [];
+        if (calleeType && calleeType.tag === "func" && calleeType.paramNames) {
+            const paramNames = calleeType.paramNames;
+            const argsByName = new Map();
+            const positionalArgs = [];
+            for (const arg of expr.args) {
+                if (arg.name) {
+                    argsByName.set(arg.name, arg.spread ? `...${this.emitExpr(arg.value)}` : this.emitExpr(arg.value));
+                }
+                else {
+                    positionalArgs.push(arg.spread ? `...${this.emitExpr(arg.value)}` : this.emitExpr(arg.value));
+                }
+            }
+            // Reconstruct args based on paramNames
+            for (let i = 0; i < paramNames.length; i++) {
+                const name = paramNames[i];
+                if (argsByName.has(name)) {
+                    finalArgs.push(argsByName.get(name));
+                }
+                else if (i < positionalArgs.length) {
+                    finalArgs.push(positionalArgs[i]);
+                }
+                else {
+                    // Missing argument - JS default value logic will handle it if we pass undefined
+                    finalArgs.push("undefined");
+                }
+            }
+            // Handle trailing positional args if any
+            if (positionalArgs.length > paramNames.length) {
+                finalArgs.push(...positionalArgs.slice(paramNames.length));
+            }
+        }
+        else {
+            // Fallback for types we don't know param names for (like constructors or any)
+            finalArgs = expr.args.map((a) => {
+                return a.spread ? `...${this.emitExpr(a.value)}` : this.emitExpr(a.value);
+            });
+        }
+        if (expr.trailingLambda) {
+            finalArgs.push(this.emitLambdaExpr(expr.trailingLambda));
+        }
+        // If the callee is a class instance (not a constructor / function), emit `.invoke(args)`
+        if (calleeType &&
+            calleeType.tag === "class" &&
+            calleeType.decl &&
+            this.classHasInvokeOperator(calleeType.decl)) {
+            return `${callee}.invoke(${finalArgs.join(", ")})`;
+        }
+        // Constructor calls: class names start with uppercase by convention
+        if (this.isConstructorCall(expr.callee)) {
+            return `new ${callee}${typeArgs}(${finalArgs.join(", ")})`;
+        }
+        return `${callee}${typeArgs}(${finalArgs.join(", ")})`;
+    }
+    /**
+     * For each non-scoped local import (e.g. `import src.views.MoveCounterView.MoveCounter`),
+     * attempt to load and parse the corresponding .jalvin source file. If the named symbol is
+     * a `component fun`, register it in `componentNames` and record its param names so that
+     * call sites can emit the correct props-object invocation.
+     */
+    resolveLocalComponentImports(program, sourceRoot) {
+        for (const imp of program.imports) {
+            // Skip scoped packages (@org/pkg) and star imports
+            if (imp.star || imp.path[0]?.startsWith("@"))
+                continue;
+            // Need at least 2 path segments: the last is the symbol, the rest form the file path
+            if (imp.path.length < 2)
+                continue;
+            const rawSymbolName = imp.path[imp.path.length - 1];
+            const symbolName = imp.alias ?? rawSymbolName;
+            const precedingParts = imp.path.slice(0, -1);
+            const candidatePath = nodePath.join(sourceRoot, precedingParts.join("/") + ".jalvin");
+            if (!fs.existsSync(candidatePath))
+                continue;
+            try {
+                const source = fs.readFileSync(candidatePath, "utf8");
+                const diag = new diagnostics_js_1.DiagnosticBag();
+                const tokens = (0, lexer_js_1.lex)(source, candidatePath, diag);
+                if (diag.hasErrors)
+                    continue;
+                const ast = (0, parser_js_1.parse)(tokens, candidatePath, diag, source);
+                if (diag.hasErrors)
+                    continue;
+                // Look for a top-level ComponentDecl matching the imported symbol name
+                const compDecl = ast.declarations.find((d) => d.kind === "ComponentDecl" && d.name === rawSymbolName);
+                if (compDecl) {
+                    this.componentNames.add(symbolName);
+                    this.componentParamNames.set(symbolName, compDecl.params.map((p) => p.name));
+                    this.hasComponents = true;
+                }
+            }
+            catch {
+                // Silently skip if the file cannot be read or parsed
+            }
+        }
+    }
+    /** Returns true if a call expression's callee looks like a class constructor.
+     *  In Jalvin, class names always start with an uppercase letter. */
+    isConstructorCall(calleeExpr) {
+        if (calleeExpr.kind === "NameExpr") {
+            // Names in componentNames are factory functions (UI primitives, components), not constructors
+            if (this.componentNames.has(calleeExpr.name))
+                return false;
+            // Class names start with uppercase; function names start with lowercase
+            return /^[A-Z]/.test(calleeExpr.name);
+        }
+        if (calleeExpr.kind === "MemberExpr") {
+            // e.g. UiState.Success(data), Discount.Percentage(0.1)
+            return /^[A-Z]/.test(calleeExpr.member);
+        }
+        return false;
+    }
+    // ── Compose-style component call → DOM ──────────────────────────────────────
+    /** Emit `Column(modifier = ...) { ... }` as `Column({ modifier: ... }, [children])` */
+    emitComposeCallAsDom(expr) {
+        const tag = expr.callee.name;
+        const calleeType = this.typeMap.get(expr.callee);
+        // Param names from type checker (for same-file components) or resolved from imported files
+        const paramNames = (calleeType?.tag === "func" ? calleeType.paramNames : undefined) ??
+            this.componentParamNames.get(tag);
+        // Build props object from named/positional args
+        const props = [];
+        for (let i = 0; i < expr.args.length; i++) {
+            const arg = expr.args[i];
+            // Prop name: explicit named arg > known param name > NameExpr variable name (shorthand)
+            const propName = arg.name ??
+                paramNames?.[i] ??
+                (arg.value.kind === "NameExpr" ? arg.value.name : undefined);
+            if (!propName)
+                continue;
+            const val = this.emitExpr(arg.value);
+            // Use JS shorthand `{ key }` when key and value are the same identifier
+            props.push(propName === val ? propName : `${propName}: ${val}`);
+        }
+        const propsStr = props.length > 0 ? `{ ${props.join(", ")} }` : "{}";
+        if (expr.trailingLambda) {
+            const children = this.emitLambdaBodyAsDomChildren(expr.trailingLambda);
+            return children ? `${tag}(${propsStr}, [${children}])` : `${tag}(${propsStr})`;
+        }
+        return `${tag}(${propsStr})`;
+    }
+    /** Collect each expression statement in a trailing-lambda body as DOM children. */
+    emitLambdaBodyAsDomChildren(lambda) {
+        return lambda.body
+            .filter((stmt) => stmt.kind === "ExprStmt")
+            .map((stmt) => this.emitExpr(stmt.expr))
+            .join(", ");
+    }
+    emitLambdaExpr(expr) {
+        // If no explicit params, emit `it` as the single implicit parameter
+        // (Convention for single-argument lambdas)
+        const params = expr.params.length === 0
+            ? "it"
+            : expr.params.map((p) => p.name ?? "_").join(", ");
+        const body = expr.body;
+        if (body.length === 1 && body[0].kind === "ExprStmt") {
+            return `(${params}) => ${this.emitExpr(body[0].expr)}`;
+        }
+        return `(${params}) => { ${body.map((s) => this.captureStmt(s)).join(" ")} }`;
+    }
+    emitIfExpr(expr) {
+        const cond = this.emitExpr(expr.condition);
+        const thenStr = expr.then.kind === "Block"
+            ? `(() => { ${this.captureBlockStatements(expr.then.statements)} })()`
+            : this.emitExpr(expr.then);
+        const elseExpr = expr.else;
+        const elseStr = elseExpr.kind === "Block"
+            ? `(() => { ${this.captureBlockStatements(elseExpr.statements)} })()`
+            : elseExpr.kind === "IfExpr"
+                ? this.emitIfExpr(elseExpr)
+                : this.emitExpr(elseExpr);
+        return `(${cond} ? ${thenStr} : ${elseStr})`;
+    }
+    emitWhenExpr(expr) {
+        // Compile as an IIFE with if/else chain
+        const parts = [];
+        const subject = expr.subject ? `const __s = ${this.emitExpr(expr.subject.expr)};` : "";
+        const subjectRef = expr.subject ? (expr.subject.binding ?? "__s") : "";
+        for (const branch of expr.branches) {
+            if (branch.isElse) {
+                const body = branch.body.kind === "Block"
+                    ? this.captureBlock(branch.body)
+                    : `return ${this.emitExpr(branch.body)};`;
+                parts.push(`{ ${body} }`);
+            }
+            else {
+                const cond = branch.conditions.map((c) => this.emitWhenCondition(c, subjectRef)).join(" || ");
+                const body = branch.body.kind === "Block"
+                    ? this.captureBlock(branch.body)
+                    : `return ${this.emitExpr(branch.body)};`;
+                parts.push(`if (${cond}) { ${body} }`);
+            }
+        }
+        return `(() => { ${subject} ${parts.join(" else ")} })()`;
+    }
+    emitTryCatchExpr(expr) {
+        const body = this.captureBlock(expr.body);
+        const catches = expr.catches.map((c) => {
+            const cb = this.captureBlock(c.body);
+            return `catch (${c.name}) { ${cb} }`;
+        }).join(" ");
+        const fin = expr.finally ? `finally { ${this.captureBlock(expr.finally)} }` : "";
+        return `(() => { try { ${body} } ${catches} ${fin} })()`;
+    }
+    emitCollectionLiteral(expr) {
+        if (expr.collectionKind === "map") {
+            const entries = expr.elements.map((e) => {
+                if ("kind" in e && e.kind === "MapEntry") {
+                    return `[${this.emitExpr(e.key)}, ${this.emitExpr(e.value)}]`;
+                }
+                return "null";
+            });
+            return `new Map([${entries.join(", ")}])`;
+        }
+        if (expr.collectionKind === "set") {
+            const items = expr.elements.map((e) => this.emitExpr(e));
+            return `new Set([${items.join(", ")}])`;
+        }
+        const items = expr.elements.map((e) => this.emitExpr(e));
+        return `[${items.join(", ")}]`;
+    }
+    emitObjectExpr(expr) {
+        const superType = expr.superTypes[0];
+        const ext = superType ? ` extends ${this.emitTypeRef(superType.type)}` : "";
+        const members = expr.body.members.map((m) => this.captureClassMember(m)).join(" ");
+        return `(new (class${ext} { ${members} })())`;
+    }
+    // ── capture helpers (emit to temp string) ─────────────────────────────────
+    captureBlock(block) {
+        return block.statements.map((s) => this.captureStmt(s)).join(" ");
+    }
+    captureBlockStatements(stmts) {
+        return stmts.map((s) => this.captureStmt(s)).join(" ");
+    }
+    captureStmt(stmt) {
+        const saved = this.w;
+        const tmp = new Writer();
+        this.w = tmp;
+        this.emitStmt(stmt);
+        this.w = saved;
+        return tmp.output.trim();
+    }
+    captureClassMember(member) {
+        const saved = this.w;
+        const tmp = new Writer();
+        this.w = tmp;
+        this.emitClassMember(member);
+        this.w = saved;
+        return tmp.output.trim();
+    }
+    // ── Type reference emission ────────────────────────────────────────────────
+    emitTypeRef(ref) {
+        switch (ref.kind) {
+            case "SimpleTypeRef": {
+                const name = ref.name.join(".");
+                return PRIMITIVE_TYPE_MAP[name] ?? name;
+            }
+            case "NullableTypeRef":
+                return `${this.emitTypeRef(ref.base)} | null | undefined`;
+            case "GenericTypeRef": {
+                const base = ref.base.name.join(".");
+                const mapped = GENERIC_TYPE_MAP[base] ?? base;
+                const args = ref.args.map((a) => a.star ? "any" : a.type ? this.emitTypeRef(a.type) : "unknown");
+                return `${mapped}<${args.join(", ")}>`;
+            }
+            case "FunctionTypeRef": {
+                const params = ref.params.map((p, i) => `p${i}: ${this.emitTypeRef(p)}`).join(", ");
+                const ret = this.emitTypeRef(ref.returnType);
+                return `(${params}) => ${ret}`;
+            }
+            case "StarProjection":
+                return "any";
+        }
+    }
+    // ── Utility helpers ────────────────────────────────────────────────────────
+    emitTypeParamsStr(params) {
+        if (params.length === 0)
+            return "";
+        const ps = params.map((p) => {
+            const bound = p.upperBound ? ` extends ${this.emitTypeRef(p.upperBound)}` : "";
+            return `${p.name}${bound}`;
+        });
+        return `<${ps.join(", ")}>`;
+    }
+    emitParamsStr(params) {
+        return params.map((p) => {
+            const spread = p.vararg ? "..." : "";
+            // vararg params are rest params in TS: `...name: T[]`
+            const type = this.opts.emitTypes
+                ? `: ${this.emitTypeRef(p.type)}${p.vararg ? "[]" : ""}`
+                : "";
+            const def = p.defaultValue ? ` = ${this.emitExpr(p.defaultValue)}` : "";
+            return `${spread}${p.name}${type}${def}`;
+        }).join(", ");
+    }
+    emitComponentPropsStr(params) {
+        if (params.length === 0)
+            return "";
+        return params.map((p) => {
+            const type = this.opts.emitTypes ? `: ${this.emitTypeRef(p.type)}` : "";
+            return `${p.name}${type}`;
+        }).join(", ");
+    }
+    emitSuperTypesStr(superTypes) {
+        if (superTypes.length === 0)
+            return "";
+        const parts = [];
+        let first = true;
+        for (const s of superTypes) {
+            // TypeScript does NOT allow constructor arguments in the `extends` clause.
+            // Delegation args are passed via `super(args)` inside the constructor.
+            if (first) {
+                parts.push(` extends ${this.emitTypeRef(s.type)}`);
+                first = false;
+            }
+            else {
+                parts.push(` implements ${this.emitTypeRef(s.type)}`);
+            }
+        }
+        return parts.join("");
+    }
+    exportPrefix(mods) {
+        if (mods.visibility === "private" || mods.visibility === "internal")
+            return "";
+        return "export ";
+    }
+    visibilityPrefix(mods) {
+        switch (mods.visibility) {
+            case "private": return "private ";
+            case "protected": return "protected ";
+            case "internal": return "/* internal */ ";
+            default: return "";
+        }
+    }
+    unaryOpStr(op) {
+        if (op === "not")
+            return "!";
+        return op;
+    }
+    binaryOpStr(op) {
+        switch (op) {
+            case "and": return "&&";
+            case "or": return "||";
+            case "xor": return "^";
+            case "shl": return "<<";
+            case "shr": return ">>";
+            case "ushr": return ">>>";
+            // === / !== are JS reference equality (Jalvin's triple-equals)
+            case "===": return "===";
+            case "!==": return "!==";
+            case "..": return "/* .. */ +"; // handled by range()
+            case "..<": return "/* ..< */ +";
+            default: return op;
+        }
+    }
+    // ── AST name walkers (for wildcard import resolution) ─────────────────────
+    /**
+     * Walk the entire program AST and collect all identifier names that are
+     * REFERENCED (i.e., used) in the code: NameExpr values and the first name
+     * component of SimpleTypeRef / GenericTypeRef nodes.
+     *
+     * Jalvin primitive type names (String, Boolean, …) that map to TS primitives
+     * are excluded from TypeRef collection since they never need an import.
+     */
+    gatherReferencedNames(program) {
+        const names = new Set();
+        const visited = new WeakSet();
+        const walk = (val) => {
+            if (!val || typeof val !== "object")
+                return;
+            if (Array.isArray(val)) {
+                for (const item of val)
+                    walk(item);
+                return;
+            }
+            const obj = val;
+            if (visited.has(obj))
+                return;
+            visited.add(obj);
+            const kind = obj["kind"];
+            if (kind === "NameExpr") {
+                const name = obj["name"];
+                if (typeof name === "string")
+                    names.add(name);
+                return; // leaf node
+            }
+            if (kind === "SimpleTypeRef") {
+                const nameArr = obj["name"];
+                if (Array.isArray(nameArr) && nameArr.length > 0) {
+                    const first = nameArr[0];
+                    // Skip Jalvin primitive type names — they're erased to TS primitives.
+                    if (!(first in PRIMITIVE_TYPE_MAP))
+                        names.add(first);
+                }
+                return;
+            }
+            if (kind === "GenericTypeRef") {
+                const base = obj["base"];
+                const nameArr = base?.["name"];
+                if (Array.isArray(nameArr) && nameArr.length > 0) {
+                    const first = nameArr[0];
+                    if (!(first in PRIMITIVE_TYPE_MAP))
+                        names.add(first);
+                }
+                // Fall through to recurse into type arguments
+            }
+            for (const propVal of Object.values(obj)) {
+                walk(propVal);
+            }
+        };
+        for (const decl of program.declarations)
+            walk(decl);
+        return names;
+    }
+    /**
+     * Walk the entire program AST and collect all names that are LOCALLY DEFINED:
+     * top-level declaration names, non-star import aliases, function/lambda
+     * parameters, local val/var bindings, for-loop variables, catch-clause names,
+     * when-subject bindings, and type parameter names.
+     */
+    gatherAllLocalBindings(program) {
+        const names = new Set();
+        const visited = new WeakSet();
+        // Top-level declaration names
+        for (const decl of program.declarations) {
+            const d = decl;
+            if (typeof d.name === "string" && d.name)
+                names.add(d.name);
+        }
+        // Non-star import aliases
+        for (const imp of program.imports) {
+            if (!imp.star) {
+                const name = imp.alias ?? imp.path[imp.path.length - 1];
+                if (name)
+                    names.add(name);
+            }
+        }
+        const walk = (val) => {
+            if (!val || typeof val !== "object")
+                return;
+            if (Array.isArray(val)) {
+                for (const item of val)
+                    walk(item);
+                return;
+            }
+            const obj = val;
+            if (visited.has(obj))
+                return;
+            visited.add(obj);
+            const kind = obj["kind"];
+            // Collect bound names at their declaration sites
+            if (kind === "PropertyDecl" || kind === "DestructuringDecl") {
+                if (typeof obj["name"] === "string")
+                    names.add(obj["name"]);
+                const nms = obj["names"];
+                if (Array.isArray(nms)) {
+                    for (const n of nms) {
+                        if (typeof n === "string")
+                            names.add(n);
+                    }
+                }
+            }
+            if (kind === "FunDecl" || kind === "ExtensionFunDecl" ||
+                kind === "ComponentDecl" || kind === "ClassDecl" ||
+                kind === "DataClassDecl" || kind === "SealedClassDecl" ||
+                kind === "EnumClassDecl" || kind === "InterfaceDecl" ||
+                kind === "ObjectDecl" || kind === "TypeAliasDecl") {
+                if (typeof obj["name"] === "string" && obj["name"])
+                    names.add(obj["name"]);
+                // Type parameters
+                const typeParams = obj["typeParams"];
+                if (Array.isArray(typeParams)) {
+                    for (const tp of typeParams) {
+                        if (tp.name)
+                            names.add(tp.name);
+                    }
+                }
+                // Function/method parameters
+                const params = obj["params"];
+                if (Array.isArray(params)) {
+                    for (const p of params) {
+                        if (p.name)
+                            names.add(p.name);
+                    }
+                }
+            }
+            if (kind === "LambdaExpr") {
+                const params = obj["params"];
+                if (Array.isArray(params)) {
+                    for (const p of params) {
+                        if (p.name)
+                            names.add(p.name);
+                    }
+                }
+            }
+            if (kind === "ForStmt") {
+                const binding = obj["binding"];
+                if (typeof binding === "string") {
+                    names.add(binding);
+                }
+                else if (binding && typeof binding === "object") {
+                    const b = binding;
+                    // TupleDestructure or MapDestructure
+                    if (Array.isArray(b["names"])) {
+                        for (const n of b["names"]) {
+                            if (typeof n === "string")
+                                names.add(n);
+                        }
+                    }
+                    if (typeof b["key"] === "string")
+                        names.add(b["key"]);
+                    if (typeof b["value"] === "string")
+                        names.add(b["value"]);
+                }
+            }
+            if (kind === "TryCatchStmt") {
+                const catches = obj["catches"];
+                if (Array.isArray(catches)) {
+                    for (const c of catches) {
+                        if (c.name)
+                            names.add(c.name);
+                    }
+                }
+            }
+            if (kind === "WhenStmt" || kind === "WhenExpr") {
+                const subject = obj["subject"];
+                if (typeof subject?.["binding"] === "string")
+                    names.add(subject["binding"]);
+            }
+            if (kind === "SecondaryConstructor") {
+                const params = obj["params"];
+                if (Array.isArray(params)) {
+                    for (const p of params) {
+                        if (p.name)
+                            names.add(p.name);
+                    }
+                }
+            }
+            for (const propVal of Object.values(obj)) {
+                walk(propVal);
+            }
+        };
+        for (const decl of program.declarations)
+            walk(decl);
+        return names;
+    }
+}
+exports.CodeGenerator = CodeGenerator;
+// ---------------------------------------------------------------------------
+// Type name mappings (Jalvin → TypeScript)
+// ---------------------------------------------------------------------------
+const PRIMITIVE_TYPE_MAP = {
+    Int: "number",
+    Long: "bigint",
+    Float: "number",
+    Double: "number",
+    Boolean: "boolean",
+    String: "string",
+    Char: "string",
+    Byte: "number",
+    Short: "number",
+    Unit: "void",
+    Any: "unknown",
+    Nothing: "never",
+};
+const GENERIC_TYPE_MAP = {
+    List: "ReadonlyArray",
+    MutableList: "Array",
+    Set: "ReadonlySet",
+    MutableSet: "Set",
+    Map: "ReadonlyMap",
+    MutableMap: "Map",
+    Array: "Array",
+    Pair: "[", // handled specially
+    Triple: "[",
+    Deferred: "Promise",
+    StateFlow: "StateFlow",
+    MutableStateFlow: "MutableStateFlow",
+    Flow: "AsyncIterable",
+};
+const PRIMITIVE_TYPES = new Set(Object.keys(PRIMITIVE_TYPE_MAP));
+// ---------------------------------------------------------------------------
+// Well-known JavaScript / TypeScript global names that must never be emitted
+// as named imports from a wildcard-imported package.
+// ---------------------------------------------------------------------------
+const JS_GLOBAL_NAMES = new Set([
+    // JS built-in constructors and objects
+    "Array", "Map", "Set", "Object", "String", "Number", "Boolean",
+    "Promise", "Error", "TypeError", "RangeError", "SyntaxError", "URIError",
+    "EvalError", "ReferenceError",
+    "console", "Math", "Date", "JSON", "RegExp", "Symbol", "BigInt",
+    "Proxy", "Reflect", "globalThis", "Atomics", "SharedArrayBuffer",
+    "ArrayBuffer", "DataView", "Int8Array", "Uint8Array", "Uint8ClampedArray",
+    "Int16Array", "Uint16Array", "Int32Array", "Uint32Array",
+    "Float32Array", "Float64Array", "BigInt64Array", "BigUint64Array",
+    // Global functions
+    "isNaN", "isFinite", "parseInt", "parseFloat", "eval",
+    "encodeURI", "decodeURI", "encodeURIComponent", "decodeURIComponent",
+    // Browser/Node globals
+    "setTimeout", "clearTimeout", "setInterval", "clearInterval",
+    "queueMicrotask", "requestAnimationFrame", "cancelAnimationFrame",
+    "fetch", "URL", "URLSearchParams", "AbortController", "AbortSignal",
+    "EventTarget", "Event", "CustomEvent", "FormData", "Headers",
+    "Request", "Response", "Blob", "File", "FileReader",
+    "Worker", "SharedWorker", "WebSocket",
+    "ReadableStream", "WritableStream", "TransformStream",
+    "document", "window", "navigator", "location", "history", "screen",
+    "performance", "crypto", "indexedDB", "localStorage", "sessionStorage",
+    "confirm", "alert", "prompt",
+    "process", "Buffer", "global", "require", "module", "exports", "__dirname", "__filename",
+    // Special identifiers
+    "undefined", "null", "NaN", "Infinity",
+    "it", "this", "super", "arguments", "new", "class", "function",
+    // TypeScript primitive type names
+    "any", "unknown", "never", "void", "string", "number", "boolean", "bigint",
+    "object", "symbol",
+    // Jalvin type names that map to TS primitives (never need import)
+    "String", "Boolean", "Any", "Nothing", "Unit", "Char", "Byte", "Short",
+    "Float", "Double",
+]);
+// ---------------------------------------------------------------------------
+// Public helper
+// ---------------------------------------------------------------------------
+function generate(program, opts, operatorOverloads, typeMap) {
+    return new CodeGenerator(opts).generate(program, operatorOverloads, typeMap);
+}
+//# sourceMappingURL=index.js.map