edict-lang 1.2.0 → 1.5.0

package/dist/codegen/codegen.js

@@ -6,33 +6,16 @@
 // let bindings, blocks, and the `print` builtin.
 import binaryen from "binaryen";
 import { StringTable } from "./string-table.js";
-import { BUILTIN_FUNCTIONS } from "./builtins.js";
-// =============================================================================
-// Edict → WASM type mapping
-// =============================================================================
-function edictTypeToWasm(type) {
-    if (type.kind === "basic") {
-        switch (type.name) {
-            case "Int":
-                return binaryen.i32;
-            case "Float":
-                return binaryen.f64;
-            case "Bool":
-                return binaryen.i32;
-            case "String":
-                // Strings are (ptr, len) → we use i32 for the pointer.
-                // The full string is represented as two i32s, but at the ABI
-                // level we pass two separate i32 params. For return values
-                // of builtin print, we return just the ptr (i32).
-                return binaryen.i32;
-        }
-    }
-    if (type.kind === "unit_type") {
-        return binaryen.none;
-    }
-    // Fallback for anything else
-    return binaryen.i32;
-}
+import { BUILTIN_FUNCTIONS } from "../builtins/builtins.js";
+import { wasmValidationError } from "../errors/structured-errors.js";
+import { collectStrings } from "./collect-strings.js";
+import { generateArrayMap, generateArrayFilter, generateArrayReduce, generateArrayFind, generateArraySort } from "./hof-generators.js";
+import { FunctionContext, edictTypeToWasm, } from "./types.js";
+import { inferImportSignatures } from "./imports.js";
+import { compileLiteral, compileIdent, compileBinop, compileUnop, compileIf, compileLet, compileBlock } from "./compile-scalars.js";
+import { compileCall, compileLambdaExpr } from "./compile-calls.js";
+import { compileRecordExpr, compileTupleExpr, compileEnumConstructor, compileAccess, compileArrayExpr, compileStringInterp } from "./compile-data.js";
+import { compileMatch } from "./compile-match.js";
 // =============================================================================
 // Compile-time WASM type inference for expressions
 // =============================================================================
