cluaupp 1.5.2 → 2.0.0-beta.2

package/generated/compiler/emit/emitter.js

@@ -0,0 +1,2356 @@
+"use strict";
+/**
+ * Luau emitter. Walks the checked tree and writes idiomatic, `--!strict`-typed Luau:
+ * services hoisted once, `:` method calls decided by type, record-typed classes with metatables,
+ * numeric `for` loops, `continue`, compound assignment, `if`-expressions, string interpolation,
+ * and only the runtime helpers the file actually uses.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LuauEmitter = void 0;
+exports.emitLuau = emitLuau;
+const stdlib_js_1 = require("../stdlib.js");
+const types_js_1 = require("../types.js");
+const luau_types_js_1 = require("./luau-types.js");
+const names_js_1 = require("./names.js");
+const runtime_js_1 = require("./runtime.js");
+const P = { IF: 0, OR: 1, AND: 2, CMP: 3, CONCAT: 4, ADD: 5, MUL: 6, UNARY: 7, POW: 8, ATOM: 10 };
+const atom = (code) => ({ code, prec: P.ATOM });
+class LuauEmitter {
+    program;
+    file;
+    api;
+    options;
+    lines = [];
+    sourceOffset = null;
+    indent = 0;
+    helpers = new Set();
+    services = new Set();
+    names = new Map();
+    reserved;
+    tmp = 0;
+    loops = [];
+    usedLinks = new Set();
+    axiomRuntime = false;
+    sharedTable = false;
+    substitutions = new Map();
+    staticSignals = new Set();
+    enumTablesUsed = new Set();
+    fnDepth = 0;
+    selfName = "self";
+    /** Function symbols referenced so far (for forward declarations). */
+    referencedFuncs = new Set();
+    forwardFuncs = new Set();
+    definedFuncs = new Set();
+    isModule;
+    constructor(program, file, api, options) {
+        this.program = program;
+        this.file = file;
+        this.api = api;
+        this.options = options;
+        this.reserved = (0, names_js_1.reservedGlobals)(api);
+        for (const s of file.services) {
+            this.reserved.add(s);
+        }
+        this.isModule = file.kind === "module";
+        this.assignNames();
+        this.findStaticSignals();
+    }
+    // ---------- naming ----------
+    assignNames() {
+        for (const s of this.file.structs) {
+            s.luauName = (0, names_js_1.isReservedTypeName)(this.api, s.name) || this.reserved.has(s.name) ? `${s.name}_` : (0, names_js_1.sanitizeIdentifier)(s.name);
+        }
+        for (const e of this.file.enums) {
+            e.luauName = this.reserved.has(e.name) || (0, names_js_1.isReservedTypeName)(this.api, e.name) ? `${e.name}_` : (0, names_js_1.sanitizeIdentifier)(e.name);
+        }
+    }
+    nameOf(sym) {
+        const sub = this.substitutions.get(sym.id);
+        if (sub) {
+            return sub;
+        }
+        const known = this.names.get(sym.id);
+        if (known) {
+            return known;
+        }
+        let base = (0, names_js_1.sanitizeIdentifier)(sym.name);
+        if (sym.kind === "struct" && sym.typeId) {
+            const info = this.file.structRegistry.get(sym.typeId);
+            if (info) {
+                base = info.luauName;
+            }
+        }
+        if (names_js_1.LUAU_KEYWORDS.has(base) || this.reserved.has(base) || base.startsWith("__cl")) {
+            base = `${base}_`;
+        }
+        if (sym.kind === "self") {
+            base = this.selfName;
+        }
+        this.names.set(sym.id, base);
+        return base;
+    }
+    temp(prefix = "t") {
+        this.tmp++;
+        return `__${prefix}${this.tmp}`;
+    }
+    struct(id) {
+        const info = this.file.structRegistry.get(id);
+        if (!info) {
+            return null;
+        }
+        if (info.moduleId === this.file.moduleId) {
+            return info.luauName;
+        }
+        const link = this.linkFor((exp) => [...exp.structs.values()].some((s) => s.id === id));
+        if (!link) {
+            return null;
+        }
+        return `${this.linkName(link)}.${info.luauName}`;
+    }
+    enumType(id) {
+        const info = this.file.enumRegistry.get(id);
+        if (!info || !info.hasPayload) {
+            return null;
+        }
+        if (info.moduleId === this.file.moduleId) {
+            return info.luauName;
+        }
+        const link = this.linkFor((exp) => [...exp.enums.values()].some((e) => e.id === id));
+        return link ? `${this.linkName(link)}.${info.luauName}` : null;
+    }
+    linkFor(test) {
+        for (const link of this.file.links) {
+            const exp = link.target.kind === "clp" ? link.target.exports : link.target.kind === "luau" ? link.target.exports : undefined;
+            if (exp && test(exp)) {
+                this.usedLinks.add(link);
+                return link;
+            }
+        }
+        return null;
+    }
+    linkName(link) {
+        return link.sym ? this.nameOf(link.sym) : (0, names_js_1.sanitizeIdentifier)(link.decl.alias);
+    }
+    structRef(id) {
+        return this.struct(id) ?? "nil";
+    }
+    typeOf(t) {
+        return t ? (0, luau_types_js_1.luauType)(t, this) : null;
+    }
+    use(helper) {
+        this.helpers.add(helper);
+        return (0, runtime_js_1.helperFunctionName)(helper);
+    }
+    service(name) {
+        if (name === "Workspace") {
+            return "workspace";
+        }
+        this.services.add(name);
+        return name;
+    }
+    // ---------- writer ----------
+    line(text) {
+        const marker = text && this.sourceOffset !== null && this.options.sourcePosition ? `\u0000SRC${this.sourceOffset}\u0000` : "";
+        this.lines.push(text === "" ? "" : `${"\t".repeat(this.indent)}${text}${marker}`);
+    }
+    block(fn) {
+        this.indent++;
+        fn();
+        this.indent--;
+    }
+    /** Run fn with a fresh line buffer; returns the lines it produced. */
+    capture(fn) {
+        const saved = this.lines;
+        this.lines = [];
+        fn();
+        const out = this.lines;
+        this.lines = saved;
+        return out;
+    }
+    // ---------- entry ----------
+    emit() {
+        const types = this.capture(() => this.emitTypes());
+        const classes = this.capture(() => this.emitClassTables());
+        const functions = this.capture(() => this.emitFunctions());
+        const captured = this.file.topLevel.filter((s) => s.kind === "var" && s.captured);
+        const body = this.capture(() => {
+            for (const stmt of this.program.body) {
+                if (stmt.kind !== "Decl") {
+                    this.stmt(stmt, true);
+                }
+            }
+        });
+        const footer = this.capture(() => this.emitReturn());
+        const out = [];
+        out.push(this.file.mode === "nocheck" ? "--!nocheck" : "--!strict");
+        out.push("--!optimize 2");
+        if (this.file.directives.includes("native")) {
+            out.push("--!native");
+        }
+        out.push(`-- Generated by Cluaupp ${this.options.version} from ${this.options.sourceLabel}. Do not edit: changes are overwritten on build.`);
+        const requireLines = this.capture(() => this.emitRequires());
+        const serviceLines = [...this.services].sort().map((s) => `local ${s} = game:GetService(${(0, names_js_1.luauString)(s)})`);
+        if (serviceLines.length || requireLines.length) {
+            out.push("", ...serviceLines);
+            if (requireLines.length) {
+                if (serviceLines.length) {
+                    out.push("");
+                }
+                out.push(...requireLines);
+            }
+        }
+        const helperNames = (0, runtime_js_1.resolveHelpers)(this.helpers);
+        const helperTypes = helperNames.map((h) => runtime_js_1.HELPERS[h].types).filter(Boolean);
+        const helperCode = helperNames.map((h) => runtime_js_1.HELPERS[h].code).filter(Boolean);
+        if (helperTypes.length || helperCode.length) {
+            out.push("", ...helperTypes, ...(helperTypes.length ? [""] : []), helperCode.join("\n\n"));
+        }
+        if (types.length) {
+            out.push("", ...types);
+        }
+        if (this.sharedTable) {
+            out.push("", "local __clShared: { [string]: any } = {}");
+        }
+        if (classes.length) {
+            out.push("", ...classes);
+        }
+        const forward = [];
+        for (const s of captured) {
+            const t = this.typeOf(s.type);
+            forward.push(`local ${this.nameOf(s)}${t ? `: ${t}` : ""}`);
+        }
+        const forwardFns = this.file.topLevel.filter((s) => s.kind === "func" && this.forwardFuncs.has(s.id)).map((s) => this.nameOf(s));
+        if (forwardFns.length) {
+            forward.push(`local ${forwardFns.join(", ")}`);
+        }
+        if (forward.length) {
+            out.push("", ...forward);
+        }
+        const fnText = functions.map((l) => l.replace(/\u0000DECL(\d+)\u0000/g, (_m, id) => (this.forwardFuncs.has(Number(id)) ? "function" : "local function")));
+        if (fnText.length) {
+            out.push("", ...fnText);
+        }
+        if (body.length) {
+            out.push("", ...body);
+        }
+        if (footer.length) {
+            out.push("", ...footer);
+        }
+        const text = collapseBlankLines(out).join("\n").replace(/\s+$/, "");
+        const mappings = [];
+        const clean = text.split("\n").map((line, index) => line.replace(/\u0000SRC(\d+)\u0000/g, (_m, offset) => {
+            const pos = this.options.sourcePosition(Number(offset));
+            mappings.push({ luauLine: index + 1, clppLine: pos.line, clppColumn: pos.column, file: this.options.sourceLabel });
+            return "";
+        })).join("\n");
+        this.options.onSourceMap?.(mappings);
+        return clean + "\n";
+    }
+    emitRequires() {
+        for (const link of this.file.links) {
+            const target = link.target;
+            if (target.kind === "roblox" || target.kind === "error") {
+                continue;
+            }
+            if (target.kind === "std") {
+                if (target.module === "axiom" && this.axiomRuntime) {
+                    this.line(`local ${this.linkName(link)} = require(${this.options.libsRoot(this.service.bind(this))}:WaitForChild("Axiom"))`);
+                }
+                continue;
+            }
+            const used = this.usedLinks.has(link);
+            if (!used) {
+                continue;
+            }
+            const expr = this.options.requireTarget(link, (name) => this.service(name));
+            if (expr) {
+                this.line(`local ${this.linkName(link)} = require(${expr})`);
+            }
+        }
+    }
+    // ---------- declarations ----------
+    orderedStructs() {
+        const own = this.file.structs;
+        const out = [];
+        const seen = new Set();
+        const visit = (s) => {
+            if (seen.has(s.id)) {
+                return;
+            }
+            seen.add(s.id);
+            for (const b of s.bases) {
+                const base = own.find((x) => x.id === b);
+                if (base) {
+                    visit(base);
+                }
+            }
+            out.push(s);
+        };
+        own.forEach(visit);
+        return out;
+    }
+    exportKw() {
+        return this.isModule ? "export type" : "type";
+    }
+    emitTypes() {
+        for (const e of this.file.enums) {
+            if (!e.hasPayload) {
+                continue;
+            }
+            const payloads = [...new Set(e.cases.map((k) => (k.payload ? this.typeOf(k.payload) ?? "any" : null)).filter(Boolean))];
+            const optional = e.cases.some((k) => !k.payload);
+            const value = payloads.length ? (optional ? `(${payloads.join(" | ")})?` : payloads.join(" | ")) : "nil";
+            this.line(`${this.exportKw()} ${e.luauName} = { tag: number, value: ${value} }`);
+        }
+        for (const s of this.orderedStructs()) {
+            const generics = s.typeParams.length ? `<${s.typeParams.join(", ")}>` : "";
+            this.line(`${this.exportKw()} ${s.luauName}${generics} = {`);
+            this.block(() => {
+                for (const f of s.fields) {
+                    this.line(`${f.name}: ${this.typeOf(f.type) ?? "any"},`);
+                }
+                for (const m of s.methods.values()) {
+                    if (m.isStatic) {
+                        continue;
+                    }
+                    this.line(`${m.name}: ${this.methodType(m)},`);
+                }
+            });
+            this.line("}");
+        }
+    }
+    ownerType(m) {
+        for (const s of this.file.structRegistry.values()) {
+            if (s.name === m.owner && s.methods.get(m.name) === m) {
+                const ref = this.struct(s.id) ?? s.luauName;
+                return s.typeParams.length ? `${ref}<${s.typeParams.join(", ")}>` : ref;
+            }
+        }
+        return "any";
+    }
+    methodType(m) {
+        const params = [`self: ${this.ownerType(m)}`];
+        for (const p of m.type.params) {
+            const t = this.typeOf(p.type) ?? "any";
+            params.push(p.optional && !t.endsWith("?") ? optionalType(t) : t);
+        }
+        if (m.type.variadic) {
+            params.push(`...${this.typeOf(m.type.variadic) ?? "any"}`);
+        }
+        const ret = this.returnType(m.type.ret, m.decl.isAsync);
+        return `(${params.join(", ")}) -> ${ret ?? "()"}`;
+    }
+    returnType(ret, isAsync) {
+        let r = (0, types_js_1.prune)(ret);
+        if (isAsync && r.k === "task") {
+            r = (0, types_js_1.prune)(r.result);
+        }
+        if (r.k === "void") {
+            return "()";
+        }
+        if (r.k === "infer" || r.k === "unknown") {
+            return null;
+        }
+        return this.typeOf(r);
+    }
+    emitClassTables() {
+        for (const e of this.file.enums) {
+            if (this.isModule || this.enumTablesUsed.has(e.id)) {
+                const cases = e.cases.map((k, i) => `${k.name} = ${i}`).join(", ");
+                this.line(`local ${e.luauName} = table.freeze({ ${cases} })`);
+            }
+        }
+        for (const s of this.orderedStructs()) {
+            this.line(`local ${s.luauName} = {}`);
+            this.line(`${s.luauName}.__index = ${s.luauName}`);
+            this.line(`${s.luauName}.__fields = table.freeze({ ${s.fields.map((f) => (0, names_js_1.luauString)(f.name)).join(", ")} })`);
+        }
+        for (const stmt of this.program.body) {
+            if (stmt.kind === "Decl" && stmt.decl.kind === "Namespace") {
+                this.line(`local ${(0, names_js_1.sanitizeIdentifier)(stmt.decl.name)} = {}`);
+            }
+        }
+    }
+    emitFunctions() {
+        let first = true;
+        const sep = () => {
+            if (!first) {
+                this.line("");
+            }
+            first = false;
+        };
+        for (const s of this.orderedStructs()) {
+            if (!s.isAbstract) {
+                sep();
+                this.emitConstructor(s);
+            }
+            for (const m of s.decl.methods) {
+                if (!m.body) {
+                    continue;
+                }
+                sep();
+                this.emitFunction(m, `${s.luauName}.${m.name}`, s);
+            }
+            for (const [name, m] of s.methods) {
+                if (m.owner !== s.name) {
+                    const base = [...this.file.structRegistry.values()].find((x) => x.name === m.owner && x.methods.get(name) === m);
+                    if (base && !m.isAbstract) {
+                        this.line(`${s.luauName}.${name} = ${this.structRef(base.id)}.${name}`);
+                    }
+                }
+            }
+        }
+        for (const stmt of this.program.body) {
+            if (stmt.kind !== "Decl") {
+                continue;
+            }
+            const decl = stmt.decl;
+            if (decl.kind === "Func" && decl.body) {
+                sep();
+                const sym = this.file.funcSyms.get(decl);
+                this.emitFunction(decl, sym ? this.nameOf(sym) : (0, names_js_1.sanitizeIdentifier)(decl.name), null, sym ?? null);
+            }
+            else if (decl.kind === "Namespace") {
+                for (const f of decl.funcs) {
+                    if (f.body) {
+                        sep();
+                        this.emitFunction(f, `${(0, names_js_1.sanitizeIdentifier)(decl.name)}.${f.name}`, null);
+                    }
+                }
+            }
+        }
+    }
+    emitConstructor(s) {
+        const generics = s.typeParams.length ? `<${s.typeParams.join(", ")}>` : "";
+        const selfType = `${s.luauName}${generics}`;
+        const params = s.fields.map((f) => {
+            const t = this.typeOf(f.type) ?? "any";
+            return `${safeName(f.name)}: ${f.defaultValue ? optionalType(t) : t}`;
+        });
+        this.line(`function ${s.luauName}.new${generics}(${params.join(", ")}): ${selfType}`);
+        this.block(() => {
+            const fields = s.fields.map((f) => {
+                const local = safeName(f.name);
+                if (f.defaultValue) {
+                    const def = this.expr(f.defaultValue).code;
+                    return `${fieldKey(f.name)} = if ${local} == nil then ${def} else ${local}`;
+                }
+                return `${fieldKey(f.name)} = ${local}`;
+            });
+            if (fields.length <= 3) {
+                this.line(`local self = { ${fields.join(", ")} } :: ${selfType}`);
+            }
+            else {
+                this.line("local self = {");
+                this.block(() => fields.forEach((f) => this.line(`${f},`)));
+                this.line(`} :: ${selfType}`);
+            }
+            // __index supplies the methods described by the public struct type.
+            this.line(`return setmetatable(self, ${s.luauName})`);
+        });
+        this.line("end");
+    }
+    paramList(params, fnType) {
+        const list = [];
+        const prologue = [];
+        for (const p of params) {
+            const sym = p.sym;
+            const name = sym ? this.nameOf(sym) : (0, names_js_1.sanitizeIdentifier)(p.name);
+            if (p.variadic) {
+                const elem = p.ty && (0, types_js_1.prune)(p.ty).k === "list" ? this.typeOf((0, types_js_1.prune)(p.ty).elem) : null;
+                list.push(elem ? `...: ${elem}` : "...");
+                prologue.push(() => this.line(`local ${name} = { ... }`));
+                continue;
+            }
+            const t = this.typeOf(p.ty);
+            list.push(t ? `${name}: ${p.defaultValue && !t.endsWith("?") ? optionalType(t) : t}` : name);
+            if (p.defaultValue) {
+                const dv = p.defaultValue;
+                prologue.push(() => {
+                    const value = this.expr(dv).code;
+                    this.line(`if ${name} == nil then`);
+                    this.block(() => this.line(`${name} = ${value}`));
+                    this.line("end");
+                });
+            }
+        }
+        void fnType;
+        return { list, prologue };
+    }
+    emitFunction(decl, name, owner, sym = null) {
+        const fnType = sym ? sym.type : this.file.funcSyms.get(decl)?.type ?? null;
+        const isMethod = owner !== null && !decl.isStatic;
+        const generics = [...(isMethod || decl.isStatic ? owner?.typeParams ?? [] : []), ...decl.typeParams];
+        const { list, prologue } = this.paramList(decl.params, fnType);
+        if (isMethod && owner) {
+            const ownerGenerics = owner.typeParams.length ? `<${owner.typeParams.join(", ")}>` : "";
+            list.unshift(`self: ${owner.luauName}${ownerGenerics}`);
+        }
+        const ret = fnType ? this.returnType(fnType.ret, decl.isAsync) : null;
+        const retText = ret && ret !== "()" ? `: ${ret}` : "";
+        if (decl.attributes.some((a) => a.name === "native")) {
+            this.line("@native");
+        }
+        if (decl.doc) {
+            for (const docLine of decl.doc.split(/\r?\n/)) {
+                this.line(`--- ${docLine.trim()}`);
+            }
+        }
+        const header = owner || name.includes(".") ? `function ${name}` : `\u0000DECL${sym?.id ?? 0}\u0000 ${name}`;
+        if (sym) {
+            if (this.referencedFuncs.has(sym.id)) {
+                this.forwardFuncs.add(sym.id);
+            }
+            this.definedFuncs.add(sym.id);
+        }
+        this.line(`${header}${generics.length ? `<${generics.join(", ")}>` : ""}(${list.join(", ")})${retText}`);
+        this.block(() => {
+            this.fnDepth++;
+            const saved = this.loops.splice(0);
+            for (const p of prologue) {
+                p();
+            }
+            this.stmts(decl.body || []);
+            this.loops.push(...saved);
+            this.fnDepth--;
+        });
+        this.line("end");
+    }
+    emitReturn() {
+        if (!this.isModule) {
+            return;
+        }
+        const entries = [];
+        const exp = this.file.exports;
+        for (const [name] of exp.funcs) {
+            const sym = this.file.topLevel.find((s) => s.name === name && s.kind === "func");
+            if (sym) {
+                entries.push(`${fieldKey(name)} = ${this.nameOf(sym)}`);
+            }
+        }
+        for (const [name, k] of exp.consts) {
+            entries.push(`${fieldKey(name)} = ${literal(k.value)}`);
+        }
+        for (const s of this.file.structs) {
+            entries.push(`${fieldKey(s.luauName)} = ${s.luauName}`);
+        }
+        for (const e of this.file.enums) {
+            entries.push(`${fieldKey(e.luauName)} = ${e.luauName}`);
+        }
+        for (const [name] of exp.namespaces) {
+            entries.push(`${fieldKey(name)} = ${(0, names_js_1.sanitizeIdentifier)(name)}`);
+        }
+        if (entries.length === 0) {
+            this.line("return {}");
+            return;
+        }
+        this.line("return table.freeze({");
+        this.block(() => entries.forEach((e) => this.line(`${e},`)));
+        this.line("})");
+    }
+    // ---------- signals ----------
+    /** CL++ signals connected only at the top level resolve at compile time: firing calls the handlers directly. */
+    findStaticSignals() {
+        const dynamic = new Set();
+        const all = new Set();
+        const scan = (stmts, depth) => {
+            for (const s of stmts) {
+                walkStmt(s, (inner, d) => {
+                    if (inner.kind === "Connect" && inner.target === "cl" && inner.signal.kind === "Name" && inner.signal.res?.kind === "signal") {
+                        const id = inner.signal.res.sym.id;
+                        all.add(id);
+                        if (d > 0 || inner.handler.kind === "Function") {
+                            dynamic.add(id);
+                        }
+                    }
+                }, depth);
+            }
+        };
+        scan(this.program.body, 0);
+        for (const id of all) {
+            if (!dynamic.has(id)) {
+                this.staticSignals.add(id);
+            }
+        }
+        for (const s of this.file.topLevel) {
+            if (s.kind === "signal" && !all.has(s.id)) {
+                this.staticSignals.add(s.id);
+            }
+        }
+    }
+    // ---------- statements ----------
+    stmts(list) {
+        for (const s of list) {
+            this.stmt(s, false);
+        }
+    }
+    stmt(s, topLevel) {
+        const saved = this.sourceOffset;
+        this.sourceOffset = s.span.start;
+        try {
+            this.emitStmt(s, topLevel);
+        }
+        finally {
+            this.sourceOffset = saved;
+        }
+    }
+    emitStmt(s, topLevel) {
+        switch (s.kind) {
+            case "Var":
+                this.varStmt(s, topLevel);
+                return;
+            case "Assign":
+                this.assign(s);
+                return;
+            case "Expr":
+                this.exprStmt(s.expr);
+                return;
+            case "If":
+                this.ifStmt(s);
+                return;
+            case "While": {
+                const cond = this.cond(s.cond);
+                this.line(`while ${cond} do`);
+                this.loopBody(s.body, {});
+                this.line("end");
+                return;
+            }
+            case "For":
+                this.forStmt(s);
+                return;
+            case "ForIn":
+                this.forIn(s);
+                return;
+            case "Break":
+                this.breakStmt();
+                return;
+            case "Continue":
+                this.continueStmt();
+                return;
+            case "Return":
+                this.returnStmt(s);
+                return;
+            case "Switch":
+                this.switchStmt(s);
+                return;
+            case "Match":
+                this.matchStmt(s);
+                return;
+            case "Try":
+                this.tryStmt(s);
+                return;
+            case "Output":
+                this.output(s);
+                return;
+            case "Connect":
+                this.connect(s);
+                return;
+            case "Signal": {
+                const sym = s.name.sym;
+                if (sym && !this.staticSignals.has(sym.id)) {
+                    this.line(`local ${this.nameOf(sym)}: { (...any) -> () } = {}`);
+                }
+                return;
+            }
+            case "Using": {
+                const sym = s.sym;
+                if (sym && sym.constValue === undefined && s.target) {
+                    this.line(`local ${this.nameOf(sym)} = ${this.valueOf(s.target).code}`);
+                }
+                return;
+            }
+            case "Block":
+                this.line("do");
+                this.block(() => this.stmts(s.body));
+                this.line("end");
+                return;
+            case "Decl":
+                if (s.decl.kind === "Func" && this.fnDepth > 0) {
+                    const sym = this.file.funcSyms.get(s.decl);
+                    const name = sym ? this.nameOf(sym) : (0, names_js_1.sanitizeIdentifier)(s.decl.name);
+                    const lines = this.capture(() => this.emitFunction(s.decl, name, null, null));
+                    if (lines.length) {
+                        lines[0] = lines[0].replace(`function ${name}`, `local function ${name}`).replace(/\u0000DECL\d+\u0000 /, "local function ");
+                    }
+                    this.lines.push(...lines);
+                }
+                return;
+            default:
+                return;
+        }
+    }
+    varStmt(s, topLevel) {
+        if (s.unpack) {
+            const names = s.names.map((n) => (n.sym ? this.nameOf(n.sym) : (0, names_js_1.sanitizeIdentifier)(n.name)));
+            const src = (0, types_js_1.prune)(s.init?.ty ?? types_js_1.T.any);
+            const init = s.init ? this.expr(s.init).code : "nil";
+            if (src.k === "tuple") {
+                this.line(`local ${names.join(", ")} = ${init}`);
+            }
+            else {
+                this.line(`local ${names.join(", ")} = table.unpack(${init})`);
+            }
+            return;
+        }
+        const n = s.names[0];
+        const sym = n.sym;
+        if (!sym) {
+            return;
+        }
+        if (sym.kind === "const" && sym.constValue !== undefined) {
+            return; // inlined at every use
+        }
+        const name = this.nameOf(sym);
+        const declared = topLevel && sym.captured ? "" : "local ";
+        const annotation = declared ? this.annotationFor(s, sym) : "";
+        if (s.init && s.init.res?.kind === "call" && s.init.res.call.form === "instance") {
+            this.instanceInto(s.init, `${declared}${name}${annotation}`, name);
+        }
+        else if (s.init && s.init.res?.kind === "call" && s.init.res.call.form === "datatype" && s.init.res.call.props.length) {
+            this.datatypeInto(s.init, `${declared}${name}${annotation}`, name);
+        }
+        else {
+            const value = s.init ? this.valueOf(s.init).code : "nil";
+            this.line(`${declared}${name}${annotation} = ${value}`);
+        }
+        if (sym.observable) {
+            const t = this.typeOf(sym.type) ?? "any";
+            this.line(`local ${name}_changed: { (${t}) -> () } = {}`);
+        }
+    }
+    /** Only annotate when Luau could not infer the same type from the initializer. */
+    annotationFor(s, sym) {
+        const t = (0, types_js_1.prune)(sym.type);
+        const init = s.init;
+        const needs = !init ||
+            init.kind === "Null" ||
+            s.declaredType !== null ||
+            ((t.k === "list" || t.k === "dict") && init.kind === "Call" && init.res?.kind === "call" && init.res.call.form === "builtin") ||
+            (t.k === "option" && !isInferredByLuau(init)) ||
+            t.k === "union" ||
+            t.k === "lit";
+        if (!needs) {
+            return "";
+        }
+        const lt = this.typeOf(sym.type);
+        return lt && lt !== "any" ? `: ${lt}` : "";
+    }
+    instanceInto(e, declaration, name) {
+        const res = e.res;
+        const call = res.call;
+        this.line(`${declaration} = Instance.new(${(0, names_js_1.luauString)(call.cls)})`);
+        for (const p of call.props) {
+            this.line(`${name}.${p.name} = ${this.valueOf(p.value).code}`);
+        }
+        if (call.parent) {
+            this.line(`${name}.Parent = ${this.expr(call.parent).code}`);
+        }
+    }
+    datatypeInto(e, declaration, name) {
+        const res = e.res;
+        const call = res.call;
+        this.line(`${declaration} = ${call.name}.new(${this.args(res.args, res.variadicArgs)})`);
+        for (const p of call.props) {
+            this.line(`${name}.${p.name} = ${this.valueOf(p.value).code}`);
+        }
+    }
+    assign(s) {
+        const target = s.target;
+        // Vector component: pos.y = 1 → pos = Vector3.new(pos.X, 1, pos.Z)
+        if (target.kind === "Member" && target.res?.kind === "vectorComponent") {
+            this.assignVectorComponent(target, s.op, s.value);
+            return;
+        }
+        // `x = f(x)`: the old x is dropped by this very statement, so passing it needs no copy.
+        if (s.op === "=" && target.kind === "Name" && target.res?.kind === "local" && s.value.kind === "Call" && s.value.res?.kind === "call") {
+            const id = target.res.sym.id;
+            for (const arg of s.value.res.args) {
+                if (arg && arg.copy && arg.kind === "Name" && arg.res?.kind === "local" && arg.res.sym.id === id) {
+                    arg.copy = false;
+                }
+            }
+        }
+        const targetCode = this.place(target);
+        const t = (0, types_js_1.prune)(target.ty ?? types_js_1.T.any);
+        let value;
+        if (s.op === "=") {
+            value = this.valueOf(s.value).code;
+            this.line(`${targetCode} = ${value}`);
+        }
+        else {
+            const op = s.op[0];
+            const rhs = this.expr(s.value);
+            const intDiv = op === "/" && isIntPair(t, (0, types_js_1.prune)(s.value.ty ?? types_js_1.T.any));
+            if (intDiv) {
+                this.line(`${targetCode} = ${this.use("__cl_idiv")}(${targetCode}, ${rhs.code})`);
+            }
+            else if (op === "%") {
+                this.line(`${targetCode} = math.fmod(${targetCode}, ${rhs.code})`);
+            }
+            else {
+                this.line(`${targetCode} ${s.op} ${rhs.code}`);
+            }
+        }
+        this.notifyObservable(target);
+    }
+    notifyObservable(target) {
+        if (target.kind === "Name" && target.res?.kind === "local" && target.res.sym.observable) {
+            const name = this.nameOf(target.res.sym);
+            this.line(`for _, onChange in ${name}_changed do`);
+            this.block(() => this.line(`onChange(${name})`));
+            this.line("end");
+        }
+    }
+    assignVectorComponent(target, op, valueExpr) {
+        const vecType = (0, types_js_1.prune)(target.object.ty ?? types_js_1.T.any);
+        const dt = vecType.k === "datatype" ? vecType.name : "Vector3";
+        const comps = dt.startsWith("Vector2") ? ["X", "Y"] : ["X", "Y", "Z"];
+        const objectPlace = this.place(target.object);
+        const simple = /^[A-Za-z_][\w.]*$/.test(objectPlace);
+        let src = objectPlace;
+        if (!simple) {
+            src = this.temp("v");
+            this.line(`local ${src} = ${objectPlace}`);
+        }
+        const comp = target.res.component.toUpperCase();
+        const rhs = this.expr(valueExpr).code;
+        const newValue = op === "=" ? rhs : `${src}.${comp} ${op[0]} ${wrapCode(rhs, P.MUL)}`;
+        const args = comps.map((c) => (c === comp ? newValue : `${src}.${c}`));
+        this.line(`${objectPlace} = ${dt}.new(${args.join(", ")})`);
+    }
+    /** Assignable Luau place for a target expression. */
+    place(e) {
+        switch (e.kind) {
+            case "Name":
+                return e.res?.kind === "local" ? this.nameOf(e.res.sym) : (0, names_js_1.sanitizeIdentifier)(e.name);
+            case "SelfField":
+                return e.res?.kind === "sharedField" ? this.shared(e.name) : `${this.selfName}.${e.name}`;
+            case "Member": {
+                const obj = this.expr(e.object);
+                if (e.res?.kind === "vectorComponent") {
+                    return `${wrap(obj, P.ATOM)}.${e.res.component}`;
+                }
+                return `${wrap(obj, P.ATOM)}${memberAccess(e.name)}`;
+            }
+            case "Index":
+                return this.index(e).code;
+            default:
+                return this.expr(e).code;
+        }
+    }
+    shared(name) {
+        this.sharedTable = true;
+        return `__clShared${memberAccess(name)}`;
+    }
+    exprStmt(e) {
+        if (e.kind === "Update") {
+            this.line(`${this.place(e.target)} ${e.delta > 0 ? "+=" : "-="} 1`);
+            this.notifyObservable(e.target);
+            return;
+        }
+        if (e.kind === "Call" && e.res?.kind === "call") {
+            const call = e.res.call;
+            if (call.form === "signalFire") {
+                this.fireSignal(e, call.sym, e.res.args);
+                return;
+            }
+            if (call.form === "instance") {
+                const name = this.temp("i");
+                this.instanceInto(e, `local ${name}`, name);
+                return;
+            }
+        }
+        const code = this.expr(e).code;
+        if (isCallCode(code)) {
+            this.line(code);
+        }
+        else {
+            this.line(`local _ = ${code}`);
+        }
+    }
+    fireSignal(e, sym, args) {
+        const values = args.map((a) => (a ? this.valueOf(a).code : "nil"));
+        if (this.staticSignals.has(sym.id)) {
+            const handlers = sym.handlers ?? [];
+            const needTemps = handlers.length > 1 && values.some((v) => !/^[\w.]+$|^".*"$|^-?\d/.test(v));
+            const passed = needTemps
+                ? values.map((v) => {
+                    const t = this.temp("a");
+                    this.line(`local ${t} = ${v}`);
+                    return t;
+                })
+                : values;
+            for (const h of handlers) {
+                this.line(`${wrap(this.expr(h), P.ATOM)}(${passed.join(", ")})`);
+            }
+            return;
+        }
+        this.line(`for _, handler in ${this.nameOf(sym)} do`);
+        this.block(() => this.line(`handler(${values.join(", ")})`));
+        this.line("end");
+    }
+    connect(s) {
+        if (s.target === "cl") {
+            const sym = s.signal.kind === "Name" && s.signal.res?.kind === "signal" ? s.signal.res.sym : null;
+            if (sym && this.staticSignals.has(sym.id)) {
+                return;
+            }
+            this.line(`table.insert(${this.expr(s.signal).code}, ${this.expr(s.handler).code})`);
+            return;
+        }
+        this.line(`${wrap(this.expr(s.signal), P.ATOM)}:Connect(${this.expr(s.handler).code})`);
+    }
+    output(s) {
+        const value = this.stringy(s.value, s.channel === "report");
+        switch (s.channel) {
+            case "post":
+            case "cout":
+                this.line(`print(${value})`);
+                return;
+            case "warn":
+                this.line(`warn(${value})`);
+                return;
+            case "report":
+                this.line(`error(${value}, 0)`);
+                return;
+        }
+    }
+    /** Value printed the way CL++ prints it. */
+    stringy(e, forceString = false) {
+        const t = (0, types_js_1.prune)(e.ty ?? types_js_1.T.any);
+        const c = this.expr(e);
+        if (t.k === "string" || t.k === "lit" || ((t.k === "int" || t.k === "float" || t.k === "bool") && !forceString)) {
+            return c.code;
+        }
+        if (t.k === "int" || t.k === "float" || t.k === "bool" || t.k === "instance" || t.k === "rbxEnumItem" || (t.k === "datatype" && t.name !== "Vector3" && t.name !== "Vector2")) {
+            return `tostring(${c.code})`;
+        }
+        return `${this.use("__cl_str")}(${c.code})`;
+    }
+    ifStmt(s) {
+        if (s.letName) {
+            const sym = s.letName.sym;
+            const name = sym ? this.nameOf(sym) : (0, names_js_1.sanitizeIdentifier)(s.letName.name);
+            this.line("do");
+            this.block(() => {
+                this.line(`local ${name} = ${this.valueOf(s.cond).code}`);
+                this.line(`if ${this.truthy({ code: name, prec: P.ATOM }, (0, types_js_1.prune)(s.cond.ty ?? types_js_1.T.any))} then`);
+                this.block(() => this.stmts(s.then));
+                if (s.else) {
+                    this.line("else");
+                    this.block(() => this.stmts(s.else));
+                }
+                this.line("end");
+            });
+            this.line("end");
+            return;
+        }
+        this.line(`if ${this.cond(s.cond)} then`);
+        this.block(() => this.stmts(s.then));
+        let rest = s.else;
+        while (rest) {
+            if (rest.length === 1 && rest[0].kind === "If" && !rest[0].letName && !rest[0].attributes) {
+                const next = rest[0];
+                const hoisted = [];
+                let cond = "";
+                hoisted.push(...this.capture(() => {
+                    cond = this.cond(next.cond);
+                }));
+                if (hoisted.length) {
+                    this.line("else");
+                    this.block(() => {
+                        this.lines.push(...hoisted.map((l) => `\t${l}`));
+                        this.line(`if ${cond} then`);
+                        this.block(() => this.stmts(next.then));
+                        if (next.else) {
+                            this.line("else");
+                            this.block(() => this.stmts(next.else));
+                        }
+                        this.line("end");
+                    });
+                    break;
+                }
+                this.line(`elseif ${cond} then`);
+                this.block(() => this.stmts(next.then));
+                rest = next.else;
+                continue;
+            }
+            this.line("else");
+            this.block(() => this.stmts(rest));
+            break;
+        }
+        this.line("end");
+    }
+    loopBody(body, frame) {
+        this.loops.push({ kind: "loop", ...frame });
+        this.block(() => this.stmts(body));
+        this.loops.pop();
+    }
+    forStmt(s) {
+        const numeric = this.numericFor(s);
+        if (numeric) {
+            this.line(`for ${numeric.name} = ${numeric.from}, ${numeric.to}${numeric.step !== "1" ? `, ${numeric.step}` : ""} do`);
+            this.loopBody(s.body, {});
+            this.line("end");
+            return;
+        }
+        this.line("do");
+        this.block(() => {
+            if (s.init) {
+                this.stmt(s.init, false);
+            }
+            const cond = s.cond ? this.cond(s.cond) : "true";
+            this.line(`while ${cond} do`);
+            const step = s.step;
+            this.loopBody(s.body, { step: step ? () => this.stmt(step, false) : undefined });
+            if (step) {
+                this.block(() => this.stmt(step, false));
+            }
+            this.line("end");
+        });
+        this.line("end");
+    }
+    /** `for (let mut i = a; i < b; i++)` with an invariant bound → `for i = a, b - 1 do`. */
+    numericFor(s) {
+        const init = s.init;
+        if (!init || init.kind !== "Var" || init.names.length !== 1 || !init.init || !s.cond || !s.step) {
+            return null;
+        }
+        const sym = init.names[0].sym;
+        if (!sym || !isIntLikeType(sym.type) || sym.captured) {
+            return null;
+        }
+        const cond = s.cond;
+        if (cond.kind !== "Binary" || !["<", "<=", ">", ">="].includes(cond.op) || cond.left.kind !== "Name" || cond.left.res?.kind !== "local" || cond.left.res.sym.id !== sym.id) {
+            return null;
+        }
+        if (!isInvariant(cond.right, s.body)) {
+            return null;
+        }
+        let delta = null;
+        const step = s.step;
+        if (step.kind === "Expr" && step.expr.kind === "Update" && isSym(step.expr.target, sym)) {
+            delta = step.expr.delta;
+        }
+        else if (step.kind === "Assign" && isSym(step.target, sym) && step.value.kind === "Number" && !step.value.isFloat && (step.op === "+=" || step.op === "-=")) {
+            delta = step.op === "+=" ? step.value.value : -step.value.value;
+        }
+        else if (step.kind === "Assign" && step.op === "=" && isSym(step.target, sym) && step.value.kind === "Binary" && (step.value.op === "+" || step.value.op === "-") && isSym(step.value.left, sym) && step.value.right.kind === "Number" && !step.value.right.isFloat) {
+            delta = step.value.op === "+" ? step.value.right.value : -step.value.right.value;
+        }
+        if (!delta || assigns(s.body, sym)) {
+            return null;
+        }
+        const up = cond.op === "<" || cond.op === "<=";
+        if ((up && delta < 0) || (!up && delta > 0)) {
+            return null;
+        }
+        const bound = this.expr(cond.right);
+        let to;
+        if (cond.op === "<=" || cond.op === ">=") {
+            to = bound.code;
+        }
+        else if (cond.right.kind === "Number") {
+            to = (0, names_js_1.luauNumber)(cond.right.value + (up ? -1 : 1));
+        }
+        else {
+            to = `${wrap(bound, P.ADD)} ${up ? "-" : "+"} 1`;
+        }
+        return { name: this.nameOf(sym), from: this.expr(init.init).code, to, step: String(delta) };
+    }
+    forIn(s) {
+        const sym = s.name.sym;
+        const name = sym ? this.nameOf(sym) : (0, names_js_1.sanitizeIdentifier)(s.name.name);
+        const iterable = this.expr(s.iterable);
+        switch (s.iterKind) {
+            case "range": {
+                const to = s.iterable.kind === "Number" ? (0, names_js_1.luauNumber)(s.iterable.value - 1) : `${wrap(iterable, P.ADD)} - 1`;
+                this.line(`for ${name} = 0, ${to} do`);
+                this.loopBody(s.body, {});
+                this.line("end");
+                return;
+            }
+            case "string": {
+                const cp = this.temp("cp");
+                this.line(`for _, ${cp} in utf8.codes(${iterable.code}) do`);
+                this.block(() => this.line(`local ${name} = utf8.char(${cp})`));
+                this.loopBody(s.body, {});
+                this.line("end");
+                return;
+            }
+            case "dict":
+                this.line(`for ${name} in ${iterable.code} do`);
+                this.loopBody(s.body, {});
+                this.line("end");
+                return;
+            default: {
+                if (s.downcast && s.declaredType) {
+                    const raw = this.temp("item");
+                    this.line(`for _, ${raw} in ${iterable.code} do`);
+                    const t = this.typeOf(sym?.type);
+                    this.block(() => this.line(`local ${name} = ${raw}${t ? ` :: ${t}` : ""}`));
+                }
+                else {
+                    this.line(`for _, ${name} in ${iterable.code} do`);
+                }
+                this.loopBody(s.body, {});
+                this.line("end");
+            }
+        }
+    }
+    breakStmt() {
+        for (let i = this.loops.length - 1; i >= 0; i--) {
+            const f = this.loops[i];
+            if (f.kind === "try") {
+                f.usedBreak = true;
+                this.line("return 2");
+                return;
+            }
+            if (f.kind === "switch") {
+                if (f.wrapped) {
+                    this.line("break");
+                }
+                return;
+            }
+            this.line("break");
+            return;
+        }
+        this.line("break");
+    }
+    continueStmt() {
+        for (let i = this.loops.length - 1; i >= 0; i--) {
+            const f = this.loops[i];
+            if (f.kind === "try") {
+                f.usedContinue = true;
+                this.line("return 3");
+                return;
+            }
+            if (f.kind === "switch") {
+                if (f.wrapped) {
+                    f.continueFlag ||= this.temp("continue");
+                    this.line(`${f.continueFlag} = true`);
+                    this.line("break");
+                    return;
+                }
+                continue;
+            }
+            if (f.step) {
+                f.step();
+            }
+            this.line("continue");
+            return;
+        }
+        this.line("continue");
+    }
+    returnStmt(s) {
+        const value = s.value ? this.valueOf(s.value).code : null;
+        const tryFrame = [...this.loops].reverse().find((f) => f.kind === "try");
+        if (tryFrame && this.fnDepth > 0) {
+            tryFrame.usedReturn = true;
+            this.line(value ? `return 1, ${value}` : "return 1");
+            return;
+        }
+        this.line(value ? `return ${value}` : "return");
+    }
+    subject(e) {
+        if (e.kind === "Name" && e.res?.kind === "local") {
+            return this.nameOf(e.res.sym);
+        }
+        const t = this.temp("m");
+        this.line(`local ${t} = ${this.expr(e).code}`);
+        return t;
+    }
+    switchStmt(s) {
+        const needsWrap = s.cases.some((k) => hasInnerBreak(k.body));
+        const frame = { kind: "switch", wrapped: needsWrap };
+        const repeatAt = this.lines.length;
+        if (needsWrap) {
+            this.line("repeat");
+            this.indent++;
+        }
+        const subj = this.subject(s.subject);
+        const subjType = (0, types_js_1.prune)(s.subject.ty ?? types_js_1.T.any);
+        const cases = s.cases.filter((k) => k.test !== null);
+        const def = s.cases.find((k) => k.test === null);
+        this.loops.push(frame);
+        const body = (k) => this.block(() => this.stmts(trimTrailingBreak(k.body)));
+        cases.forEach((k, i) => {
+            const test = this.equality({ code: subj, prec: P.ATOM }, k.test, subjType);
+            this.line(`${i === 0 ? "if" : "elseif"} ${test} then`);
+            body(k);
+        });
+        if (def) {
+            if (cases.length) {
+                this.line("else");
+                body(def);
+            }
+            else {
+                this.line("do");
+                body(def);
+            }
+        }
+        if (cases.length || def) {
+            this.line("end");
+        }
+        this.loops.pop();
+        if (needsWrap) {
+            this.indent--;
+            this.line("until true");
+            if (frame.continueFlag) {
+                this.lines.splice(repeatAt, 0, `${"\t".repeat(this.indent)}local ${frame.continueFlag} = false`);
+                this.line(`if ${frame.continueFlag} then`);
+                this.block(() => this.continueStmt());
+                this.line("end");
+            }
+        }
+    }
+    equality(left, right, t) {
+        const r = this.expr(right);
+        if ((0, types_js_1.isValueTable)(t)) {
+            return `${this.use("__cl_eq")}(${left.code}, ${r.code})`;
+        }
+        return `${wrap(left, P.CONCAT)} == ${wrap(r, P.CONCAT)}`;
+    }
+    matchStmt(s) {
+        const subj = this.subject(s.subject);
+        const subjType = (0, types_js_1.prune)(s.subject.ty ?? types_js_1.T.any);
+        let first = true;
+        let opened = false;
+        for (let index = 0; index < s.arms.length; index++) {
+            const arm = s.arms[index];
+            const lastExhaustive = s.exhaustive === true && index === s.arms.length - 1 && !first && !arm.guard;
+            const computed = this.armTest(arm, subj, subjType);
+            const test = lastExhaustive ? "true" : computed.test;
+            const bind = computed.bind;
+            if (test === "true" && first) {
+                // a lone wildcard
+                this.line("do");
+                opened = true;
+                this.block(() => {
+                    bind();
+                    this.stmts(arm.body);
+                });
+                break;
+            }
+            if (test === "true") {
+                this.line("else");
+                this.block(() => {
+                    bind();
+                    this.stmts(arm.body);
+                });
+                break;
+            }
+            this.line(`${first ? "if" : "elseif"} ${test} then`);
+            opened = true;
+            first = false;
+            this.block(() => {
+                bind();
+                this.stmts(arm.body);
+            });
+        }
+        if (opened) {
+            this.line("end");
+        }
+    }
+    armTest(arm, subj, subjType) {
+        const pattern = arm.pattern;
+        let test = "true";
+        let bindName = null;
+        let bindSource = null;
+        const caseTest = (p) => {
+            const res = p.res;
+            if (res?.kind === "enumCase") {
+                if (res.anyPayload) {
+                    test = `${subj}.tag == ${res.index}`;
+                    if (p.binding) {
+                        bindSource = `${subj}.value`;
+                    }
+                }
+                else {
+                    test = `${subj} == ${res.index}`;
+                }
+            }
+            else if (res?.kind === "builtin") {
+                switch (res.name) {
+                    case "Some":
+                        test = `${subj} ~= nil`;
+                        bindSource = subj;
+                        break;
+                    case "None":
+                        test = `${subj} == nil`;
+                        break;
+                    case "Ok":
+                        test = `${subj}.ok`;
+                        bindSource = `${subj}.value`;
+                        break;
+                    case "Err":
+                        test = `not ${subj}.ok`;
+                        bindSource = `${subj}.error`;
+                        break;
+                    default:
+                        break;
+                }
+            }
+            else if (res?.kind === "rbxEnumItem") {
+                test = `${subj} == Enum.${res.enumName}.${res.item}`;
+            }
+            else if (p.valueExpr) {
+                test = this.equality({ code: subj, prec: P.ATOM }, p.valueExpr, subjType);
+            }
+            if (p.binding && bindSource) {
+                const sym = p.binding.sym;
+                bindName = sym ? this.nameOf(sym) : (0, names_js_1.sanitizeIdentifier)(p.binding.name);
+                if (sym) {
+                    this.substitutions.set(sym.id, bindSource);
+                }
+            }
+        };
+        if (pattern.kind === "Value") {
+            test = this.equality({ code: subj, prec: P.ATOM }, pattern.expr, subjType);
+        }
+        else if (pattern.kind === "Case") {
+            caseTest(pattern);
+        }
+        if (arm.guard) {
+            const guard = this.cond(arm.guard);
+            test = test === "true" ? guard : `${test} and ${parenIfLow(guard)}`;
+        }
+        const sym = pattern.kind === "Case" ? pattern.binding?.sym : undefined;
+        if (sym) {
+            this.substitutions.delete(sym.id);
+        }
+        return {
+            test,
+            bind: () => {
+                if (bindName && bindSource) {
+                    const t = sym ? this.typeOf(sym.type) : null;
+                    this.line(`local ${bindName}${t && t !== "any" ? `: ${t}` : ""} = ${bindSource}${t && t !== "any" && pattern.kind === "Case" && ((pattern.res?.kind === "builtin" && pattern.res.name !== "Some") || pattern.res?.kind === "enumCase") ? ` :: ${t}` : ""}`);
+                }
+            },
+        };
+    }
+    tryStmt(s) {
+        const frame = { kind: "try" };
+        const ok = this.temp("ok");
+        const err = this.temp("err");
+        const val = this.temp("value");
+        this.loops.push(frame);
+        const body = this.capture(() => this.block(() => this.block(() => this.stmts(s.body))));
+        this.loops.pop();
+        const flow = frame.usedBreak || frame.usedContinue || frame.usedReturn;
+        this.line(`local ${ok}, ${err}${flow ? `, ${val}` : ""} = pcall(function()`);
+        this.lines.push(...body.map((l) => (l.startsWith("\t") ? l.slice(1) : l)));
+        this.line("end)");
+        this.line(`if not ${ok} then`);
+        this.block(() => {
+            if (s.catchName) {
+                const sym = s.catchName.sym;
+                const name = sym ? this.nameOf(sym) : (0, names_js_1.sanitizeIdentifier)(s.catchName.name);
+                this.line(`local ${name} = ${this.use("__cl_errmsg")}(${err})`);
+            }
+            this.stmts(s.handler);
+        });
+        if (frame.usedReturn) {
+            this.line(`elseif ${err} == 1 then`);
+            this.block(() => this.line(`return ${val}`));
+        }
+        if (frame.usedBreak) {
+            this.line(`elseif ${err} == 2 then`);
+            this.block(() => this.breakStmt());
+        }
+        if (frame.usedContinue) {
+            this.line(`elseif ${err} == 3 then`);
+            this.block(() => this.continueStmt());
+        }
+        this.line("end");
+    }
+    // ---------- expressions ----------
+    /** Expression whose value flows into a new owner (copy for value semantics). */
+    valueOf(e) {
+        const c = this.expr(e);
+        if (e.copy) {
+            return atom(`${this.use("__cl_copy")}(${c.code})`);
+        }
+        return c;
+    }
+    /** Condition with CL++ truthiness (0 and "" are false). */
+    cond(e) {
+        return this.truthy(this.expr(e), (0, types_js_1.prune)(e.ty ?? types_js_1.T.any));
+    }
+    truthy(c, t) {
+        switch (t.k) {
+            case "int":
+            case "float":
+                return `${wrap(c, P.CMP + 1)} ~= 0`;
+            case "string":
+                return `${wrap(c, P.CMP + 1)} ~= ""`;
+            case "lit":
+                return typeof t.value === "boolean" ? c.code : typeof t.value === "string" ? `${wrap(c, P.CMP + 1)} ~= ""` : `${wrap(c, P.CMP + 1)} ~= 0`;
+            default:
+                return c.code;
+        }
+    }
+    truthyCode(e) {
+        const t = (0, types_js_1.prune)(e.ty ?? types_js_1.T.any);
+        const c = this.expr(e);
+        if (t.k === "int" || t.k === "float" || t.k === "string" || (t.k === "lit" && typeof t.value !== "boolean")) {
+            return { code: this.truthy(c, t), prec: P.CMP };
+        }
+        return c;
+    }
+    expr(e) {
+        switch (e.kind) {
+            case "Number":
+                return { code: (0, names_js_1.luauNumber)(e.value), prec: e.value < 0 ? P.UNARY : P.ATOM };
+            case "String":
+                return atom((0, names_js_1.luauString)(e.value));
+            case "Template":
+                return this.template(e);
+            case "Bool":
+                return atom(e.value ? "true" : "false");
+            case "Null":
+                return atom("nil");
+            case "Name":
+                return this.name(e);
+            case "SelfField":
+                if (e.res?.kind === "sharedField") {
+                    return atom(this.shared(e.name));
+                }
+                if (e.res?.kind === "dataModel") {
+                    return atom("game");
+                }
+                if (e.res?.kind === "global") {
+                    return atom(e.res.luau);
+                }
+                return atom(`${this.selfName}.${e.name}`);
+            case "Member":
+                return this.member(e);
+            case "Scope":
+                return this.scopeAccess(e);
+            case "Index":
+                return this.index(e);
+            case "Call":
+            case "New":
+                return this.call(e);
+            case "Unary":
+                return this.unary(e);
+            case "Binary":
+                return this.binary(e);
+            case "Ternary": {
+                const cond = this.cond(e.cond);
+                const a = this.valueOf(e.then);
+                const b = this.valueOf(e.else);
+                return { code: `if ${cond} then ${a.code} else ${b.code}`, prec: P.IF };
+            }
+            case "Function":
+                return this.functionExpr(e);
+            case "Spawn":
+            case "Thread":
+                return this.spawn(e.kind === "Spawn" ? e.call : e.call);
+            case "Await":
+                return this.await(e);
+            case "Join":
+                this.use("__cl_task");
+                return atom(`__cl_await(${this.expr(e.operand).code})`);
+            case "Move":
+                return this.move(e);
+            case "PCall": {
+                const inner = this.expr(e.operand).code;
+                const body = (0, types_js_1.prune)(e.operand.ty ?? types_js_1.T.any).k === "void" ? inner : `return ${inner}`;
+                return { code: `if pcall(function() ${body} end) then 1 else 0`, prec: P.IF };
+            }
+            case "Parallel": {
+                this.use("__cl_parallel");
+                const jobs = e.calls.map((c) => this.spawn(c).code);
+                return atom(`__cl_parallel({ ${jobs.join(", ")} })`);
+            }
+            case "Update":
+                return this.updateExpr(e);
+            case "Cast": {
+                const inner = this.expr(e.operand);
+                const t = this.typeOf(e.ty);
+                return t ? atom(`(${wrap(inner, P.UNARY).toString()} :: ${t})`) : inner;
+            }
+            default:
+                return atom("nil");
+        }
+    }
+    name(e) {
+        const res = e.res;
+        let code;
+        switch (res?.kind) {
+            case "local":
+                code = this.nameOf(res.sym);
+                break;
+            case "func": {
+                const sym = res.sym;
+                code = this.nameOf(sym);
+                if (sym.topLevel && !this.definedFuncs.has(sym.id) && this.fnDepth > 0) {
+                    this.referencedFuncs.add(sym.id);
+                }
+                if (sym.topLevel && !this.definedFuncs.has(sym.id)) {
+                    this.referencedFuncs.add(sym.id);
+                }
+                break;
+            }
+            case "const":
+                return literalCode(res.value);
+            case "struct":
+                code = this.structRef(res.sym.typeId ?? "");
+                break;
+            case "enum": {
+                const id = res.sym.typeId ?? "";
+                this.enumTablesUsed.add(id);
+                const info = this.file.enumRegistry.get(id);
+                code = info ? info.luauName : (0, names_js_1.sanitizeIdentifier)(e.name);
+                break;
+            }
+            case "module": {
+                const link = this.file.links.find((l) => l.decl.alias === e.name);
+                if (link) {
+                    this.usedLinks.add(link);
+                    code = this.linkName(link);
+                }
+                else {
+                    code = (0, names_js_1.sanitizeIdentifier)(e.name);
+                }
+                break;
+            }
+            case "signal":
+                code = this.nameOf(res.sym);
+                break;
+            case "builtin":
+                code = res.name === "None" ? "nil" : e.name;
+                break;
+            case "global":
+                code = res.luau;
+                break;
+            case "service":
+                code = this.service(res.service);
+                break;
+            case "dataModel":
+                code = "game";
+                break;
+            default:
+                code = (0, names_js_1.sanitizeIdentifier)(e.name);
+        }
+        return atom(code);
+    }
+    member(e) {
+        const res = e.res;
+        switch (res?.kind) {
+            case "const":
+                return literalCode(res.value);
+            case "service":
+                return atom(this.service(res.service));
+            case "enumCase":
+                if (res.anyPayload) {
+                    return atom(`{ tag = ${res.index} }`);
+                }
+                return atom(String(res.index));
+            case "rbxEnum":
+                return atom(`Enum.${res.enumName}`);
+            case "rbxEnumItem":
+                return atom(`Enum.${res.enumName}.${res.item}`);
+            case "stdlib":
+                return atom(this.stdValue(res.module, res.member));
+            case "rbxChild": {
+                const obj = this.expr(e.object);
+                const t = this.typeOf(e.ty);
+                if (res.safe) {
+                    return atom(`(${wrap(obj, P.ATOM)}:WaitForChild(${(0, names_js_1.luauString)(res.childName)})${t && t !== "Instance" ? ` :: ${t}` : ""})`);
+                }
+                return atom(`${wrap(obj, P.ATOM)}${memberAccess(e.name)}`);
+            }
+            case "moduleMember":
+                if (res.moduleId === "namespace") {
+                    return atom(`${(0, names_js_1.sanitizeIdentifier)(res.alias)}${memberAccess(res.member)}`);
+                }
+                break;
+            case "vectorComponent": {
+                const obj = this.expr(e.object);
+                return atom(`${wrap(obj, P.ATOM)}.${res.component}`);
+            }
+            default:
+                break;
+        }
+        const obj = this.expr(e.object);
+        return atom(`${wrap(obj, P.ATOM)}${memberAccess(e.name)}`);
+    }
+    stdValue(module, member) {
+        const fn = (0, stdlib_js_1.stdModule)(module).get(member);
+        if (!fn) {
+            return "nil";
+        }
+        if (module === "axiom" && !fn.inline) {
+            this.axiomRuntime = true;
+            const link = this.file.links.find((l) => l.target.kind === "std" && l.target.module === "axiom");
+            return `${link ? this.linkName(link) : "Axiom"}.${member}`;
+        }
+        if (fn.helper) {
+            return this.use(fn.helper);
+        }
+        const params = fn.params.map((p) => p.name);
+        const body = this.std(fn.inline, params);
+        return `function(${params.join(", ")}) return ${body} end`;
+    }
+    scopeAccess(e) {
+        const obj = this.expr(e.object);
+        if (e.res?.kind === "luauMethod") {
+            return atom(`${wrap(obj, P.ATOM)}:${e.name}`);
+        }
+        if (e.res?.kind === "stdlib") {
+            return atom(this.stdValue(e.res.module, e.res.member));
+        }
+        if (e.res?.kind === "library") {
+            return atom(`${e.res.lib}.${e.res.member}`);
+        }
+        return atom(`${wrap(obj, P.ATOM)}.${e.name}`);
+    }
+    index(e) {
+        const objType = (0, types_js_1.prune)(e.object.ty ?? types_js_1.T.any);
+        const obj = this.expr(e.object);
+        if (e.index.kind === "Binary" && e.index.op === "..") {
+            return atom(`${this.use("__cl_slice")}(${obj.code}, ${this.expr(e.index.left).code}, ${this.expr(e.index.right).code})`);
+        }
+        switch (objType.k) {
+            case "list":
+                return atom(`${wrap(obj, P.ATOM)}[${this.plusOne(e.index)}]`);
+            case "string":
+            case "lit":
+                return atom(`${this.use("__cl_char")}(${obj.code}, ${this.expr(e.index).code})`);
+            case "instance":
+                return atom(`${wrap(obj, P.ATOM)}:FindFirstChild(${this.expr(e.index).code})`);
+            case "tuple":
+                return atom(`(select(${this.plusOne(e.index)}, ${obj.code}))`);
+            default:
+                return atom(`${wrap(obj, P.ATOM)}[${this.expr(e.index).code}]`);
+        }
+    }
+    plusOne(e) {
+        if (e.kind === "Number") {
+            return (0, names_js_1.luauNumber)(e.value + 1);
+        }
+        return `${wrap(this.expr(e), P.ADD)} + 1`;
+    }
+    unary(e) {
+        switch (e.op) {
+            case "-": {
+                if (e.operand.kind === "Number") {
+                    return { code: (0, names_js_1.luauNumber)(-e.operand.value), prec: P.UNARY };
+                }
+                return { code: `-${wrap(this.expr(e.operand), P.UNARY)}`, prec: P.UNARY };
+            }
+            case "not": {
+                const t = (0, types_js_1.prune)(e.operand.ty ?? types_js_1.T.any);
+                const inner = this.expr(e.operand);
+                if (t.k === "int" || t.k === "float") {
+                    return { code: `${wrap(inner, P.CMP + 1)} == 0`, prec: P.CMP };
+                }
+                if (t.k === "string") {
+                    return { code: `${wrap(inner, P.CMP + 1)} == ""`, prec: P.CMP };
+                }
+                return { code: `not ${wrap(inner, P.UNARY)}`, prec: P.UNARY };
+            }
+            case "~":
+                return atom(`bit32.bnot(${this.expr(e.operand).code})`);
+            default:
+                return atom("nil");
+        }
+    }
+    binary(e) {
+        const lt = (0, types_js_1.prune)(e.left.ty ?? types_js_1.T.any);
+        const rt = (0, types_js_1.prune)(e.right.ty ?? types_js_1.T.any);
+        switch (e.op) {
+            case "and":
+            case "or": {
+                if (e.res?.kind === "builtin" && e.res.name === "valueOr") {
+                    return { code: `${wrap(this.expr(e.left), P.OR)} or ${wrap(this.expr(e.right), P.OR + 1)}`, prec: P.OR };
+                }
+                const prec = e.op === "and" ? P.AND : P.OR;
+                const l = this.truthyCode(e.left);
+                const r = this.truthyCode(e.right);
+                return { code: `${wrap(l, prec)} ${e.op} ${wrap(r, prec + 1)}`, prec };
+            }
+            case ".:": {
+                const l = this.concatPart(e.left);
+                const r = this.concatPart(e.right);
+                return { code: `${wrap(l, P.CONCAT)} .. ${wrap(r, P.CONCAT)}`, prec: P.CONCAT };
+            }
+            case "+":
+            case "-":
+            case "*": {
+                if (e.res?.kind === "func") {
+                    return atom(`${this.nameOf(e.res.sym)}(${this.expr(e.left).code}, ${this.expr(e.right).code})`);
+                }
+                const prec = e.op === "*" ? P.MUL : P.ADD;
+                return { code: `${wrap(this.expr(e.left), prec)} ${e.op} ${wrap(this.expr(e.right), prec + 1)}`, prec };
+            }
+            case "/":
+                if (isIntPair(lt, rt)) {
+                    return atom(`${this.use("__cl_idiv")}(${this.expr(e.left).code}, ${this.expr(e.right).code})`);
+                }
+                return { code: `${wrap(this.expr(e.left), P.MUL)} / ${wrap(this.expr(e.right), P.MUL + 1)}`, prec: P.MUL };
+            case "%":
+                if (lt.k === "datatype") {
+                    return { code: `${wrap(this.expr(e.left), P.MUL)} % ${wrap(this.expr(e.right), P.MUL + 1)}`, prec: P.MUL };
+                }
+                return atom(`math.fmod(${this.expr(e.left).code}, ${this.expr(e.right).code})`);
+            case "==":
+            case "!=": {
+                if (((0, types_js_1.isValueTable)(lt) || (0, types_js_1.isValueTable)(rt)) && e.left.kind !== "Null" && e.right.kind !== "Null") {
+                    const call = `${this.use("__cl_eq")}(${this.expr(e.left).code}, ${this.expr(e.right).code})`;
+                    return e.op === "==" ? atom(call) : { code: `not ${call}`, prec: P.UNARY };
+                }
+                return { code: `${wrap(this.expr(e.left), P.CMP + 1)} ${e.op === "==" ? "==" : "~="} ${wrap(this.expr(e.right), P.CMP + 1)}`, prec: P.CMP };
+            }
+            case "<":
+            case "<=":
+            case ">":
+            case ">=": {
+                // generic operands: Luau cannot prove T supports ordering, CL++ checked the call sites
+                const side = (x) => ((0, types_js_1.prune)(x.ty ?? types_js_1.T.any).k === "param" ? `(${this.expr(x).code} :: any)` : wrap(this.expr(x), P.CMP + 1));
+                return { code: `${side(e.left)} ${e.op} ${side(e.right)}`, prec: P.CMP };
+            }
+            case "&":
+                return atom(`bit32.band(${this.expr(e.left).code}, ${this.expr(e.right).code})`);
+            case "|":
+                return atom(`bit32.bor(${this.expr(e.left).code}, ${this.expr(e.right).code})`);
+            case "^":
+                return atom(`bit32.bxor(${this.expr(e.left).code}, ${this.expr(e.right).code})`);
+            case "shl":
+                return atom(`bit32.lshift(${this.expr(e.left).code}, ${this.expr(e.right).code})`);
+            case "shr":
+                return atom(`bit32.arshift(${this.expr(e.left).code}, ${this.expr(e.right).code})`);
+            default:
+                return atom("nil");
+        }
+    }
+    concatPart(e) {
+        const t = (0, types_js_1.prune)(e.ty ?? types_js_1.T.any);
+        const c = this.expr(e);
+        if (t.k === "string" || t.k === "int" || t.k === "float" || (t.k === "lit" && typeof t.value !== "boolean")) {
+            return c;
+        }
+        if (t.k === "bool" || t.k === "lit" || t.k === "instance" || t.k === "rbxEnumItem" || (t.k === "datatype" && t.name !== "Vector3" && t.name !== "Vector2")) {
+            return atom(`tostring(${c.code})`);
+        }
+        return atom(`${this.use("__cl_str")}(${c.code})`);
+    }
+    template(e) {
+        if (e.parts.every((p) => typeof p === "string")) {
+            return atom((0, names_js_1.luauString)(e.parts.join("")));
+        }
+        let out = "`";
+        for (const part of e.parts) {
+            if (typeof part === "string") {
+                out += (0, names_js_1.interpolationText)(part);
+                continue;
+            }
+            const constant = part.res?.kind === "const" ? part.res.value : undefined;
+            if (typeof constant === "string" || typeof constant === "number") {
+                out += (0, names_js_1.interpolationText)(String(constant));
+                continue;
+            }
+            const t = (0, types_js_1.prune)(part.ty ?? types_js_1.T.any);
+            let code = this.expr(part).code;
+            if ((0, types_js_1.isValueTable)(t) || (t.k === "datatype" && (t.name === "Vector3" || t.name === "Vector2")) || t.k === "null" || t.k === "option") {
+                code = `${this.use("__cl_str")}(${code})`;
+            }
+            if (code.includes("{") || code.includes("`")) {
+                const tmp = this.temp("s");
+                this.line(`local ${tmp} = ${code}`);
+                code = tmp;
+            }
+            out += `{${code}}`;
+        }
+        return atom(`${out}\``);
+    }
+    functionExpr(e) {
+        const { list, prologue } = this.paramList(e.params, null);
+        const ret = (0, types_js_1.prune)(e.ty ?? types_js_1.T.any);
+        const retType = ret.k === "func" ? this.returnType(ret.ret, false) : null;
+        const savedLoops = this.loops.splice(0);
+        this.fnDepth++;
+        const body = this.capture(() => this.block(() => {
+            for (const p of prologue) {
+                p();
+            }
+            if (Array.isArray(e.body)) {
+                this.stmts(e.body);
+            }
+            else {
+                const v = this.valueOf(e.body);
+                if ((0, types_js_1.prune)(e.body.ty ?? types_js_1.T.any).k === "void" && isCallCode(v.code)) {
+                    this.line(v.code);
+                }
+                else {
+                    this.line(`return ${v.code}`);
+                }
+            }
+        }));
+        this.fnDepth--;
+        this.loops.push(...savedLoops);
+        const head = `function(${list.join(", ")})${retType && retType !== "()" ? `: ${retType}` : ""}`;
+        if (body.length === 1 && !Array.isArray(e.body) && body[0].trim().length < 60) {
+            return atom(`${head} ${body[0].trim()} end`);
+        }
+        return atom(`${head}\n${body.join("\n")}\n${"\t".repeat(this.indent)}end`);
+    }
+    spawn(call) {
+        this.use("__cl_task");
+        const t = (0, types_js_1.prune)(call.ty ?? types_js_1.T.any);
+        const inner = this.callRaw(call);
+        const body = t.k === "void" ? inner : `return ${inner}`;
+        return atom(`__cl_spawn(function() ${body} end)`);
+    }
+    /** A call to an async function emitted without the implicit spawn. */
+    callRaw(call) {
+        if (call.kind === "Call") {
+            const saved = call.__raw;
+            call.__raw = true;
+            const code = this.expr(call).code;
+            call.__raw = saved;
+            return code;
+        }
+        return this.expr(call).code;
+    }
+    await(e) {
+        const t = (0, types_js_1.prune)(e.operand.ty ?? types_js_1.T.any);
+        if (t.k === "rbxSignal") {
+            return atom(`${wrap(this.expr(e.operand), P.ATOM)}:Wait()`);
+        }
+        if (e.operand.kind === "Call" && this.isAsyncCall(e.operand)) {
+            return atom(this.callRaw(e.operand));
+        }
+        if (t.k === "task") {
+            this.use("__cl_task");
+            return atom(`__cl_await(${this.expr(e.operand).code})`);
+        }
+        return this.expr(e.operand);
+    }
+    isAsyncCall(e) {
+        if (e.kind !== "Call") {
+            return false;
+        }
+        const res = e.callee.res;
+        if (res && (res.kind === "func" || res.kind === "local")) {
+            return Boolean(res.sym.decl?.isAsync);
+        }
+        if (res && res.kind === "method") {
+            return Boolean(this.file.structRegistry.get(res.struct)?.methods.get(res.name)?.decl.isAsync);
+        }
+        return false;
+    }
+    move(e) {
+        const src = this.place(e.operand);
+        const tmp = this.temp("moved");
+        this.line(`local ${tmp} = ${src}`);
+        const t = (0, types_js_1.prune)(e.operand.ty ?? types_js_1.T.any);
+        this.line(`${src} = ${t.k === "string" ? '""' : t.k === "list" || t.k === "dict" ? "{}" : "nil"}`);
+        return atom(tmp);
+    }
+    updateExpr(e) {
+        const target = this.place(e.target);
+        const op = e.delta > 0 ? "+=" : "-=";
+        if (e.prefix) {
+            this.line(`${target} ${op} 1`);
+            return atom(target);
+        }
+        const tmp = this.temp("old");
+        this.line(`local ${tmp} = ${target}`);
+        this.line(`${target} ${op} 1`);
+        return atom(tmp);
+    }
+    // ---------- calls ----------
+    args(args, rest) {
+        const out = args.map((a) => (a ? this.valueOf(a).code : "nil"));
+        for (const r of rest || []) {
+            out.push(this.valueOf(r).code);
+        }
+        return out.join(", ");
+    }
+    call(e) {
+        const res = e.res;
+        if (!res || res.kind !== "call") {
+            if (e.kind === "Call") {
+                return atom(`${wrap(this.expr(e.callee), P.ATOM)}(${e.args.map((a) => this.valueOf(a.value).code).join(", ")})`);
+            }
+            return atom("nil");
+        }
+        const call = res.call;
+        const args = res.args;
+        switch (call.form) {
+            case "struct":
+                return atom(`${this.structRef(call.id)}.new(${this.args(args)})`);
+            case "instance": {
+                if (call.props.length === 0 && !call.parent) {
+                    return atom(`Instance.new(${(0, names_js_1.luauString)(call.cls)})`);
+                }
+                const tmp = this.temp("i");
+                this.instanceInto(e, `local ${tmp}`, tmp);
+                return atom(tmp);
+            }
+            case "datatype": {
+                if (call.props.length === 0) {
+                    return atom(`${call.name}.new(${this.args(args, res.variadicArgs)})`);
+                }
+                const tmp = this.temp("d");
+                this.datatypeInto(e, `local ${tmp}`, tmp);
+                return atom(tmp);
+            }
+            case "enumCase":
+                return atom(`{ tag = ${call.index}, value = ${args[0] ? this.valueOf(args[0]).code : "nil"} }`);
+            case "some":
+            case "variant":
+                return args[0] ? this.valueOf(args[0]) : atom("nil");
+            case "ok":
+                return atom(`{ ok = true, value = ${args[0] ? this.valueOf(args[0]).code : "nil"}, error = nil }`);
+            case "err":
+                return atom(`{ ok = false, value = nil, error = ${args[0] ? this.valueOf(args[0]).code : "nil"} }`);
+            case "builtin":
+                return this.builtin(call.name, args, call.elemType);
+            case "std":
+                return this.stdCall(call.module, call.fn, args);
+            case "signalFire":
+                this.fireSignal(e, call.sym, args);
+                return atom("nil");
+            case "classArg": {
+                const callee = e.callee;
+                const obj = this.expr(callee.object);
+                const rest = this.args(args, res.variadicArgs);
+                const code = `${wrap(obj, P.ATOM)}:${callee.name}(${(0, names_js_1.luauString)(call.cls)}${rest ? `, ${rest}` : ""})`;
+                if (call.cast) {
+                    const t = this.typeOf(e.ty);
+                    return t ? atom(`(${code} :: ${t})`) : atom(code);
+                }
+                return atom(code);
+            }
+            case "cast": {
+                const inner = this.plainCall(e, args, res.variadicArgs);
+                const t = this.typeOf(e.ty);
+                return t ? atom(`(${inner} :: ${t})`) : atom(inner);
+            }
+            case "service":
+                return atom(this.service(call.service));
+            case "convert":
+                return this.convert(call.to, args[0]);
+            case "stringMethod": {
+                const callee = e.callee;
+                return atom(`${wrap(this.expr(callee.object), P.ATOM)}:${call.name}(${this.args(args, res.variadicArgs)})`);
+            }
+            case "observe": {
+                const sym = call.sym;
+                return atom(`table.insert(${this.nameOf(sym)}_changed, ${args[0] ? this.expr(args[0]).code : "nil"})`);
+            }
+            case "table": {
+                const parts = call.keys.map((k, i) => `${fieldKey(k)} = ${args[i] ? this.valueOf(args[i]).code : "nil"}`);
+                return atom(parts.length ? `{ ${parts.join(", ")} }` : "{}");
+            }
+            case "luauMethod":
+            case "call":
+            default: {
+                const ce = e;
+                const code = this.plainCall(ce, args, res.variadicArgs);
+                if (this.isAsyncCall(ce) && !ce.__raw) {
+                    this.use("__cl_task");
+                    return atom(`__cl_spawn(function() return ${code} end)`);
+                }
+                return atom(code);
+            }
+        }
+    }
+    plainCall(e, args, rest) {
+        const callee = e.callee;
+        const argText = this.args(args, rest);
+        if (callee.kind === "Member") {
+            const r = callee.res;
+            const isMethod = (r?.kind === "rbxMethod") ||
+                (r?.kind === "method" && !r.isStatic) ||
+                (r?.kind === "datatypeMember" && r.isMethod) ||
+                (r?.kind === "library" && r.stringMethod);
+            if (isMethod) {
+                return `${wrap(this.expr(callee.object), P.ATOM)}:${callee.name}(${argText})`;
+            }
+            if (r?.kind === "method" && r.isStatic) {
+                return `${this.structRef(r.struct)}.${callee.name}(${argText})`;
+            }
+        }
+        if (callee.kind === "SelfField" && callee.res?.kind === "method" && !callee.res.isStatic) {
+            return `${this.selfName}:${callee.name}(${argText})`;
+        }
+        if (callee.kind === "Scope" && callee.res?.kind === "luauMethod") {
+            return `${wrap(this.expr(callee.object), P.ATOM)}:${callee.name}(${argText})`;
+        }
+        return `${wrap(this.expr(callee), P.ATOM)}(${argText})`;
+    }
+    convert(to, arg) {
+        if (!arg) {
+            return atom("nil");
+        }
+        const t = (0, types_js_1.prune)(arg.ty ?? types_js_1.T.any);
+        const c = this.expr(arg);
+        switch (to) {
+            case "int":
+                if (t.k === "int" || t.k === "enum") {
+                    return c;
+                }
+                if (t.k === "rbxEnumItem") {
+                    return atom(`${wrap(c, P.ATOM)}.Value`);
+                }
+                if (t.k === "string" || t.k === "lit") {
+                    return atom(`${this.use("__cl_toint")}(${c.code})`);
+                }
+                return atom(`${this.use("__cl_trunc")}(${c.code})`);
+            case "float":
+                if (t.k === "string" || (t.k === "lit" && typeof t.value === "string")) {
+                    return atom(`${this.use("__cl_tonumber")}(${c.code})`);
+                }
+                return c;
+            case "string":
+                if (t.k === "string") {
+                    return c;
+                }
+                if (t.k === "int" || t.k === "float" || t.k === "bool") {
+                    return atom(`tostring(${c.code})`);
+                }
+                return atom(`${this.use("__cl_str")}(${c.code})`);
+            case "bool":
+                return { code: this.truthy(c, t), prec: P.CMP };
+            default:
+                return c;
+        }
+    }
+    builtin(name, args, elemType) {
+        const a = (i) => (args[i] ? this.expr(args[i]) : atom("nil"));
+        const v = (i) => (args[i] ? this.valueOf(args[i]) : atom("nil"));
+        switch (name) {
+            case "len": {
+                const t = (0, types_js_1.prune)(args[0]?.ty ?? types_js_1.T.any);
+                if (t.k === "string" || t.k === "lit") {
+                    return atom(`${this.use("__cl_strlen")}(${a(0).code})`);
+                }
+                if (t.k === "dict" || t.k === "table") {
+                    return atom(`${this.use("__cl_count")}(${a(0).code})`);
+                }
+                if (t.k === "buffer") {
+                    return atom(`buffer.len(${a(0).code})`);
+                }
+                return { code: `#${wrap(a(0), P.UNARY)}`, prec: P.UNARY };
+            }
+            case "list":
+            case "array": {
+                const items = args.map((x) => (x ? this.valueOf(x).code : "nil"));
+                return atom(items.length ? `{ ${items.join(", ")} }` : "{}");
+            }
+            case "dictionary": {
+                const parts = [];
+                for (let i = 0; i + 1 < args.length; i += 2) {
+                    const k = args[i];
+                    const key = k.kind === "String" && (0, names_js_1.isIdentifier)(k.value) ? k.value : `[${this.expr(k).code}]`;
+                    parts.push(`${key} = ${this.valueOf(args[i + 1]).code}`);
+                }
+                return atom(parts.length ? `{ ${parts.join(", ")} }` : "{}");
+            }
+            case "push":
+                return atom(`table.insert(${a(0).code}, ${v(1).code})`);
+            case "pop":
+                return atom(`table.remove(${a(0).code})`);
+            case "insert":
+                return atom(`table.insert(${a(0).code}, ${args[1] ? this.plusOne(args[1]) : "1"}, ${v(2).code})`);
+            case "remove": {
+                const t = (0, types_js_1.prune)(args[0]?.ty ?? types_js_1.T.any);
+                if (t.k === "dict" || t.k === "table") {
+                    return atom(`${this.use("__cl_take")}(${a(0).code}, ${a(1).code})`);
+                }
+                return atom(`table.remove(${a(0).code}, ${args[1] ? this.plusOne(args[1]) : "1"})`);
+            }
+            case "find": {
+                if (elemType && (0, types_js_1.isValueTable)(elemType)) {
+                    return atom(`${this.use("__cl_findeq")}(${a(0).code}, ${a(1).code})`);
+                }
+                return { code: `(table.find(${a(0).code}, ${a(1).code}) or 0) - 1`, prec: P.ADD };
+            }
+            case "sort":
+                return atom(`${this.use("__cl_sorted")}(${a(0).code})`);
+            case "mutex":
+                this.use("__cl_mutex");
+                return atom("__cl_mutex()");
+            case "lock":
+                this.use("__cl_mutex");
+                return atom(`__cl_lock(${a(0).code})`);
+            case "unlock":
+                this.use("__cl_mutex");
+                return atom(`__cl_unlock(${a(0).code})`);
+            case "fetch_add": {
+                const target = this.place(args[0]);
+                const tmp = this.temp("old");
+                this.line(`local ${tmp} = ${target}`);
+                this.line(`${target} += ${a(1).code}`);
+                return atom(tmp);
+            }
+            case "atomic_load":
+                return a(0);
+            default:
+                return atom("nil");
+        }
+    }
+    stdCall(module, member, args) {
+        const fn = (0, stdlib_js_1.stdModule)(module).get(member);
+        if (!fn) {
+            return atom("nil");
+        }
+        const codes = args.map((x) => (x ? this.valueOf(x) : atom("nil")));
+        while (codes.length < fn.params.length && fn.params[codes.length]?.optional) {
+            break;
+        }
+        if (fn.inline) {
+            const multi = /@\d/.test(fn.inline);
+            const simple = args.every((x) => !x || isSimple(x));
+            if (!multi || simple) {
+                return { code: this.std(fn.inline, codes.map((c) => c.code), codes), prec: inlinePrec(fn.inline) };
+            }
+        }
+        if (fn.helper) {
+            return atom(`${this.use(fn.helper)}(${codes.map((c) => c.code).join(", ")})`);
+        }
+        this.axiomRuntime = true;
+        const link = this.file.links.find((l) => l.target.kind === "std" && l.target.module === module);
+        const alias = link ? this.linkName(link) : "Axiom";
+        return atom(`${alias}.${member}(${codes.map((c) => c.code).join(", ")})`);
+    }
+    std(template, args, codes) {
+        return template.replace(/[$@](\d)/g, (_m, n) => {
+            const i = Number(n) - 1;
+            const code = codes?.[i];
+            if (code && code.prec < P.ATOM) {
+                return `(${code.code})`;
+            }
+            return args[i] ?? "nil";
+        });
+    }
+}
+exports.LuauEmitter = LuauEmitter;
+// ---------- helpers ----------
+/** Luau infers the type of calls and member reads on its own; annotations there are noise. */
+function isInferredByLuau(e) {
+    return e.kind === "Call" || e.kind === "Member" || e.kind === "Index" || e.kind === "Await";
+}
+function wrap(c, min) {
+    return c.prec < min ? `(${c.code})` : c.code;
+}
+function wrapCode(code, min) {
+    return /^[\w.:"()[\]]+$/.test(code) || min <= P.ADD ? code : `(${code})`;
+}
+function parenIfLow(code) {
+    return /\s(and|or)\s/.test(code) ? `(${code})` : code;
+}
+function optionalType(t) {
+    if (t.endsWith("?") || t === "any") {
+        return t;
+    }
+    return /->|\|/.test(t) ? `(${t})?` : `${t}?`;
+}
+function safeName(name) {
+    const s = (0, names_js_1.sanitizeIdentifier)(name);
+    return names_js_1.LUAU_KEYWORDS.has(s) ? `${s}_` : s;
+}
+function fieldKey(name) {
+    return (0, names_js_1.isIdentifier)(name) ? name : `[${(0, names_js_1.luauString)(name)}]`;
+}
+function memberAccess(name) {
+    return (0, names_js_1.isIdentifier)(name) ? `.${name}` : `[${(0, names_js_1.luauString)(name)}]`;
+}
+function literal(value) {
+    if (value === null) {
+        return "nil";
+    }
+    if (typeof value === "string") {
+        return (0, names_js_1.luauString)(value);
+    }
+    if (typeof value === "number") {
+        return (0, names_js_1.luauNumber)(value);
+    }
+    return value ? "true" : "false";
+}
+function literalCode(value) {
+    return { code: literal(value), prec: typeof value === "number" && value < 0 ? P.UNARY : P.ATOM };
+}
+function inlinePrec(template) {
+    if (/^\w[\w.]*\([^()]*(\([^()]*\))*[^()]*\)$/.test(template) || /^[\w.]+$/.test(template)) {
+        return P.ATOM;
+    }
+    if (/ ~= | == | <= | >= | < | > /.test(template)) {
+        return / and | or /.test(template) ? P.AND : P.CMP;
+    }
+    if (/ [+-] /.test(template)) {
+        return P.ADD;
+    }
+    if (/ [*/%] /.test(template)) {
+        return P.MUL;
+    }
+    if (/\^/.test(template)) {
+        return P.POW;
+    }
+    return P.UNARY;
+}
+function isCallCode(code) {
+    return /\)$/.test(code.trim()) && !/^\(/.test(code.trim()) && !/^if /.test(code.trim());
+}
+function isSimple(e) {
+    return e.kind === "Name" || e.kind === "Number" || e.kind === "String" || e.kind === "Bool" || e.kind === "SelfField" || (e.kind === "Member" && isSimple(e.object));
+}
+function isIntLikeType(t) {
+    const p = (0, types_js_1.prune)(t);
+    return p.k === "int";
+}
+function isIntPair(a, b) {
+    const isInt = (t) => t.k === "int" || (t.k === "lit" && typeof t.value === "number" && Number.isInteger(t.value));
+    return isInt(a) && isInt(b);
+}
+function isSym(e, sym) {
+    return e.kind === "Name" && e.res?.kind === "local" && e.res.sym.id === sym.id;
+}
+function assigns(body, sym) {
+    let found = false;
+    const visit = (n) => {
+        if (found || !n || typeof n !== "object") {
+            return;
+        }
+        if (Array.isArray(n)) {
+            n.forEach(visit);
+            return;
+        }
+        const rec = n;
+        if ((rec.kind === "Assign" || rec.kind === "Update") && rec.target && isSym(rec.target, sym)) {
+            found = true;
+            return;
+        }
+        if (rec.kind === "Function") {
+            found = found || JSON.stringify(Object.keys(rec)).length < 0;
+        }
+        for (const [k, v] of Object.entries(n)) {
+            if (k !== "ty" && k !== "res" && k !== "span" && k !== "sym" && k !== "narrowedFrom") {
+                visit(v);
+            }
+        }
+    };
+    visit(body);
+    return found;
+}
+function isInvariant(e, body) {
+    if (e.kind === "Number") {
+        return true;
+    }
+    if (e.kind === "Name") {
+        if (e.res?.kind === "const") {
+            return true;
+        }
+        if (e.res?.kind === "local") {
+            const sym = e.res.sym;
+            return !sym.mutable || !assigns(body, sym);
+        }
+    }
+    if (e.kind === "Binary" && (e.op === "+" || e.op === "-" || e.op === "*")) {
+        return isInvariant(e.left, body) && isInvariant(e.right, body);
+    }
+    if (e.kind === "Member" && e.res?.kind === "const") {
+        return true;
+    }
+    return false;
+}
+function trimTrailingBreak(body) {
+    if (body.length && body[body.length - 1].kind === "Break") {
+        return body.slice(0, -1);
+    }
+    return body;
+}
+/** A `break` before the end of a switch case (needs a `repeat … until true` wrapper). */
+function hasInnerBreak(body) {
+    const trimmed = trimTrailingBreak(body);
+    let found = false;
+    const visit = (s) => {
+        if (found) {
+            return;
+        }
+        switch (s.kind) {
+            case "Break":
+                found = true;
+                return;
+            case "If":
+                s.then.forEach(visit);
+                s.else?.forEach(visit);
+                return;
+            case "Block":
+                s.body.forEach(visit);
+                return;
+            case "Match":
+                s.arms.forEach((a) => a.body.forEach(visit));
+                return;
+            case "Try":
+                s.body.forEach(visit);
+                s.handler.forEach(visit);
+                return;
+            default:
+                return;
+        }
+    };
+    trimmed.forEach(visit);
+    return found;
+}
+function walkStmt(s, fn, depth) {
+    fn(s, depth);
+    const inner = (list, d = depth) => list?.forEach((x) => walkStmt(x, fn, d));
+    switch (s.kind) {
+        case "If":
+            inner(s.then);
+            inner(s.else);
+            break;
+        case "While":
+        case "ForIn":
+            inner(s.body);
+            break;
+        case "For":
+            inner(s.body);
+            break;
+        case "Block":
+            inner(s.body);
+            break;
+        case "Try":
+            inner(s.body);
+            inner(s.handler);
+            break;
+        case "Match":
+            s.arms.forEach((a) => inner(a.body));
+            break;
+        case "Switch":
+            s.cases.forEach((k) => inner(k.body));
+            break;
+        case "Decl":
+            if (s.decl.kind === "Func") {
+                inner(s.decl.body, depth + 1);
+            }
+            else if (s.decl.kind === "Struct") {
+                s.decl.methods.forEach((m) => inner(m.body, depth + 1));
+            }
+            else if (s.decl.kind === "Namespace") {
+                s.decl.funcs.forEach((f) => inner(f.body, depth + 1));
+            }
+            break;
+        default:
+            break;
+    }
+}
+function collapseBlankLines(lines) {
+    const out = [];
+    for (const l of lines) {
+        if (l.trim() === "" && (out.length === 0 || out[out.length - 1].trim() === "")) {
+            continue;
+        }
+        out.push(l);
+    }
+    return out;
+}
+function emitLuau(program, file, api, options) {
+    return new LuauEmitter(program, file, api, options).emit();
+}