cluaupp 1.5.2 → 2.0.0-beta.1

package/src/compiler/emit/emitter.ts

@@ -0,0 +1,2486 @@
+/**
+ * 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.
+ */
+
+import type { Arg, Expr, FuncDecl, MatchArm, Param, Pattern, Program, Stmt, SwitchCase } from "../ast.js";
+import type { FileInfo, LinkInfo } from "../checker/checker.js";
+import type { EnumInfo, MethodInfo, StructInfo, Sym } from "../checker/symbols.js";
+import type { RobloxApi } from "../roblox/api.js";
+import { stdModule } from "../stdlib.js";
+import { isDynamic, isValueTable, prune, T, type Type } from "../types.js";
+import { luauType, type TypeNaming } from "./luau-types.js";
+import { interpolationText, isIdentifier, isReservedTypeName, LUAU_KEYWORDS, luauNumber, luauString, reservedGlobals, sanitizeIdentifier } from "./names.js";
+import { HELPERS, helperFunctionName, resolveHelpers } from "./runtime.js";
+
+export interface EmitOptions {
+	sourcePosition?(offset: number): {line: number; column: number};
+	onSourceMap?(lines: import("../../clpp/contract.js").SourceMapLine[]): void;
+	/** Source path shown in the header (relative to the project). */
+	sourceLabel: string;
+	version: string;
+	/** Luau expression of the Instance a link points to (the argument of `require`), or null. */
+	requireTarget(link: LinkInfo, service: (name: string) => string): string | null;
+	/** Luau expression of the CluauppLibs folder. */
+	libsRoot(service: (name: string) => string): string;
+}
+
+const P = { IF: 0, OR: 1, AND: 2, CMP: 3, CONCAT: 4, ADD: 5, MUL: 6, UNARY: 7, POW: 8, ATOM: 10 } as const;
+
+interface Code {
+	code: string;
+	prec: number;
+}
+
+interface LoopFrame {
+	kind: "loop" | "switch" | "try";
+	/** Statements to run before `continue` (C-style for step). */
+	step?: () => void;
+	/** Inside a pcall closure: control flow is returned as codes. */
+	usedBreak?: boolean;
+	usedContinue?: boolean;
+	usedReturn?: boolean;
+	/** Switch wrapped in `repeat … until true`. */
+	wrapped?: boolean;
+	continueFlag?: string;
+}
+
+const atom = (code: string): Code => ({ code, prec: P.ATOM });
+
+export class LuauEmitter implements TypeNaming {
+	private lines: string[] = [];
+	private sourceOffset: number | null = null;
+	private indent = 0;
+	private readonly helpers = new Set<string>();
+	private readonly services = new Set<string>();
+	private readonly names = new Map<number, string>();
+	private readonly reserved: Set<string>;
+	private tmp = 0;
+	private readonly loops: LoopFrame[] = [];
+	private readonly usedLinks = new Set<LinkInfo>();
+	private axiomRuntime = false;
+	private sharedTable = false;
+	private readonly substitutions = new Map<number, string>();
+	private readonly staticSignals = new Set<number>();
+	private readonly enumTablesUsed = new Set<string>();
+	private fnDepth = 0;
+	private selfName = "self";
+	/** Function symbols referenced so far (for forward declarations). */
+	private readonly referencedFuncs = new Set<number>();
+	private readonly forwardFuncs = new Set<number>();
+	private readonly definedFuncs = new Set<number>();
+	private readonly isModule: boolean;
+
+	constructor(
+		private readonly program: Program,
+		private readonly file: FileInfo,
+		private readonly api: RobloxApi,
+		private readonly options: EmitOptions,
+	) {
+		this.reserved = reservedGlobals(api);
+		for (const s of file.services) {
+			this.reserved.add(s);
+		}
+		this.isModule = file.kind === "module";
+		this.assignNames();
+		this.findStaticSignals();
+	}
+
+	// ---------- naming ----------
+
+	private assignNames(): void {
+		for (const s of this.file.structs) {
+			s.luauName = isReservedTypeName(this.api, s.name) || this.reserved.has(s.name) ? `${s.name}_` : sanitizeIdentifier(s.name);
+		}
+		for (const e of this.file.enums) {
+			e.luauName = this.reserved.has(e.name) || isReservedTypeName(this.api, e.name) ? `${e.name}_` : sanitizeIdentifier(e.name);
+		}
+	}
+
+	nameOf(sym: Sym): string {
+		const sub = this.substitutions.get(sym.id);
+		if (sub) {
+			return sub;
+		}
+		const known = this.names.get(sym.id);
+		if (known) {
+			return known;
+		}
+		let base = sanitizeIdentifier(sym.name);
+		if (sym.kind === "struct" && sym.typeId) {
+			const info = this.file.structRegistry.get(sym.typeId);
+			if (info) {
+				base = info.luauName;
+			}
+		}
+		if (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;
+	}
+
+	private temp(prefix = "t"): string {
+		this.tmp++;
+		return `__${prefix}${this.tmp}`;
+	}
+
+	struct(id: string): string | null {
+		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: string): string | null {
+		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;
+	}
+
+	private linkFor(test: (exp: NonNullable<Extract<LinkInfo["target"], { kind: "clp" }>>["exports"]) => boolean): LinkInfo | null {
+		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;
+	}
+
+	private linkName(link: LinkInfo): string {
+		return link.sym ? this.nameOf(link.sym as Sym) : sanitizeIdentifier(link.decl.alias);
+	}
+
+	private structRef(id: string): string {
+		return this.struct(id) ?? "nil";
+	}
+
+	private typeOf(t: Type | undefined): string | null {
+		return t ? luauType(t, this) : null;
+	}
+
+	private use(helper: string): string {
+		this.helpers.add(helper);
+		return helperFunctionName(helper);
+	}
+
+	private service(name: string): string {
+		if (name === "Workspace") {
+			return "workspace";
+		}
+		this.services.add(name);
+		return name;
+	}
+
+	// ---------- writer ----------
+
+	private line(text: string): void {
+		const marker = text && this.sourceOffset !== null && this.options.sourcePosition ? `\u0000SRC${this.sourceOffset}\u0000` : "";
+		this.lines.push(text === "" ? "" : `${"\t".repeat(this.indent)}${text}${marker}`);
+	}
+
+	private block(fn: () => void): void {
+		this.indent++;
+		fn();
+		this.indent--;
+	}
+
+	/** Run fn with a fresh line buffer; returns the lines it produced. */
+	private capture(fn: () => void): string[] {
+		const saved = this.lines;
+		this.lines = [];
+		fn();
+		const out = this.lines;
+		this.lines = saved;
+		return out;
+	}
+
+	// ---------- entry ----------
+
+	emit(): string {
+		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: string[] = [];
+		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(${luauString(s)})`);
+		if (serviceLines.length || requireLines.length) {
+			out.push("", ...serviceLines);
+			if (requireLines.length) {
+				if (serviceLines.length) {
+					out.push("");
+				}
+				out.push(...requireLines);
+			}
+		}
+		const helperNames = resolveHelpers(this.helpers);
+		const helperTypes = helperNames.map((h) => HELPERS[h].types).filter(Boolean) as string[];
+		const helperCode = helperNames.map((h) => 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: string[] = [];
+		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: string) => (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: import("../../clpp/contract.js").SourceMapLine[] = [];
+  const clean = text.split("\n").map((line, index) => line.replace(/\u0000SRC(\d+)\u0000/g, (_m, offset: string) => {
+   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";
+	}
+
+	private emitRequires(): void {
+		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 ----------
+
+	private orderedStructs(): StructInfo[] {
+		const own = this.file.structs;
+		const out: StructInfo[] = [];
+		const seen = new Set<string>();
+		const visit = (s: StructInfo) => {
+			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;
+	}
+
+	private exportKw(): string {
+		return this.isModule ? "export type" : "type";
+	}
+
+	private emitTypes(): void {
+		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) as string[])];
+			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("}");
+		}
+	}
+
+	private ownerType(m: MethodInfo): string {
+		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";
+	}
+
+	private methodType(m: MethodInfo): string {
+		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 ?? "()"}`;
+	}
+
+	private returnType(ret: Type, isAsync: boolean): string | null {
+		let r = prune(ret);
+		if (isAsync && r.k === "task") {
+			r = prune(r.result);
+		}
+		if (r.k === "void") {
+			return "()";
+		}
+		if (r.k === "infer" || r.k === "unknown") {
+			return null;
+		}
+		return this.typeOf(r);
+	}
+
+	private emitClassTables(): void {
+		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) => luauString(f.name)).join(", ")} })`);
+		}
+		for (const stmt of this.program.body) {
+			if (stmt.kind === "Decl" && stmt.decl.kind === "Namespace") {
+				this.line(`local ${sanitizeIdentifier(stmt.decl.name)} = {}`);
+			}
+		}
+	}
+
+	private emitFunctions(): void {
+		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) : sanitizeIdentifier(decl.name), null, sym ?? null);
+			} else if (decl.kind === "Namespace") {
+				for (const f of decl.funcs) {
+					if (f.body) {
+						sep();
+						this.emitFunction(f, `${sanitizeIdentifier(decl.name)}.${f.name}`, null);
+					}
+				}
+			}
+		}
+	}
+
+	private emitConstructor(s: StructInfo): void {
+		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");
+	}
+
+	private paramList(params: Param[], fnType: Extract<Type, { k: "func" }> | null): { list: string[]; prologue: Array<() => void> } {
+		const list: string[] = [];
+		const prologue: Array<() => void> = [];
+		for (const p of params) {
+			const sym = p.sym as Sym | undefined;
+			const name = sym ? this.nameOf(sym) : sanitizeIdentifier(p.name);
+			if (p.variadic) {
+				const elem = p.ty && prune(p.ty).k === "list" ? this.typeOf((prune(p.ty) as Extract<Type, { k: "list" }>).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 };
+	}
+
+	private emitFunction(decl: FuncDecl, name: string, owner: StructInfo | null, sym: Sym | null = null): void {
+		const fnType = sym ? (sym.type as Extract<Type, { k: "func" }>) : (this.file.funcSyms.get(decl)?.type as Extract<Type, { k: "func" }> | undefined) ?? 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");
+	}
+
+	private emitReturn(): void {
+		if (!this.isModule) {
+			return;
+		}
+		const entries: string[] = [];
+		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)} = ${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. */
+	private findStaticSignals(): void {
+		const dynamic = new Set<number>();
+		const all = new Set<number>();
+		const scan = (stmts: Stmt[], depth: number) => {
+			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 as 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 ----------
+
+	private stmts(list: Stmt[]): void {
+		for (const s of list) {
+			this.stmt(s, false);
+		}
+	}
+
+	private stmt(s: Stmt, topLevel: boolean): void {
+		const saved = this.sourceOffset;
+		this.sourceOffset = s.span.start;
+		try {this.emitStmt(s, topLevel);} finally {this.sourceOffset = saved;}
+	}
+
+	private emitStmt(s: Stmt, topLevel: boolean): void {
+		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 as Sym | undefined;
+				if (sym && !this.staticSignals.has(sym.id)) {
+					this.line(`local ${this.nameOf(sym)}: { (...any) -> () } = {}`);
+				}
+				return;
+			}
+			case "Using": {
+				const sym = s.sym as Sym | undefined;
+				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) : sanitizeIdentifier(s.decl.name);
+					const lines = this.capture(() => this.emitFunction(s.decl as FuncDecl, 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;
+		}
+	}
+
+	private varStmt(s: Extract<Stmt, { kind: "Var" }>, topLevel: boolean): void {
+		if (s.unpack) {
+			const names = s.names.map((n) => (n.sym ? this.nameOf(n.sym as Sym) : sanitizeIdentifier(n.name)));
+			const src = prune(s.init?.ty ?? 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 as Sym | undefined;
+		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. */
+	private annotationFor(s: Extract<Stmt, { kind: "Var" }>, sym: Sym): string {
+		const t = 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}` : "";
+	}
+
+	private instanceInto(e: Expr, declaration: string, name: string): void {
+		const res = e.res as Extract<NonNullable<Expr["res"]>, { kind: "call" }>;
+		const call = res.call as Extract<typeof res.call, { form: "instance" }>;
+		this.line(`${declaration} = Instance.new(${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}`);
+		}
+	}
+
+	private datatypeInto(e: Expr, declaration: string, name: string): void {
+		const res = e.res as Extract<NonNullable<Expr["res"]>, { kind: "call" }>;
+		const call = res.call as Extract<typeof res.call, { form: "datatype" }>;
+		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}`);
+		}
+	}
+
+	private assign(s: Extract<Stmt, { kind: "Assign" }>): void {
+		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 as Sym).id;
+			for (const arg of s.value.res.args) {
+				if (arg && arg.copy && arg.kind === "Name" && arg.res?.kind === "local" && (arg.res.sym as Sym).id === id) {
+					arg.copy = false;
+				}
+			}
+		}
+		const targetCode = this.place(target);
+		const t = prune(target.ty ?? T.any);
+		let value: string;
+		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, prune(s.value.ty ?? 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);
+	}
+
+	private notifyObservable(target: Expr): void {
+		if (target.kind === "Name" && target.res?.kind === "local" && (target.res.sym as Sym).observable) {
+			const name = this.nameOf(target.res.sym as Sym);
+			this.line(`for _, onChange in ${name}_changed do`);
+			this.block(() => this.line(`onChange(${name})`));
+			this.line("end");
+		}
+	}
+
+	private assignVectorComponent(target: Extract<Expr, { kind: "Member" }>, op: string, valueExpr: Expr): void {
+		const vecType = prune(target.object.ty ?? 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 as { component: string }).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. */
+	private place(e: Expr): string {
+		switch (e.kind) {
+			case "Name":
+				return e.res?.kind === "local" ? this.nameOf(e.res.sym as Sym) : 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;
+		}
+	}
+
+	private shared(name: string): string {
+		this.sharedTable = true;
+		return `__clShared${memberAccess(name)}`;
+	}
+
+	private exprStmt(e: Expr): void {
+		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 as 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}`);
+		}
+	}
+
+	private fireSignal(e: Expr, sym: Sym, args: Array<Expr | null>): void {
+		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");
+	}
+
+	private connect(s: Extract<Stmt, { kind: "Connect" }>): void {
+		if (s.target === "cl") {
+			const sym = s.signal.kind === "Name" && s.signal.res?.kind === "signal" ? (s.signal.res.sym as 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})`);
+	}
+
+	private output(s: Extract<Stmt, { kind: "Output" }>): void {
+		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. */
+	private stringy(e: Expr, forceString = false): string {
+		const t = prune(e.ty ?? 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})`;
+	}
+
+	private ifStmt(s: Extract<Stmt, { kind: "If" }>): void {
+		if (s.letName) {
+			const sym = s.letName.sym as Sym | undefined;
+			const name = sym ? this.nameOf(sym) : 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 }, prune(s.cond.ty ?? 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: string[] = [];
+				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");
+	}
+
+	private loopBody(body: Stmt[], frame: Omit<LoopFrame, "kind">): void {
+		this.loops.push({ kind: "loop", ...frame });
+		this.block(() => this.stmts(body));
+		this.loops.pop();
+	}
+
+	private forStmt(s: Extract<Stmt, { kind: "For" }>): void {
+		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`. */
+	private numericFor(s: Extract<Stmt, { kind: "For" }>): { name: string; from: string; to: string; step: string } | null {
+		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 as Sym | undefined;
+		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 as Sym).id !== sym.id) {
+			return null;
+		}
+		if (!isInvariant(cond.right, s.body)) {
+			return null;
+		}
+		let delta: number | null = 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: string;
+		if (cond.op === "<=" || cond.op === ">=") {
+			to = bound.code;
+		} else if (cond.right.kind === "Number") {
+			to = 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) };
+	}
+
+	private forIn(s: Extract<Stmt, { kind: "ForIn" }>): void {
+		const sym = s.name.sym as Sym | undefined;
+		const name = sym ? this.nameOf(sym) : sanitizeIdentifier(s.name.name);
+		const iterable = this.expr(s.iterable);
+		switch (s.iterKind) {
+			case "range": {
+				const to = s.iterable.kind === "Number" ? 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");
+			}
+		}
+	}
+
+	private breakStmt(): void {
+		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");
+	}
+
+	private continueStmt(): void {
+		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");
+	}
+
+	private returnStmt(s: Extract<Stmt, { kind: "Return" }>): void {
+		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");
+	}
+
+	private subject(e: Expr): string {
+		if (e.kind === "Name" && e.res?.kind === "local") {
+			return this.nameOf(e.res.sym as Sym);
+		}
+		const t = this.temp("m");
+		this.line(`local ${t} = ${this.expr(e).code}`);
+		return t;
+	}
+
+	private switchStmt(s: Extract<Stmt, { kind: "Switch" }>): void {
+		const needsWrap = s.cases.some((k) => hasInnerBreak(k.body));
+		const frame: LoopFrame = { kind: "switch", wrapped: needsWrap };
+		const repeatAt = this.lines.length;
+		if (needsWrap) {
+			this.line("repeat");
+			this.indent++;
+		}
+		const subj = this.subject(s.subject);
+		const subjType = prune(s.subject.ty ?? 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: SwitchCase) => 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");
+			}
+		}
+	}
+
+	private equality(left: Code, right: Expr, t: Type): string {
+		const r = this.expr(right);
+		if (isValueTable(t)) {
+			return `${this.use("__cl_eq")}(${left.code}, ${r.code})`;
+		}
+		return `${wrap(left, P.CONCAT)} == ${wrap(r, P.CONCAT)}`;
+	}
+
+	private matchStmt(s: Extract<Stmt, { kind: "Match" }>): void {
+		const subj = this.subject(s.subject);
+		const subjType = prune(s.subject.ty ?? 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");
+		}
+	}
+
+	private armTest(arm: MatchArm, subj: string, subjType: Type): { test: string; bind: () => void } {
+		const pattern = arm.pattern;
+		let test = "true";
+		let bindName: string | null = null;
+		let bindSource: string | null = null;
+		const caseTest = (p: Extract<Pattern, { kind: "Case" }>) => {
+			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 as Sym | undefined;
+				bindName = sym ? this.nameOf(sym) : 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 as Sym | undefined) : 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}` : ""}`);
+				}
+			},
+		};
+	}
+
+	private tryStmt(s: Extract<Stmt, { kind: "Try" }>): void {
+		const frame: LoopFrame = { 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 as Sym | undefined;
+				const name = sym ? this.nameOf(sym) : 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). */
+	private valueOf(e: Expr): Code {
+		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). */
+	private cond(e: Expr): string {
+		return this.truthy(this.expr(e), prune(e.ty ?? T.any));
+	}
+
+	private truthy(c: Code, t: Type): string {
+		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;
+		}
+	}
+
+	private truthyCode(e: Expr): Code {
+		const t = prune(e.ty ?? 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: Expr): Code {
+		switch (e.kind) {
+			case "Number":
+				return { code: luauNumber(e.value), prec: e.value < 0 ? P.UNARY : P.ATOM };
+			case "String":
+				return atom(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 = prune(e.operand.ty ?? 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");
+		}
+	}
+
+	private name(e: Extract<Expr, { kind: "Name" }>): Code {
+		const res = e.res;
+		let code: string;
+		switch (res?.kind) {
+			case "local":
+				code = this.nameOf(res.sym as Sym);
+				break;
+			case "func": {
+				const sym = res.sym as 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 as Sym).typeId ?? "");
+				break;
+			case "enum": {
+				const id = (res.sym as Sym).typeId ?? "";
+				this.enumTablesUsed.add(id);
+				const info = this.file.enumRegistry.get(id);
+				code = info ? info.luauName : 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 = sanitizeIdentifier(e.name);
+				}
+				break;
+			}
+			case "signal":
+				code = this.nameOf(res.sym as 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 = sanitizeIdentifier(e.name);
+		}
+		return atom(code);
+	}
+
+	private member(e: Extract<Expr, { kind: "Member" }>): Code {
+		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(${luauString(res.childName)})${t && t !== "Instance" ? ` :: ${t}` : ""})`);
+				}
+				return atom(`${wrap(obj, P.ATOM)}${memberAccess(e.name)}`);
+			}
+			case "moduleMember":
+				if (res.moduleId === "namespace") {
+					return atom(`${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)}`);
+	}
+
+	private stdValue(module: string, member: string): string {
+		const fn = stdModule(module as "axiom").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`;
+	}
+
+	private scopeAccess(e: Extract<Expr, { kind: "Scope" }>): Code {
+		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}`);
+	}
+
+	private index(e: Extract<Expr, { kind: "Index" }>): Code {
+		const objType = prune(e.object.ty ?? 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}]`);
+		}
+	}
+
+	private plusOne(e: Expr): string {
+		if (e.kind === "Number") {
+			return luauNumber(e.value + 1);
+		}
+		return `${wrap(this.expr(e), P.ADD)} + 1`;
+	}
+
+	private unary(e: Extract<Expr, { kind: "Unary" }>): Code {
+		switch (e.op) {
+			case "-": {
+				if (e.operand.kind === "Number") {
+					return { code: luauNumber(-e.operand.value), prec: P.UNARY };
+				}
+				return { code: `-${wrap(this.expr(e.operand), P.UNARY)}`, prec: P.UNARY };
+			}
+			case "not": {
+				const t = prune(e.operand.ty ?? 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");
+		}
+	}
+
+	private binary(e: Extract<Expr, { kind: "Binary" }>): Code {
+		const lt = prune(e.left.ty ?? T.any);
+		const rt = prune(e.right.ty ?? 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 as 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 ((isValueTable(lt) || 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: Expr) => (prune(x.ty ?? 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");
+		}
+	}
+
+	private concatPart(e: Expr): Code {
+		const t = prune(e.ty ?? 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})`);
+	}
+
+	private template(e: Extract<Expr, { kind: "Template" }>): Code {
+		if (e.parts.every((p) => typeof p === "string")) {
+			return atom(luauString((e.parts as string[]).join("")));
+		}
+		let out = "`";
+		for (const part of e.parts) {
+			if (typeof part === "string") {
+				out += interpolationText(part);
+				continue;
+			}
+			const constant = part.res?.kind === "const" ? part.res.value : undefined;
+			if (typeof constant === "string" || typeof constant === "number") {
+				out += interpolationText(String(constant));
+				continue;
+			}
+			const t = prune(part.ty ?? T.any);
+			let code = this.expr(part).code;
+			if (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}\``);
+	}
+
+	private functionExpr(e: Extract<Expr, { kind: "Function" }>): Code {
+		const { list, prologue } = this.paramList(e.params, null);
+		const ret = prune(e.ty ?? 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 (prune(e.body.ty ?? 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`);
+	}
+
+	private spawn(call: Expr): Code {
+		this.use("__cl_task");
+		const t = prune(call.ty ?? 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. */
+	private callRaw(call: Expr): string {
+		if (call.kind === "Call") {
+			const saved = (call as { __raw?: boolean }).__raw;
+			(call as { __raw?: boolean }).__raw = true;
+			const code = this.expr(call).code;
+			(call as { __raw?: boolean }).__raw = saved;
+			return code;
+		}
+		return this.expr(call).code;
+	}
+
+	private await(e: Extract<Expr, { kind: "Await" }>): Code {
+		const t = prune(e.operand.ty ?? 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);
+	}
+
+	private isAsyncCall(e: Expr): boolean {
+		if (e.kind !== "Call") {
+			return false;
+		}
+		const res = e.callee.res;
+		if (res && (res.kind === "func" || res.kind === "local")) {
+			return Boolean((res.sym as Sym).decl?.isAsync);
+		}
+		if (res && res.kind === "method") {
+			return Boolean(this.file.structRegistry.get(res.struct)?.methods.get(res.name)?.decl.isAsync);
+		}
+		return false;
+	}
+
+	private move(e: Extract<Expr, { kind: "Move" }>): Code {
+		const src = this.place(e.operand);
+		const tmp = this.temp("moved");
+		this.line(`local ${tmp} = ${src}`);
+		const t = prune(e.operand.ty ?? T.any);
+		this.line(`${src} = ${t.k === "string" ? '""' : t.k === "list" || t.k === "dict" ? "{}" : "nil"}`);
+		return atom(tmp);
+	}
+
+	private updateExpr(e: Extract<Expr, { kind: "Update" }>): Code {
+		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 ----------
+
+	private args(args: Array<Expr | null>, rest?: Expr[]): string {
+		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(", ");
+	}
+
+	private call(e: Expr): Code {
+		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(${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 as Sym, args);
+				return atom("nil");
+			case "classArg": {
+				const callee = (e as Extract<Expr, { kind: "Call" }>).callee as Extract<Expr, { kind: "Member" }>;
+				const obj = this.expr(callee.object);
+				const rest = this.args(args, res.variadicArgs);
+				const code = `${wrap(obj, P.ATOM)}:${callee.name}(${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 as Extract<Expr, { kind: "Call" }>, 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 as Extract<Expr, { kind: "Call" }>).callee as Extract<Expr, { kind: "Member" }>;
+				return atom(`${wrap(this.expr(callee.object), P.ATOM)}:${call.name}(${this.args(args, res.variadicArgs)})`);
+			}
+			case "observe": {
+				const sym = call.sym as 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 as Extract<Expr, { kind: "Call" }>;
+				const code = this.plainCall(ce, args, res.variadicArgs);
+				if (this.isAsyncCall(ce) && !(ce as { __raw?: boolean }).__raw) {
+					this.use("__cl_task");
+					return atom(`__cl_spawn(function() return ${code} end)`);
+				}
+				return atom(code);
+			}
+		}
+	}
+
+	private plainCall(e: Extract<Expr, { kind: "Call" }>, args: Array<Expr | null>, rest?: Expr[]): string {
+		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})`;
+	}
+
+	private convert(to: "int" | "float" | "string" | "bool", arg: Expr | null): Code {
+		if (!arg) {
+			return atom("nil");
+		}
+		const t = prune(arg.ty ?? 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;
+		}
+	}
+
+	private builtin(name: string, args: Array<Expr | null>, elemType?: Type): Code {
+		const a = (i: number) => (args[i] ? this.expr(args[i]!) : atom("nil"));
+		const v = (i: number) => (args[i] ? this.valueOf(args[i]!) : atom("nil"));
+		switch (name) {
+			case "len": {
+				const t = prune(args[0]?.ty ?? 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: string[] = [];
+				for (let i = 0; i + 1 < args.length; i += 2) {
+					const k = args[i]!;
+					const key = k.kind === "String" && 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 = prune(args[0]?.ty ?? 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 && 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");
+		}
+	}
+
+	private stdCall(module: string, member: string, args: Array<Expr | null>): Code {
+		const fn = stdModule(module as "axiom").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(", ")})`);
+	}
+
+	private std(template: string, args: string[], codes?: Code[]): string {
+		return template.replace(/[$@](\d)/g, (_m, n: string) => {
+			const i = Number(n) - 1;
+			const code = codes?.[i];
+			if (code && code.prec < P.ATOM) {
+				return `(${code.code})`;
+			}
+			return args[i] ?? "nil";
+		});
+	}
+}
+
+// ---------- helpers ----------
+
+/** Luau infers the type of calls and member reads on its own; annotations there are noise. */
+function isInferredByLuau(e: Expr): boolean {
+	return e.kind === "Call" || e.kind === "Member" || e.kind === "Index" || e.kind === "Await";
+}
+
+function wrap(c: Code, min: number): string {
+	return c.prec < min ? `(${c.code})` : c.code;
+}
+
+function wrapCode(code: string, min: number): string {
+	return /^[\w.:"()[\]]+$/.test(code) || min <= P.ADD ? code : `(${code})`;
+}
+
+function parenIfLow(code: string): string {
+	return /\s(and|or)\s/.test(code) ? `(${code})` : code;
+}
+
+function optionalType(t: string): string {
+	if (t.endsWith("?") || t === "any") {
+		return t;
+	}
+	return /->|\|/.test(t) ? `(${t})?` : `${t}?`;
+}
+
+function safeName(name: string): string {
+	const s = sanitizeIdentifier(name);
+	return LUAU_KEYWORDS.has(s) ? `${s}_` : s;
+}
+
+function fieldKey(name: string): string {
+	return isIdentifier(name) ? name : `[${luauString(name)}]`;
+}
+
+function memberAccess(name: string): string {
+	return isIdentifier(name) ? `.${name}` : `[${luauString(name)}]`;
+}
+
+function literal(value: number | string | boolean | null): string {
+	if (value === null) {
+		return "nil";
+	}
+	if (typeof value === "string") {
+		return luauString(value);
+	}
+	if (typeof value === "number") {
+		return luauNumber(value);
+	}
+	return value ? "true" : "false";
+}
+
+function literalCode(value: number | string | boolean | null): Code {
+	return { code: literal(value), prec: typeof value === "number" && value < 0 ? P.UNARY : P.ATOM };
+}
+
+function inlinePrec(template: string): number {
+	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: string): boolean {
+	return /\)$/.test(code.trim()) && !/^\(/.test(code.trim()) && !/^if /.test(code.trim());
+}
+
+function isSimple(e: Expr): boolean {
+	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: Type): boolean {
+	const p = prune(t);
+	return p.k === "int";
+}
+
+function isIntPair(a: Type, b: Type): boolean {
+	const isInt = (t: Type) => t.k === "int" || (t.k === "lit" && typeof t.value === "number" && Number.isInteger(t.value));
+	return isInt(a) && isInt(b);
+}
+
+function isSym(e: Expr, sym: Sym): boolean {
+	return e.kind === "Name" && e.res?.kind === "local" && (e.res.sym as Sym).id === sym.id;
+}
+
+function assigns(body: Stmt[], sym: Sym): boolean {
+	let found = false;
+	const visit = (n: unknown) => {
+		if (found || !n || typeof n !== "object") {
+			return;
+		}
+		if (Array.isArray(n)) {
+			n.forEach(visit);
+			return;
+		}
+		const rec = n as { kind?: string; target?: Expr };
+		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: Expr, body: Stmt[]): boolean {
+	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 as 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: Stmt[]): Stmt[] {
+	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: Stmt[]): boolean {
+	const trimmed = trimTrailingBreak(body);
+	let found = false;
+	const visit = (s: Stmt) => {
+		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: Stmt, fn: (s: Stmt, depth: number) => void, depth: number): void {
+	fn(s, depth);
+	const inner = (list: Stmt[] | null | undefined, 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: string[]): string[] {
+	const out: string[] = [];
+	for (const l of lines) {
+		if (l.trim() === "" && (out.length === 0 || out[out.length - 1].trim() === "")) {
+			continue;
+		}
+		out.push(l);
+	}
+	return out;
+}
+
+export function emitLuau(program: Program, file: FileInfo, api: RobloxApi, options: EmitOptions): string {
+	return new LuauEmitter(program, file, api, options).emit();
+}
+
+export type { Arg, EnumInfo, isDynamic };