@@ -40,7 +23,7 @@ function edictTypeToWasm(type) {
  * Infer the WASM type an expression will produce at runtime.
  * Used to dispatch i32 vs f64 instructions in binops, unops, and block types.
  */
-function inferExprWasmType(expr, ctx, fnSigs) {
+export function inferExprWasmType(expr, cc, ctx) {
     switch (expr.kind) {
         case "literal": {
             // If the literal has an explicit type annotation, use it
@@ -55,7 +38,7 @@ function inferExprWasmType(expr, ctx, fnSigs) {
             const local = ctx.getLocal(expr.name);
             if (local)
                 return local.type;
-            const globalType = ctx.constGlobals.get(expr.name);
+            const globalType = cc.constGlobals.get(expr.name);
             if (globalType)
                 return globalType;
             return binaryen.i32;
@@ -66,15 +49,15 @@ function inferExprWasmType(expr, ctx, fnSigs) {
             if (cmpOps.includes(expr.op))
                 return binaryen.i32;
             // Arithmetic: infer from left operand
-            return inferExprWasmType(expr.left, ctx, fnSigs);
+            return inferExprWasmType(expr.left, cc, ctx);
         }
         case "unop":
             if (expr.op === "not")
                 return binaryen.i32;
-            return inferExprWasmType(expr.operand, ctx, fnSigs);
+            return inferExprWasmType(expr.operand, cc, ctx);
         case "call": {
             if (expr.fn.kind === "ident") {
-                const sig = fnSigs.get(expr.fn.name);
+                const sig = cc.fnSigs.get(expr.fn.name);
                 if (sig)
                     return sig.returnType;
             }
@@ -83,21 +66,21 @@ function inferExprWasmType(expr, ctx, fnSigs) {
         case "if":
             // Type of if is the type of the then branch's last expression
             if (expr.then.length > 0) {
-                return inferExprWasmType(expr.then[expr.then.length - 1], ctx, fnSigs);
+                return inferExprWasmType(expr.then[expr.then.length - 1], cc, ctx);
             }
             return binaryen.i32;
         case "let":
             return binaryen.none; // let is a statement (local.set), returns void
         case "block":
             if (expr.body.length > 0) {
-                return inferExprWasmType(expr.body[expr.body.length - 1], ctx, fnSigs);
+                return inferExprWasmType(expr.body[expr.body.length - 1], cc, ctx);
             }
             return binaryen.none;
         case "match":
             // Type of match is the type of the first arm's body
             if (expr.arms.length > 0 && expr.arms[0].body.length > 0) {
                 const firstBody = expr.arms[0].body;
-                return inferExprWasmType(firstBody[firstBody.length - 1], ctx, fnSigs);
+                return inferExprWasmType(firstBody[firstBody.length - 1], cc, ctx);
             }
             return binaryen.i32;
         case "array":
@@ -119,7 +102,7 @@ function inferExprWasmType(expr, ctx, fnSigs) {
                 recordTypeName = expr.target.name;
             }
             if (recordTypeName) {
-                const layout = ctx.recordLayouts.get(recordTypeName);
+                const layout = cc.recordLayouts.get(recordTypeName);
                 if (layout) {
                     const fieldLayout = layout.fields.find((f) => f.name === expr.field);
                     if (fieldLayout)
@@ -132,40 +115,14 @@ function inferExprWasmType(expr, ctx, fnSigs) {
             return binaryen.i32;
     }
 }
-class FunctionContext {
-    nextIndex;
-    locals = new Map();
-    varTypes = [];
-    constGlobals;
-    recordLayouts;
-    enumLayouts;
-    constructor(params, constGlobals = new Map(), recordLayouts = new Map(), enumLayouts = new Map()) {
-        this.nextIndex = 0;
-        this.constGlobals = constGlobals;
-        this.recordLayouts = recordLayouts;
-        this.enumLayouts = enumLayouts;
-        for (const p of params) {
-            this.locals.set(p.name, { index: this.nextIndex, type: p.wasmType, edictTypeName: p.edictTypeName });
-            this.nextIndex++;
-        }
-    }
-    getLocal(name) {
-        return this.locals.get(name);
-    }
-    addLocal(name, type, edictTypeName) {
-        const index = this.nextIndex++;
-        this.locals.set(name, { index, type, edictTypeName });
-        this.varTypes.push(type);
-        return index;
-    }
-}
 // =============================================================================
 // Compiler
 // =============================================================================
-export function compile(module) {
+export function compile(module, options) {
     const mod = new binaryen.Module();
     const strings = new StringTable();
     const errors = [];
+    const maxPages = options?.maxMemoryPages ?? 16;
     try {
         // Pre-scan: intern all string literals
         for (const def of module.definitions) {
@@ -173,13 +130,13 @@ export function compile(module) {
                 collectStrings(def.body, strings);
             }
             if (def.kind === "const") {
-                collectStringExpr(def.value, strings);
+                collectStrings([def.value], strings);
             }
         }
         // Setup memory with string data segments
         const segments = strings.toMemorySegments(mod);
         const pages = Math.max(1, Math.ceil(strings.totalBytes / 65536));
-        mod.setMemory(pages, 16, "memory", segments);
+        mod.setMemory(pages, maxPages, "memory", segments);
         // Build RecordLayout registry
         const recordLayouts = new Map();
         const enumLayouts = new Map();
@@ -209,6 +166,26 @@ export function compile(module) {
                 enumLayouts.set(def.name, { variants });
             }
         }
+        // Register built-in Option enum layout: None (tag 0), Some(value) (tag 1)
+        // Guard lets user-defined Option enums override the built-in.
+        if (!enumLayouts.has("Option")) {
+            enumLayouts.set("Option", {
+                variants: [
+                    { name: "None", tag: 0, fields: [], totalSize: 8 },
+                    { name: "Some", tag: 1, fields: [{ name: "value", offset: 8, wasmType: binaryen.i32 }], totalSize: 16 },
+                ],
+            });
+        }
+        // Register built-in Result enum layout: Ok (tag 0), Err (tag 1)
+        // Guard lets user-defined Result enums override the built-in.
+        if (!enumLayouts.has("Result")) {
+            enumLayouts.set("Result", {
+                variants: [
+                    { name: "Ok", tag: 0, fields: [{ name: "value", offset: 8, wasmType: binaryen.i32 }], totalSize: 16 },
+                    { name: "Err", tag: 1, fields: [{ name: "error", offset: 8, wasmType: binaryen.i32 }], totalSize: 16 },
+                ],
+            });
+        }
         // Initialize bump allocator heap pointer
         // Ensure heap starts at an 8-byte aligned offset after the string table, min 8
         const heapStart = Math.max(8, Math.ceil(strings.totalBytes / 8) * 8);
@@ -227,16 +204,45 @@ export function compile(module) {
         }
         for (const def of module.definitions) {
             if (def.kind === "fn") {
+                // Closure convention: all user functions have __env:i32 as first WASM param
+                // String params are expanded to (ptr: i32, len: i32) pairs at the WASM level
+                const edictParamTypes = ["other"]; // __env
+                const wasmParamTypes = [binaryen.i32]; // __env
+                for (const p of def.params) {
+                    if (p.type.kind === "basic" && p.type.name === "String") {
+                        wasmParamTypes.push(binaryen.i32, binaryen.i32); // ptr, len
+                        edictParamTypes.push("String");
+                    }
+                    else {
+                        wasmParamTypes.push(edictTypeToWasm(p.type));
+                        edictParamTypes.push("other");
+                    }
+                }
                 fnSigs.set(def.name, {
-                    returnType: edictTypeToWasm(def.returnType),
-                    paramTypes: def.params.map((p) => edictTypeToWasm(p.type)),
+                    returnType: def.returnType ? edictTypeToWasm(def.returnType) : binaryen.i32,
+                    paramTypes: wasmParamTypes,
+                    edictParamTypes,
                 });
             }
         }
+        // HOF support: function table for indirect calls (call_indirect)
+        // Pre-assign table indices to user-defined functions.
+        // Lambdas will be appended during compilation.
+        const tableFunctions = [];
+        const fnTableIndices = new Map();
+        for (const def of module.definitions) {
+            if (def.kind === "fn") {
+                fnTableIndices.set(def.name, tableFunctions.length);
+                tableFunctions.push(def.name);
+            }
+        }
         // Import builtins — compute WASM-level params from Edict signatures
         // Each String param becomes two i32 values (ptr, len) at the WASM level
         for (const [name, builtin] of BUILTIN_FUNCTIONS) {
             const [importModule, importBase] = builtin.wasmImport;
+            // WASM-native builtins (HOFs) are generated as internal functions, not imported
+            if (importModule === "__wasm")
+                continue;
             const wasmParams = [];
             for (const param of builtin.type.params) {
                 if (param.kind === "basic" && param.name === "String") {
@@ -274,12 +280,18 @@ export function compile(module) {
         }
         // Compile const definitions as WASM globals
         const constGlobals = new Map();
+        // Create the compilation context — bundles compile-wide state
+        const cc = {
+            mod, strings, fnSigs, errors,
+            constGlobals, recordLayouts, enumLayouts, fnTableIndices, tableFunctions,
+            lambdaCounter: 0,
+        };
         for (const def of module.definitions) {
             if (def.kind === "const") {
                 const wasmType = edictTypeToWasm(def.type);
                 // Create a temporary context for compiling the const init expression
                 const tmpCtx = new FunctionContext([]);
-                const initExpr = compileExpr(def.value, mod, tmpCtx, strings, fnSigs, errors);
+                const initExpr = compileExpr(def.value, cc, tmpCtx);
                 mod.addGlobal(def.name, wasmType, false, initExpr);
                 constGlobals.set(def.name, wasmType);
             }
@@ -287,9 +299,27 @@ export function compile(module) {
         // Compile each function
         for (const def of module.definitions) {
             if (def.kind === "fn") {
-                compileFunction(def, mod, strings, fnSigs, constGlobals, recordLayouts, enumLayouts, errors);
+                compileFunction(def, cc);
             }
         }
+        // =====================================================================
+        // Generate WASM-native HOF array builtins
+        // These need call_indirect to invoke closure arguments, so they
+        // must be generated as internal WASM functions (not host imports).
+        // Array layout in memory: [length:i32][elem0:i32][elem1:i32]...
+        // Closure pair layout: [table_index:i32][env_ptr:i32]
+        // =====================================================================
+        generateArrayMap(mod);
+        generateArrayFilter(mod);
+        generateArrayReduce(mod);
+        generateArrayFind(mod);
+        generateArraySort(mod);
+        // Build function table for indirect calls (call_indirect)
+        // This must happen after all functions (including lambdas) are compiled
+        if (tableFunctions.length > 0) {
+            mod.addTable("__fn_table", tableFunctions.length, tableFunctions.length);
+            mod.addActiveElementSegment("__fn_table", "__fn_elems", tableFunctions, mod.i32.const(0));
+        }
         // Export the "main" function if it exists
         const mainDef = module.definitions.find((d) => d.kind === "fn" && d.name === "main");
         if (mainDef) {
@@ -308,18 +338,21 @@ export function compile(module) {
         mod.addFunctionExport("__set_str_ret_len", "__set_str_ret_len");
         // Memory is already exported via setMemory's exportName parameter
         // Validate
+        if (errors.length > 0) {
+            return { ok: false, errors };
+        }
         if (!mod.validate()) {
-            errors.push("binaryen validation failed");
+            errors.push(wasmValidationError("binaryen validation failed"));
             return { ok: false, errors };
         }
         // Optimize
         mod.optimize();
-        const wat = mod.emitText();
+        const wat = options?.emitWat ? mod.emitText() : undefined;
         const wasm = mod.emitBinary();
-        return { ok: true, wasm, wat };
+        return { ok: true, wasm, ...(wat ? { wat } : {}) };
     }
     catch (e) {
-        errors.push(e instanceof Error ? e.message : String(e));
+        errors.push(wasmValidationError(e instanceof Error ? e.message : String(e)));
         return { ok: false, errors };
     }
     finally {
@@ -329,22 +362,44 @@ export function compile(module) {
 // =============================================================================
 // Function compilation
 // =============================================================================
-function compileFunction(fn, mod, strings, fnSigs, constGlobals, recordLayouts, enumLayouts, errors) {
+function compileFunction(fn, cc) {
+    const { mod } = cc;
     const params = fn.params.map((p) => ({
         name: p.name,
         edictType: p.type,
         wasmType: edictTypeToWasm(p.type),
-        edictTypeName: p.type.kind === "named" ? p.type.name : undefined,
+        edictTypeName: p.type.kind === "named" ? p.type.name : p.type.kind === "option" ? "Option" : p.type.kind === "result" ? "Result" : undefined,
     }));
-    const ctx = new FunctionContext(params.map((p) => ({ name: p.name, wasmType: p.wasmType, edictTypeName: p.edictTypeName })), constGlobals, recordLayouts, enumLayouts);
-    const returnType = edictTypeToWasm(fn.returnType);
-    const paramTypes = params.map((p) => p.wasmType);
+    // Closure convention: all user functions have __env:i32 as first WASM param.
+    // The __env param is ignored for non-lambda functions but ensures uniform
+    // call_indirect signatures when functions are used as values.
+    // String params are widened to (ptr: i32, len: i32) pairs — the companion
+    // __str_len_{name} becomes a real WASM param so existing lookups find it.
+    const allParams = [
+        { name: "__env", wasmType: binaryen.i32, edictTypeName: undefined },
+    ];
+    for (const p of params) {
+        if (p.edictType.kind === "basic" && p.edictType.name === "String") {
+            allParams.push({ name: p.name, wasmType: binaryen.i32, edictTypeName: undefined });
+            allParams.push({ name: `__str_len_${p.name}`, wasmType: binaryen.i32, edictTypeName: undefined });
+        }
+        else {
+            allParams.push({ name: p.name, wasmType: p.wasmType, edictTypeName: p.edictTypeName });
+        }
+    }
+    const ctx = new FunctionContext(allParams);
+    const returnType = fn.returnType
+        ? edictTypeToWasm(fn.returnType)
+        : (fn.body.length > 0
+            ? inferExprWasmType(fn.body[fn.body.length - 1], cc, ctx)
+            : binaryen.i32);
+    const paramTypes = allParams.map((p) => p.wasmType);
     const paramType = paramTypes.length > 0
         ? binaryen.createType(paramTypes)
         : binaryen.none;
     // Compile body — wrap non-final expressions in drop() per WASM semantics
     const bodyExprs = fn.body.map((expr, i) => {
-        const compiled = compileExpr(expr, mod, ctx, strings, fnSigs, errors);
+        const compiled = compileExpr(expr, cc, ctx);
         // Non-final expressions that produce values must be dropped
         if (i < fn.body.length - 1 && expr.kind !== "let") {
             return mod.drop(compiled);
@@ -366,926 +421,43 @@ function compileFunction(fn, mod, strings, fnSigs, constGlobals, recordLayouts,
 // =============================================================================
 // Expression compilation
 // =============================================================================
-function compileExpr(expr, mod, ctx, strings, fnSigs, errors) {
+export function compileExpr(expr, cc, ctx) {
     switch (expr.kind) {
         case "literal":
-            return compileLiteral(expr, mod, strings);
+            return compileLiteral(expr, cc);
         case "ident":
-            return compileIdent(expr, mod, ctx);
+            return compileIdent(expr, cc, ctx);
         case "binop":
-            return compileBinop(expr, mod, ctx, strings, fnSigs, errors);
+            return compileBinop(expr, cc, ctx);
         case "unop":
-            return compileUnop(expr, mod, ctx, strings, fnSigs, errors);
+            return compileUnop(expr, cc, ctx);
         case "call":
-            return compileCall(expr, mod, ctx, strings, fnSigs, errors);
+            return compileCall(expr, cc, ctx);
         case "if":
-            return compileIf(expr, mod, ctx, strings, fnSigs, errors);
+            return compileIf(expr, cc, ctx);
         case "let":
-            return compileLet(expr, mod, ctx, strings, fnSigs, errors);
+            return compileLet(expr, cc, ctx);
         case "block":
-            return compileBlock(expr, mod, ctx, strings, fnSigs, errors);
+            return compileBlock(expr, cc, ctx);
         case "match":
-            return compileMatch(expr, mod, ctx, strings, fnSigs, errors);
+            return compileMatch(expr, cc, ctx);
         case "record_expr":
-            return compileRecordExpr(expr, mod, ctx, strings, fnSigs, errors);
+            return compileRecordExpr(expr, cc, ctx);
         case "tuple_expr":
-            return compileTupleExpr(expr, mod, ctx, strings, fnSigs, errors);
+            return compileTupleExpr(expr, cc, ctx);
         case "enum_constructor":
-            return compileEnumConstructor(expr, mod, ctx, strings, fnSigs, errors);
+            return compileEnumConstructor(expr, cc, ctx);
         case "access":
-            return compileAccess(expr, mod, ctx, strings, fnSigs, errors);
+            return compileAccess(expr, cc, ctx);
         case "array":
-            return compileArrayExpr(expr, mod, ctx, strings, fnSigs, errors);
+            return compileArrayExpr(expr, cc, ctx);
         case "lambda":
-            return compileLambdaExpr(expr, mod, ctx, strings, fnSigs, errors);
+            return compileLambdaExpr(expr, cc, ctx);
         case "string_interp":
-            return compileStringInterp(expr, mod, ctx, strings, fnSigs, errors);
-        default:
-            errors.push(`unsupported expression kind: ${expr.kind}`);
-            return mod.unreachable();
-    }
-}
-function compileLiteral(expr, mod, strings) {
-    const val = expr.value;
-    if (typeof val === "boolean") {
-        return mod.i32.const(val ? 1 : 0);
-    }
-    if (typeof val === "number") {
-        // Check type annotation first — 0.0 is integer in JS but Float in Edict
-        if (expr.type && expr.type.kind === "basic" && expr.type.name === "Float") {
-            return mod.f64.const(val);
-        }
-        if (Number.isInteger(val)) {
-            return mod.i32.const(val);
-        }
-        return mod.f64.const(val);
-    }
-    if (typeof val === "string") {
-        const interned = strings.intern(val);
-        // Return the pointer (offset). The caller/callee will also need
-        // the length — for builtin calls we handle this specially in compileCall.
-        return mod.i32.const(interned.offset);
-    }
-    return mod.unreachable();
-}
-function compileIdent(expr, mod, ctx) {
-    const local = ctx.getLocal(expr.name);
-    if (local) {
-        return mod.local.get(local.index, local.type);
-    }
-    // Check module-level const globals
-    const globalType = ctx.constGlobals.get(expr.name);
-    if (globalType !== undefined) {
-        return mod.global.get(expr.name, globalType);
-    }
-    // Could be a function reference — return unreachable for now
-    return mod.unreachable();
-}
-function compileBinop(expr, mod, ctx, strings, fnSigs, errors) {
-    const left = compileExpr(expr.left, mod, ctx, strings, fnSigs, errors);
-    const right = compileExpr(expr.right, mod, ctx, strings, fnSigs, errors);
-    // Determine the WASM type from the left operand.
-    // Type checker guarantees matching types for both operands.
-    const opType = inferExprWasmType(expr.left, ctx, fnSigs);
-    const isFloat = opType === binaryen.f64;
-    switch (expr.op) {
-        case "+":
-            return isFloat ? mod.f64.add(left, right) : mod.i32.add(left, right);
-        case "-":
-            return isFloat ? mod.f64.sub(left, right) : mod.i32.sub(left, right);
-        case "*":
-            return isFloat ? mod.f64.mul(left, right) : mod.i32.mul(left, right);
-        case "/":
-            return isFloat ? mod.f64.div(left, right) : mod.i32.div_s(left, right);
-        case "%":
-            if (isFloat) {
-                errors.push(`modulo (%) not supported for Float`);
-                return mod.unreachable();
-            }
-            return mod.i32.rem_s(left, right);
-        case "==":
-            return isFloat ? mod.f64.eq(left, right) : mod.i32.eq(left, right);
-        case "!=":
-            return isFloat ? mod.f64.ne(left, right) : mod.i32.ne(left, right);
-        case "<":
-            return isFloat ? mod.f64.lt(left, right) : mod.i32.lt_s(left, right);
-        case ">":
-            return isFloat ? mod.f64.gt(left, right) : mod.i32.gt_s(left, right);
-        case "<=":
-            return isFloat ? mod.f64.le(left, right) : mod.i32.le_s(left, right);
-        case ">=":
-            return isFloat ? mod.f64.ge(left, right) : mod.i32.ge_s(left, right);
-        case "and":
-            return mod.i32.and(left, right);
-        case "or":
-            return mod.i32.or(left, right);
-        case "implies":
-            // A implies B ≡ (not A) or B
-            return mod.i32.or(mod.i32.eqz(left), right);
-        default:
-            errors.push(`unsupported binop: ${expr.op}`);
-            return mod.unreachable();
-    }
-}
-function compileUnop(expr, mod, ctx, strings, fnSigs, errors) {
-    const operand = compileExpr(expr.operand, mod, ctx, strings, fnSigs, errors);
-    const opType = inferExprWasmType(expr.operand, ctx, fnSigs);
-    const isFloat = opType === binaryen.f64;
-    switch (expr.op) {
-        case "-":
-            return isFloat
-                ? mod.f64.neg(operand)
-                : mod.i32.sub(mod.i32.const(0), operand);
-        case "not":
-            return mod.i32.eqz(operand);
+            return compileStringInterp(expr, cc, ctx);
         default:
-            errors.push(`unsupported unop: ${expr.op}`);
-            return mod.unreachable();
-    }
-}
-function compileCall(expr, mod, ctx, strings, fnSigs, errors) {
-    // The fn expression should be an ident for direct calls
-    if (expr.fn.kind !== "ident") {
-        errors.push("indirect calls not yet supported");
-        return mod.unreachable();
-    }
-    const fnName = expr.fn.name;
-    const builtin = BUILTIN_FUNCTIONS.get(fnName);
-    // Special handling for builtins that take String params:
-    // Strings are (ptr, len) pairs at the WASM level, so String args must
-    // be expanded. Check whether this builtin has any String params.
-    if (builtin) {
-        const hasStringParam = builtin.type.params.some(p => p.kind === "basic" && p.name === "String");
-        if (hasStringParam) {
-            const wasmArgs = [];
-            for (let i = 0; i < expr.args.length; i++) {
-                const arg = expr.args[i];
-                const paramType = builtin.type.params[i];
-                const isStringParam = paramType?.kind === "basic" && paramType.name === "String";
-                if (isStringParam) {
-                    if (arg.kind === "literal" && typeof arg.value === "string") {
-                        // String literal — ptr and len known at compile time
-                        const interned = strings.intern(arg.value);
-                        wasmArgs.push(mod.i32.const(interned.offset));
-                        wasmArgs.push(mod.i32.const(interned.length));
-                    }
-                    else {
-                        // Non-literal string arg — compile to get ptr,
-                        // read __str_ret_len for the length
-                        const ptrExpr = compileExpr(arg, mod, ctx, strings, fnSigs, errors);
-                        wasmArgs.push(ptrExpr);
-                        wasmArgs.push(mod.global.get("__str_ret_len", binaryen.i32));
-                    }
-                }
-                else {
-                    // Non-string param — compile normally
-                    wasmArgs.push(compileExpr(arg, mod, ctx, strings, fnSigs, errors));
-                }
-            }
-            const sig = fnSigs.get(fnName);
-            const returnType = sig ? sig.returnType : binaryen.i32;
-            return mod.call(fnName, wasmArgs, returnType);
-        }
-    }
-    // Generic function call
-    const args = expr.args.map((a, i) => {
-        const compiled = compileExpr(a, mod, ctx, strings, fnSigs, errors);
-        // Coerce i32→f64 if function expects f64 but arg infers to i32
-        const sig = fnSigs.get(fnName);
-        if (sig?.paramTypes && sig.paramTypes[i] === binaryen.f64) {
-            const argType = inferExprWasmType(a, ctx, fnSigs);
-            if (argType === binaryen.i32) {
-                return mod.f64.convert_s.i32(compiled);
-            }
-        }
-        return compiled;
-    });
-    // Look up signature for correct return type
-    const sig = fnSigs.get(fnName);
-    const returnType = sig ? sig.returnType : binaryen.i32;
-    return mod.call(fnName, args, returnType);
-}
-function compileIf(expr, mod, ctx, strings, fnSigs, errors) {
-    const cond = compileExpr(expr.condition, mod, ctx, strings, fnSigs, errors);
-    // Infer the result type from the then-branch's last expression
-    const resultType = expr.then.length > 0
-        ? inferExprWasmType(expr.then[expr.then.length - 1], ctx, fnSigs)
-        : binaryen.i32;
-    const thenExprs = expr.then.map((e) => compileExpr(e, mod, ctx, strings, fnSigs, errors));
-    const thenBody = thenExprs.length === 1
-        ? thenExprs[0]
-        : mod.block(null, thenExprs, resultType);
-    if (expr.else) {
-        const elseExprs = expr.else.map((e) => compileExpr(e, mod, ctx, strings, fnSigs, errors));
-        const elseBody = elseExprs.length === 1
-            ? elseExprs[0]
-            : mod.block(null, elseExprs, resultType);
-        return mod.if(cond, thenBody, elseBody);
-    }
-    return mod.if(cond, thenBody);
-}
-function compileLet(expr, mod, ctx, strings, fnSigs, errors) {
-    const wasmType = expr.type
-        ? edictTypeToWasm(expr.type)
-        : inferExprWasmType(expr.value, ctx, fnSigs);
-    let edictTypeName;
-    if (expr.type && expr.type.kind === "named") {
-        edictTypeName = expr.type.name;
-    }
-    else if (expr.value.kind === "record_expr") {
-        edictTypeName = expr.value.name;
-    }
-    else if (expr.value.kind === "enum_constructor") {
-        edictTypeName = expr.value.enumName;
-    }
-    const index = ctx.addLocal(expr.name, wasmType, edictTypeName);
-    const value = compileExpr(expr.value, mod, ctx, strings, fnSigs, errors);
-    const localSet = mod.local.set(index, value);
-    // For String-type let bindings from literals, also set __str_ret_len
-    // so downstream string builtins can read the correct length.
-    // For calls to string-returning builtins, __str_ret_len is already set by the host.
-    const isStringType = expr.type?.kind === "basic" && expr.type.name === "String";
-    if (isStringType && expr.value.kind === "literal" && typeof expr.value.value === "string") {
-        const interned = strings.intern(expr.value.value);
-        return mod.block(null, [
-            localSet,
-            mod.global.set("__str_ret_len", mod.i32.const(interned.length)),
-        ], binaryen.none);
-    }
-    return localSet;
-}
-function compileBlock(expr, mod, ctx, strings, fnSigs, errors) {
-    const bodyExprs = expr.body.map((e) => compileExpr(e, mod, ctx, strings, fnSigs, errors));
-    if (bodyExprs.length === 0)
-        return mod.nop();
-    if (bodyExprs.length === 1)
-        return bodyExprs[0];
-    const blockType = inferExprWasmType(expr.body[expr.body.length - 1], ctx, fnSigs);
-    return mod.block(null, bodyExprs, blockType);
-}
-function compileMatch(expr, mod, ctx, strings, fnSigs, errors) {
-    // Attempt to determine the Edict type name of the target for enum matching
-    let targetEdictTypeName;
-    if (expr.target.kind === "ident") {
-        const local = ctx.getLocal(expr.target.name);
-        targetEdictTypeName = local?.edictTypeName;
-    }
-    else if (expr.target.kind === "call") {
-        // Can't easily infer return named type yet without a type env here,
-        // but let's be pragmatic if it's annotated
-    }
-    else if ("type" in expr.target && expr.target.type && expr.target.type.kind === "named") {
-        targetEdictTypeName = expr.target.type.name;
-    }
-    // Infer the target and result types
-    const targetType = inferExprWasmType(expr.target, ctx, fnSigs);
-    const matchResultType = inferExprWasmType(expr, ctx, fnSigs);
-    // Evaluate target once and store in a temporary local
-    const targetExpr = compileExpr(expr.target, mod, ctx, strings, fnSigs, errors);
-    const tmpIndex = ctx.addLocal(`__match_${expr.id}`, targetType);
-    const setTarget = mod.local.set(tmpIndex, targetExpr);
-    const getTarget = () => mod.local.get(tmpIndex, targetType);
-    // Compile body of a match arm (list of expressions → single expression)
-    function compileArmBody(body) {
-        const compiled = body.map((e) => compileExpr(e, mod, ctx, strings, fnSigs, errors));
-        if (compiled.length === 0)
-            return mod.nop();
-        if (compiled.length === 1)
-            return compiled[0];
-        const bodyType = body.length > 0
-            ? inferExprWasmType(body[body.length - 1], ctx, fnSigs)
-            : binaryen.i32;
-        return mod.block(null, compiled, bodyType);
-    }
-    // Build condition for a pattern match against the target
-    function compilePatternCondition(pattern) {
-        switch (pattern.kind) {
-            case "literal_pattern": {
-                const val = pattern.value;
-                if (typeof val === "number" && Number.isInteger(val)) {
-                    return mod.i32.eq(getTarget(), mod.i32.const(val));
-                }
-                if (typeof val === "boolean") {
-                    return mod.i32.eq(getTarget(), mod.i32.const(val ? 1 : 0));
-                }
-                // String/float literal patterns — compare i32 representation
-                if (typeof val === "number") {
-                    // Float literal pattern — not yet supported in i32 mode
-                    errors.push(`float literal patterns not yet supported in match`);
-                    return null;
-                }
-                if (typeof val === "string") {
-                    const interned = strings.intern(val);
-                    return mod.i32.eq(getTarget(), mod.i32.const(interned.offset));
-                }
-                return null;
-            }
-            case "wildcard":
-                return null; // always matches
-            case "binding":
-                return null; // always matches (binding is set up in compileArmWithBinding)
-            case "constructor": {
-                // Determine the tag value from the enum layout
-                let tagValue = -1;
-                if (targetEdictTypeName) {
-                    const enumLayout = ctx.enumLayouts.get(targetEdictTypeName);
-                    if (enumLayout) {
-                        const variantLayout = enumLayout.variants.find(v => v.name === pattern.name);
-                        if (variantLayout) {
-                            tagValue = variantLayout.tag;
-                        }
-                        else {
-                            errors.push(`unknown variant ${pattern.name} for enum ${targetEdictTypeName}`);
-                            return null;
-                        }
-                    }
-                    else {
-                        errors.push(`unknown enum ${targetEdictTypeName}`);
-                        return null;
-                    }
-                }
-                else {
-                    errors.push(`cannot infer enum type for match target ${expr.id}`);
-                    return null;
-                }
-                if (tagValue === -1)
-                    return null;
-                // Load tag at offset 0 from the heap pointer (target)
-                const loadTag = mod.i32.load(0, 0, getTarget());
-                return mod.i32.eq(loadTag, mod.i32.const(tagValue));
-            }
-        }
-    }
-    // Pre-register binding locals so they're available during body compilation.
-    // We must do this before compiling arm bodies, otherwise ident lookups
-    // for bound names will fail.
-    const bindingLocals = new Map(); // arm index → local index
-    const constructorFieldBindings = new Map();
-    for (let i = 0; i < expr.arms.length; i++) {
-        const pattern = expr.arms[i].pattern;
-        if (pattern.kind === "binding") {
-            const bindIndex = ctx.addLocal(pattern.name, targetType);
-            bindingLocals.set(i, bindIndex);
-        }
-        else if (pattern.kind === "constructor") {
-            if (targetEdictTypeName) {
-                const enumLayout = ctx.enumLayouts.get(targetEdictTypeName);
-                if (enumLayout) {
-                    const variantLayout = enumLayout.variants.find(v => v.name === pattern.name);
-                    if (variantLayout) {
-                        const fieldBindings = [];
-                        for (let j = 0; j < pattern.fields.length; j++) {
-                            const subPattern = pattern.fields[j];
-                            if (subPattern.kind === "binding") {
-                                const fieldLayout = variantLayout.fields[j];
-                                if (fieldLayout) {
-                                    const bindIndex = ctx.addLocal(subPattern.name, fieldLayout.wasmType);
-                                    fieldBindings.push({
-                                        localIndex: bindIndex,
-                                        offset: fieldLayout.offset,
-                                        wasmType: fieldLayout.wasmType
-                                    });
-                                }
-                            }
-                            else if (subPattern.kind !== "wildcard") {
-                                errors.push(`nested patterns inside constructor patterns not yet supported`);
-                            }
-                        }
-                        constructorFieldBindings.set(i, fieldBindings);
-                    }
-                }
-            }
-        }
-    }
-    // Build nested if/else chain from arms (right to left)
-    // Start from the last arm and work backwards
-    let result = mod.unreachable();
-    for (let i = expr.arms.length - 1; i >= 0; i--) {
-        const arm = expr.arms[i];
-        const bodyExpr = compileArmBody(arm.body);
-        // Wrap with binding set if this is a binding pattern
-        let armExpr = bodyExpr;
-        const bindIndex = bindingLocals.get(i);
-        if (bindIndex !== undefined) {
-            const setBinding = mod.local.set(bindIndex, getTarget());
-            armExpr = mod.block(null, [setBinding, bodyExpr], matchResultType);
-        }
-        else if (arm.pattern.kind === "constructor") {
-            const fieldBindings = constructorFieldBindings.get(i);
-            if (fieldBindings && fieldBindings.length > 0) {
-                const sets = [];
-                for (const binding of fieldBindings) {
-                    const loadField = binding.wasmType === binaryen.f64
-                        ? mod.f64.load(binding.offset, 0, getTarget())
-                        : mod.i32.load(binding.offset, 0, getTarget());
-                    sets.push(mod.local.set(binding.localIndex, loadField));
-                }
-                armExpr = mod.block(null, [...sets, bodyExpr], matchResultType);
-            }
-        }
-        const condition = compilePatternCondition(arm.pattern);
-        if (condition === null) {
-            // Wildcard or binding — this arm always matches
-            // It becomes the else (or the whole result if it's the only/last arm)
-            result = armExpr;
-        }
-        else {
-            // Conditional arm — if condition then this arm else previous result
-            result = mod.if(condition, armExpr, result);
-        }
-    }
-    // Wrap: set target, then evaluate the if/else chain
-    return mod.block(null, [setTarget, result], matchResultType);
-}
-function compileRecordExpr(expr, mod, ctx, strings, fnSigs, errors) {
-    const layout = ctx.recordLayouts.get(expr.name);
-    if (!layout) {
-        errors.push(`unknown record type: ${expr.name}`);
-        return mod.unreachable();
-    }
-    // Allocate heap space
-    // ptr = __heap_ptr
-    // __heap_ptr = ptr + layout.totalSize
-    const ptrIndex = ctx.addLocal(`__record_ptr_${expr.id}`, binaryen.i32);
-    const setPtr = mod.local.set(ptrIndex, mod.global.get("__heap_ptr", binaryen.i32));
-    const incrementHeap = mod.global.set("__heap_ptr", mod.i32.add(mod.local.get(ptrIndex, binaryen.i32), mod.i32.const(layout.totalSize)));
-    // Evaluate and store each field
-    const stores = [];
-    for (const fieldInit of expr.fields) {
-        const fieldLayout = layout.fields.find((f) => f.name === fieldInit.name);
-        if (!fieldLayout) {
-            errors.push(`unknown field '${fieldInit.name}' on record '${expr.name}'`);
-            continue;
-        }
-        const valueExpr = compileExpr(fieldInit.value, mod, ctx, strings, fnSigs, errors);
-        if (fieldLayout.wasmType === binaryen.f64) {
-            stores.push(mod.f64.store(fieldLayout.offset, 0, // align
-            mod.local.get(ptrIndex, binaryen.i32), valueExpr));
-        }
-        else {
-            stores.push(mod.i32.store(fieldLayout.offset, 0, // align
-            mod.local.get(ptrIndex, binaryen.i32), valueExpr));
-        }
-    }
-    // Return the pointer
-    const returnPtr = mod.local.get(ptrIndex, binaryen.i32);
-    return mod.block(null, [setPtr, incrementHeap, ...stores, returnPtr], binaryen.i32);
-}
-function compileTupleExpr(expr, mod, ctx, strings, fnSigs, errors) {
-    const totalSize = expr.elements.length * 8;
-    const ptrIndex = ctx.addLocal(`__tuple_ptr_${expr.id}`, binaryen.i32);
-    const setPtr = mod.local.set(ptrIndex, mod.global.get("__heap_ptr", binaryen.i32));
-    const incrementHeap = mod.global.set("__heap_ptr", mod.i32.add(mod.local.get(ptrIndex, binaryen.i32), mod.i32.const(totalSize)));
-    const stores = [];
-    for (let i = 0; i < expr.elements.length; i++) {
-        const elExpr = expr.elements[i];
-        const valWasm = compileExpr(elExpr, mod, ctx, strings, fnSigs, errors);
-        const valType = inferExprWasmType(elExpr, ctx, fnSigs);
-        const offset = i * 8;
-        const ptrExpr = mod.local.get(ptrIndex, binaryen.i32);
-        if (valType === binaryen.f64) {
-            stores.push(mod.f64.store(offset, 0, ptrExpr, valWasm));
-        }
-        else {
-            stores.push(mod.i32.store(offset, 0, ptrExpr, valWasm));
-        }
-    }
-    const returnPtr = mod.local.get(ptrIndex, binaryen.i32);
-    return mod.block(null, [setPtr, incrementHeap, ...stores, returnPtr], binaryen.i32);
-}
-function compileEnumConstructor(expr, mod, ctx, strings, fnSigs, errors) {
-    const enumLayout = ctx.enumLayouts.get(expr.enumName);
-    if (!enumLayout) {
-        errors.push(`Enum layout not found for ${expr.enumName}`);
-        return mod.unreachable();
-    }
-    const variantLayout = enumLayout.variants.find(v => v.name === expr.variant);
-    if (!variantLayout) {
-        errors.push(`Variant layout not found for ${expr.enumName}.${expr.variant}`);
-        return mod.unreachable();
-    }
-    const ptrIndex = ctx.addLocal(`__enum_ptr_${expr.id}`, binaryen.i32);
-    const setPtr = mod.local.set(ptrIndex, mod.global.get("__heap_ptr", binaryen.i32));
-    const incrementHeap = mod.global.set("__heap_ptr", mod.i32.add(mod.local.get(ptrIndex, binaryen.i32), mod.i32.const(variantLayout.totalSize)));
-    const stores = [];
-    // Store tag
-    const ptrExpr = mod.local.get(ptrIndex, binaryen.i32);
-    stores.push(mod.i32.store(0, 0, ptrExpr, mod.i32.const(variantLayout.tag)));
-    // Store fields
-    for (const fieldInit of expr.fields) {
-        const valWasm = compileExpr(fieldInit.value, mod, ctx, strings, fnSigs, errors);
-        const fieldLayout = variantLayout.fields.find(f => f.name === fieldInit.name);
-        if (!fieldLayout)
-            continue; // Should be caught by type checker
-        const ptrExprForField = mod.local.get(ptrIndex, binaryen.i32);
-        if (fieldLayout.wasmType === binaryen.f64) {
-            stores.push(mod.f64.store(fieldLayout.offset, 0, ptrExprForField, valWasm));
-        }
-        else {
-            stores.push(mod.i32.store(fieldLayout.offset, 0, ptrExprForField, valWasm));
-        }
-    }
-    const returnPtr = mod.local.get(ptrIndex, binaryen.i32);
-    return mod.block(null, [setPtr, incrementHeap, ...stores, returnPtr], binaryen.i32);
-}
-function compileAccess(expr, mod, ctx, strings, fnSigs, errors) {
-    let recordTypeName;
-    // Try to infer record type from target
-    if (expr.target.kind === "ident") {
-        const local = ctx.getLocal(expr.target.name);
-        if (local && local.edictTypeName) {
-            recordTypeName = local.edictTypeName;
-        }
-    }
-    else if (expr.target.kind === "record_expr") {
-        recordTypeName = expr.target.name;
-    }
-    if (!recordTypeName) {
-        errors.push(`cannot resolve record type for field access '${expr.field}'`);
-        return mod.unreachable();
-    }
-    const layout = ctx.recordLayouts.get(recordTypeName);
-    if (!layout) {
-        errors.push(`unknown record type: ${recordTypeName}`);
-        return mod.unreachable();
-    }
-    const fieldLayout = layout.fields.find((f) => f.name === expr.field);
-    if (!fieldLayout) {
-        errors.push(`unknown field '${expr.field}' on record '${recordTypeName}'`);
-        return mod.unreachable();
-    }
-    const ptrExpr = compileExpr(expr.target, mod, ctx, strings, fnSigs, errors);
-    if (fieldLayout.wasmType === binaryen.f64) {
-        return mod.f64.load(fieldLayout.offset, 0, ptrExpr);
-    }
-    else {
-        return mod.i32.load(fieldLayout.offset, 0, ptrExpr);
-    }
-}
-/**
- * Scan function bodies for calls to imported names and infer WASM types
- * from the function's declared param/return types at call sites.
- */
-function inferImportSignatures(module, importedNames) {
-    const sigs = new Map();
-    // Initialize with defaults
-    for (const name of importedNames) {
-        sigs.set(name, { paramTypes: [], returnType: binaryen.i32 });
-    }
-    // Multi-pass: run inference until stable (handles ordering deps like pow→sqrt)
-    for (let pass = 0; pass < 3; pass++) {
-        for (const def of module.definitions) {
-            if (def.kind !== "fn")
-                continue;
-            inferFromExprs(def.body, def, sigs, importedNames);
-        }
-    }
-    return sigs;
-}
-function inferFromExprs(exprs, enclosingFn, sigs, importedNames) {
-    for (const expr of exprs) {
-        inferFromExpr(expr, enclosingFn, sigs, importedNames);
-    }
-}
-function inferFromExpr(expr, enclosingFn, sigs, importedNames) {
-    if (expr.kind === "call" && expr.fn.kind === "ident" && importedNames.has(expr.fn.name)) {
-        const name = expr.fn.name;
-        // Infer param types from arguments
-        const paramTypes = expr.args.map(arg => inferTypeFromExpr(arg, enclosingFn, sigs));
-        // If any param is f64, promote all i32 numeric params to f64
-        // (JSON can't distinguish 2.0 from 2; Edict doesn't mix int/float in one function)
-        const hasFloat = paramTypes.some(t => t === binaryen.f64);
-        if (hasFloat) {
-            for (let j = 0; j < paramTypes.length; j++) {
-                if (paramTypes[j] === binaryen.i32 && expr.args[j]?.kind === "literal" &&
-                    typeof expr.args[j].value === "number") {
-                    paramTypes[j] = binaryen.f64;
-                }
-            }
-        }
-        // Infer return type from the enclosing function's return type
-        // (if this call is the last expression in the function body, it determines the return type)
-        const lastExprInBody = enclosingFn.body.length > 0
-            ? enclosingFn.body[enclosingFn.body.length - 1]
-            : null;
-        const returnType = isExprOrContains(lastExprInBody, expr)
-            ? edictTypeToWasm(enclosingFn.returnType)
-            : binaryen.i32;
-        sigs.set(name, { paramTypes, returnType });
-    }
-    // Recurse into sub-expressions
-    switch (expr.kind) {
-        case "binop":
-            inferFromExpr(expr.left, enclosingFn, sigs, importedNames);
-            inferFromExpr(expr.right, enclosingFn, sigs, importedNames);
-            break;
-        case "unop":
-            inferFromExpr(expr.operand, enclosingFn, sigs, importedNames);
-            break;
-        case "call":
-            inferFromExpr(expr.fn, enclosingFn, sigs, importedNames);
-            for (const a of expr.args)
-                inferFromExpr(a, enclosingFn, sigs, importedNames);
-            break;
-        case "if":
-            inferFromExpr(expr.condition, enclosingFn, sigs, importedNames);
-            inferFromExprs(expr.then, enclosingFn, sigs, importedNames);
-            if (expr.else)
-                inferFromExprs(expr.else, enclosingFn, sigs, importedNames);
-            break;
-        case "let":
-            inferFromExpr(expr.value, enclosingFn, sigs, importedNames);
-            break;
-        case "block":
-            inferFromExprs(expr.body, enclosingFn, sigs, importedNames);
-            break;
-        case "match":
-            inferFromExpr(expr.target, enclosingFn, sigs, importedNames);
-            for (const arm of expr.arms)
-                inferFromExprs(arm.body, enclosingFn, sigs, importedNames);
-            break;
-        case "lambda":
-            inferFromExprs(expr.body, enclosingFn, sigs, importedNames);
-            break;
-        case "array":
-            for (const el of expr.elements)
-                inferFromExpr(el, enclosingFn, sigs, importedNames);
-            break;
-        case "record_expr":
-            for (const f of expr.fields)
-                inferFromExpr(f.value, enclosingFn, sigs, importedNames);
-            break;
-        case "access":
-            inferFromExpr(expr.target, enclosingFn, sigs, importedNames);
-            break;
-        default: break;
-    }
-}
-/**
- * Infer the WASM type of an expression from its AST structure.
- * Used during import signature inference (before we have a FunctionContext).
- */
-function inferTypeFromExpr(expr, enclosingFn, sigs) {
-    if (expr.kind === "literal") {
-        if (expr.type)
-            return edictTypeToWasm(expr.type);
-        if (typeof expr.value === "number" && !Number.isInteger(expr.value))
-            return binaryen.f64;
-        return binaryen.i32;
-    }
-    if (expr.kind === "ident") {
-        const param = enclosingFn.params.find(p => p.name === expr.name);
-        if (param)
-            return edictTypeToWasm(param.type);
-        return binaryen.i32;
-    }
-    if (expr.kind === "binop") {
-        // Arithmetic result type follows left operand
-        const cmpOps = ["==", "!=", "<", ">", "<=", ">=", "and", "or", "implies"];
-        if (cmpOps.includes(expr.op))
-            return binaryen.i32;
-        return inferTypeFromExpr(expr.left, enclosingFn, sigs);
-    }
-    if (expr.kind === "call" && expr.fn.kind === "ident") {
-        // Check inferred import sigs first, then fn defs
-        if (sigs?.has(expr.fn.name)) {
-            return sigs.get(expr.fn.name).returnType;
-        }
-        // Check enclosing module's function definitions
-        return binaryen.i32;
-    }
-    return binaryen.i32;
-}
-/**
- * Check if target expression is or contains the needle (by reference).
- */
-function isExprOrContains(target, needle) {
-    if (!target)
-        return false;
-    if (target === needle)
-        return true;
-    switch (target.kind) {
-        case "call": return target.args.some(a => isExprOrContains(a, needle)) || isExprOrContains(target.fn, needle);
-        case "binop": return isExprOrContains(target.left, needle) || isExprOrContains(target.right, needle);
-        case "unop": return isExprOrContains(target.operand, needle);
-        default: return false;
-    }
-}
-// =============================================================================
-// Array expression compilation
-// =============================================================================
-function compileArrayExpr(expr, mod, ctx, strings, fnSigs, errors) {
-    const elements = expr.elements;
-    // Layout: [length: i32] [elem0: i32] [elem1: i32] ...
-    const headerSize = 4; // i32 for length
-    const elemSize = 4; // i32 per element
-    const totalSize = headerSize + elements.length * elemSize;
-    const ptrIndex = ctx.addLocal(`__array_ptr_${expr.id}`, binaryen.i32);
-    const setPtr = mod.local.set(ptrIndex, mod.global.get("__heap_ptr", binaryen.i32));
-    const incrementHeap = mod.global.set("__heap_ptr", mod.i32.add(mod.local.get(ptrIndex, binaryen.i32), mod.i32.const(totalSize)));
-    // Store length at offset 0
-    const storeLength = mod.i32.store(0, 0, mod.local.get(ptrIndex, binaryen.i32), mod.i32.const(elements.length));
-    // Store each element
-    const stores = [];
-    for (let i = 0; i < elements.length; i++) {
-        const valueExpr = compileExpr(elements[i], mod, ctx, strings, fnSigs, errors);
-        stores.push(mod.i32.store(headerSize + i * elemSize, 0, mod.local.get(ptrIndex, binaryen.i32), valueExpr));
-    }
-    return mod.block(null, [
-        setPtr,
-        incrementHeap,
-        storeLength,
-        ...stores,
-        mod.local.get(ptrIndex, binaryen.i32), // return pointer
-    ], binaryen.i32);
-}
-// =============================================================================
-// Lambda expression compilation
-// =============================================================================
-// Counter for generating unique lambda function names
-let lambdaCounter = 0;
-function compileLambdaExpr(expr, mod, ctx, strings, fnSigs, errors) {
-    // Compile as a module-level helper function with a generated name
-    const lambdaName = `__lambda_${lambdaCounter++}`;
-    const params = expr.params.map((p) => ({
-        name: p.name,
-        wasmType: edictTypeToWasm(p.type),
-    }));
-    const lambdaCtx = new FunctionContext(params.map(p => ({ name: p.name, wasmType: p.wasmType })), ctx.constGlobals, ctx.recordLayouts, ctx.enumLayouts);
-    const paramTypes = params.map(p => p.wasmType);
-    const paramType = paramTypes.length > 0
-        ? binaryen.createType(paramTypes)
-        : binaryen.none;
-    // Infer return type from last body expression
-    let returnType = binaryen.i32;
-    if (expr.body.length > 0) {
-        returnType = inferExprWasmType(expr.body[expr.body.length - 1], lambdaCtx, fnSigs);
-    }
-    // Compile body
-    const bodyExprs = expr.body.map((e, i) => {
-        const compiled = compileExpr(e, mod, lambdaCtx, strings, fnSigs, errors);
-        if (i < expr.body.length - 1 && e.kind !== "let") {
-            return mod.drop(compiled);
-        }
-        return compiled;
-    });
-    let body;
-    if (bodyExprs.length === 0) {
-        body = mod.nop();
-    }
-    else if (bodyExprs.length === 1) {
-        body = bodyExprs[0];
-    }
-    else {
-        body = mod.block(null, bodyExprs, returnType);
-    }
-    mod.addFunction(lambdaName, paramType, returnType, lambdaCtx.varTypes, body);
-    fnSigs.set(lambdaName, { returnType, paramTypes: paramTypes });
-    // Return the function index as an i32 (for indirect calls / function references)
-    // For now, we add it to a table so it can be called indirectly
-    // Use a simple approach: return an i32 identifier that the caller can use
-    // The function is registered; callers that use it via direct name will resolve it
-    return mod.i32.const(lambdaCounter - 1);
-}
-function compileStringInterp(expr, mod, ctx, strings, fnSigs, errors) {
-    const parts = expr.parts;
-    // Edge case: no parts → empty string
-    if (parts.length === 0) {
-        const empty = strings.intern("");
-        // Set __str_ret_len so downstream consumers read correct length
-        return mod.block(null, [
-            mod.global.set("__str_ret_len", mod.i32.const(empty.length)),
-            mod.i32.const(empty.offset),
-        ], binaryen.i32);
-    }
-    // Single part → compile directly (no concat needed)
-    // For string literals, must also set __str_ret_len
-    if (parts.length === 1) {
-        const part = parts[0];
-        if (part.kind === "literal" && typeof part.value === "string") {
-            const interned = strings.intern(part.value);
-            return mod.block(null, [
-                mod.global.set("__str_ret_len", mod.i32.const(interned.length)),
-                mod.i32.const(interned.offset),
-            ], binaryen.i32);
-        }
-        // Non-literal — __str_ret_len already set by callee
-        return compileExpr(part, mod, ctx, strings, fnSigs, errors);
-    }
-    // Helper: compile a part and return [ptrExpr, lenExpr]
-    function compilePart(part) {
-        if (part.kind === "literal" && typeof part.value === "string") {
-            const interned = strings.intern(part.value);
-            return [mod.i32.const(interned.offset), mod.i32.const(interned.length)];
-        }
-        const ptrExpr = compileExpr(part, mod, ctx, strings, fnSigs, errors);
-        return [ptrExpr, mod.global.get("__str_ret_len", binaryen.i32)];
-    }
-    // Left-fold: concat(concat(concat(parts[0], parts[1]), parts[2]), ...)
-    // Must save intermediate results to temp locals to prevent __str_ret_len clobbering.
-    const stmts = [];
-    // Compile first part, save ptr+len to temp locals
-    const [ptr0, len0] = compilePart(parts[0]);
-    const accPtrIdx = ctx.addLocal(`__interp_ptr_${expr.id}`, binaryen.i32);
-    const accLenIdx = ctx.addLocal(`__interp_len_${expr.id}`, binaryen.i32);
-    stmts.push(mod.local.set(accPtrIdx, ptr0));
-    stmts.push(mod.local.set(accLenIdx, len0));
-    // For each subsequent part, concat with accumulator
-    for (let i = 1; i < parts.length; i++) {
-        const [partPtr, partLen] = compilePart(parts[i]);
-        // Save part ptr+len to temp locals (partLen may reference __str_ret_len
-        // which gets overwritten by the concat call)
-        const tmpPartPtrIdx = ctx.addLocal(`__interp_p${i}_ptr_${expr.id}`, binaryen.i32);
-        const tmpPartLenIdx = ctx.addLocal(`__interp_p${i}_len_${expr.id}`, binaryen.i32);
-        stmts.push(mod.local.set(tmpPartPtrIdx, partPtr));
-        stmts.push(mod.local.set(tmpPartLenIdx, partLen));
-        // Call string_concat(accPtr, accLen, partPtr, partLen)
-        const concatResult = mod.call("string_concat", [
-            mod.local.get(accPtrIdx, binaryen.i32),
-            mod.local.get(accLenIdx, binaryen.i32),
-            mod.local.get(tmpPartPtrIdx, binaryen.i32),
-            mod.local.get(tmpPartLenIdx, binaryen.i32),
-        ], binaryen.i32);
-        // Save result ptr and new __str_ret_len
-        stmts.push(mod.local.set(accPtrIdx, concatResult));
-        stmts.push(mod.local.set(accLenIdx, mod.global.get("__str_ret_len", binaryen.i32)));
-    }
-    // Return the final accumulated pointer
-    stmts.push(mod.local.get(accPtrIdx, binaryen.i32));
-    return mod.block(null, stmts, binaryen.i32);
-}
-// =============================================================================
-// String literal collector (pre-scan)
-// =============================================================================
-function collectStrings(exprs, strings) {
-    for (const expr of exprs) {
-        collectStringExpr(expr, strings);
-    }
-}
-function collectStringExpr(expr, strings) {
-    switch (expr.kind) {
-        case "literal":
-            if (typeof expr.value === "string") {
-                strings.intern(expr.value);
-            }
-            break;
-        case "binop":
-            collectStringExpr(expr.left, strings);
-            collectStringExpr(expr.right, strings);
-            break;
-        case "unop":
-            collectStringExpr(expr.operand, strings);
-            break;
-        case "call":
-            collectStringExpr(expr.fn, strings);
-            for (const arg of expr.args)
-                collectStringExpr(arg, strings);
-            break;
-        case "if":
-            collectStringExpr(expr.condition, strings);
-            collectStrings(expr.then, strings);
-            if (expr.else)
-                collectStrings(expr.else, strings);
-            break;
-        case "let":
-            collectStringExpr(expr.value, strings);
-            break;
-        case "block":
-            collectStrings(expr.body, strings);
-            break;
-        case "match":
-            collectStringExpr(expr.target, strings);
-            for (const arm of expr.arms)
-                collectStrings(arm.body, strings);
-            break;
-        case "lambda":
-            collectStrings(expr.body, strings);
-            break;
-        case "record_expr":
-            for (const field of expr.fields) {
-                collectStringExpr(field.value, strings);
-            }
-            break;
-        case "tuple_expr":
-            for (const el of expr.elements) {
-                collectStringExpr(el, strings);
-            }
-            break;
-        case "enum_constructor":
-            for (const field of expr.fields) {
-                collectStringExpr(field.value, strings);
-            }
-            break;
-        case "access":
-            collectStringExpr(expr.target, strings);
-            break;
-        case "string_interp":
-            for (const part of expr.parts) {
-                collectStringExpr(part, strings);
-            }
-            break;
-        // ident, array, tuple_expr, enum_constructor
-        // — no string literals directly
+            cc.errors.push(wasmValidationError(`unsupported expression kind: ${expr.kind}`));
+            return cc.mod.unreachable();
     }
 }
 //# sourceMappingURL=codegen.js.map