@scriptc/compiler 0.0.25 → 0.0.27

package/dist/backend/llvm/emitter.js

@@ -1,5 +1,69 @@
-import { canMarshalFuncIntoIsland, CAUGHT, DYN, F64, islandCallbackRet, islandPromisePayloadTag, isRefCounted, isUnitType, MAY_THROW_LIB_FNS, moduleUsesDynInvoke, moduleUsesFetch, moduleUsesFsWatch, moduleUsesHttpServer, moduleUsesNet, moduleUsesProcessEvents, moduleUsesStream, moduleUsesTls, moduleUsesTlsCa, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, STRING, typeEquals, typeKey, VOID } from "../../ir/nodes.js";
+/* IR → LLVM IR text (.ll). The LLVM backend consumes the SAME in-memory
+ * IrModule the C backend does (never the JSON dump — see the -0 lesson in
+ * the survey) and produces a textual module that rides compileC's
+ * program-TU seat: clang compiles .ll on the exact command line that
+ * compiles the .c, linking the same scr_* runtime with the same C ABI.
+ *
+ * Phase 1 was the TRIVIAL TIER: f64/bool/string locals and params, the
+ * scalar operator set, structured control flow, direct calls, interned
+ * string literals, and the console protocol. Phase 2 adds the VOLUME
+ * TIER: module globals and locals of every in-tier ref kind (arrays,
+ * record shapes, unions, function values/closures), the full array and
+ * string intrinsic surfaces, per-record-shape RC helpers (cycle headers
+ * included — the C emitter's fixpoint, ported in shapes.ts), tagged-union
+ * construction/narrowing/equality with interned immortal unit instances,
+ * capture boxes and the closure calling convention, switch/for-of
+ * lowering, and the non-throwing slice of the libCall table. EVERYTHING
+ * ELSE REFUSES loudly at the first unhandled node (LlvmUnsupportedError
+ * naming the kind) — this backend never guesses and never emits wrong
+ * code for a construct it does not model. compile() surfaces the refusal
+ * as diagnostic SC3001.
+ *
+ * RC ownership discipline: the frame/scope release-point machinery is
+ * ported from CEmitter (docs/ir.md) — every refcounted temp holds an owned
+ * +1 reference; varDecl/assign/return/call-argument MOVE that ownership;
+ * each statement releases its remaining refcounted temps when it ends;
+ * each scope releases the refcounted locals declared in it when it exits;
+ * callees own their params; return/break/continue release everything the
+ * jump bypasses (releaseForJump). Releases are type-directed through
+ * shapes.ts (the releaseCallC table's LLVM twin); frame entries can be
+ * SLOT-based (the entry names a pointer whose CURRENT value releases —
+ * conditional results like optional chains need that indirection).
+ *
+ * Exceptions (phase 4): the pending-flag unwind protocol, ported from the
+ * C emitter. `throw` moves its payload into the runtime's exception cell
+ * (scr_throw_*) and unwinds; after every call that can raise (per the
+ * SAME computeMayThrow analysis the C backend runs) a pending check tests
+ * scr_exc_pending() and unwinds — releasing frames/scopes down to the
+ * innermost try handler's depths and branching to its label, or releasing
+ * everything and returning a dummy value (never read: callers of a
+ * may-throw function test the flag before using the result). No
+ * setjmp/longjmp: longjmp would skip the emitted RC releases. try/catch
+ * follows emit-stmts.ts's shape exactly — a compile-time tryStack entry
+ * per region, the catch block taking the exception (scr_exc_take into the
+ * binding's snapshot box, or scr_exc_clear for the bindingless form), the
+ * finally body emitted once per path (normal, exception-with-stash,
+ * pending-return) with fresh temps each time. Catch bindings ride
+ * ScrCaught snapshot boxes (caughtTest/caughtNarrow/caughtCheck read
+ * them); TDZ reads test the box's payload slot and throw Node's
+ * ReferenceError. main() gains the uncaught epilogue when the entry
+ * function may throw.
+ *
+ * The dyn surface (phase 5): ScrDyn dyn values are in the tier — dyn.ts
+ * ports emit-walkers.ts's dyn slice (match/check/toDyn walkers, the
+ * String(unknown)/caught→dyn/keyed-read singletons, the checked-dynamic
+ * function boundary's thunk/box/adapter triple) and the emitter lowers
+ * the dyn expression kinds (dynFrom/dynCall/dynInvoke/dynTest/dynKeyGet/
+ * dynCheck/destructuring), the JSON.parse family, dyn record fields and
+ * overflow maps, dyn capture boxes, and generator unknown channels.
+ * The island surface (jsval/jsExit and embedded npm tables) is in the
+ * tier too; the module text and resolution tables use the same compressed,
+ * lazy-inflate representation as the C debugging backend.
+ */
+import { deflateRawSync } from "node:zlib";
+import { canMarshalFuncIntoIsland, CAUGHT, DYN, F64, ffiCallbackType, islandCallbackRet, islandPromisePayloadTag, isFfiCallbackParam, isFfiContextParam, isRefCounted, isUnitType, MAY_THROW_LIB_FNS, moduleEmbedsBuiltin, moduleEmbedsCompressedNpm, moduleUsesDynInvoke, moduleUsesFetch, moduleUsesFsWatch, moduleUsesHttpServer, moduleUsesNet, moduleUsesNodeTest, moduleUsesProcessEvents, moduleUsesStream, moduleUsesTls, moduleUsesTlsCa, NPM_COMPRESS_MIN, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, STRING, typeEquals, typeKey, VOID } from "../../ir/nodes.js";
 import { matchIntegerBytesForLoop } from "../../ir/integer-loops.js";
+import { allocateFfiCallbackAdapters } from "../ffi-callbacks.js";
 import { computeMayThrow } from "../emission/may-throw.js";
 import { mangleArgPack, mangleAsyncSpawn, mangleClassNew, mangleClassObj, mangleClassRetain, mangleFnClosure, mangleFunction, mangleGenDrop, mangleGenResThunk, mangleGenSpawn, mangleGlobal, mangleLocal, mangleRecordNew, mangleRecordStruct, mangleResolveThunk, mangleTrampoline, mangleVtStruct, mangleWrapper } from "../mangle.js";
 import { BlockBuilder } from "./blocks.js";
@@ -7,10 +71,41 @@ import { buildClassGraph, classFieldIndex, classStructSym, emitClassObjDefs, emi
 import { DK, LlDyn } from "./dyn.js";
 import { LlvmUnsupportedError } from "./unsupported.js";
 import { LlWalkers } from "./walkers.js";
+function ffiNativeTypeLl(cls) {
+    switch (cls) {
+        case "f64":
+            return "double";
+        case "bool":
+        case "u8":
+            return "i8";
+        case "u32":
+        case "i32":
+            return "i32";
+        case "string":
+        case "bytes":
+            throw new Error(`llvm emitter bug: span class '${cls}' has no scalar LLVM type`);
+        case "void":
+            return "void";
+    }
+}
+function ffiCallbackDummyLl(callback) {
+    switch (callback.returns) {
+        case "void":
+            return "void";
+        case "f64":
+            return "double 0.0";
+        case "bool":
+        case "u8":
+            return "i8 0";
+        case "u32":
+        case "i32":
+            return "i32 0";
+    }
+}
 import { arrNewCall, boxAccess, boxNewCall, computeTraced, elemAccess, emitRecordShapes, FN_ATTRS, llFieldType, mapKeyAccess, mapKeyKindNum, mapValKindNum, releaseSym, retainSym, traceAdapter, traceArg, vAdapters, } from "./shapes.js";
 export { LlvmUnsupportedError } from "./unsupported.js";
-export function emitLlvmModule(mod) {
-    return new LlEmitter(mod).emit();
+export function emitLlvmModule(mod, options = {}) {
+    return new LlEmitter(mod, options).emit();
 }
 /** Exact double literal: LLVM's 16-digit hex form round-trips every f64
  * bit pattern (−0 and the full denormal range included). */
@@ -22,8 +117,7 @@ function f64Lit(n) {
 const F64_INF = f64Lit(Infinity);
 /** LLVM c"..." payload for a UTF-8 literal, NUL-terminated like the C
  * emitter's flexible-array-member initializer. */
-function llStrBytes(text) {
-    const bytes = Buffer.from(text, "utf8");
+function llBytes(bytes) {
     let s = "";
     for (const b of bytes) {
         s +=
@@ -33,6 +127,9 @@ function llStrBytes(text) {
     }
     return `${s}\\00`;
 }
+function llStrBytes(text) {
+    return llBytes(Buffer.from(text, "utf8"));
+}
 /** The non-throwing libCall slice the tier claims: IrLibFn → runtime
  * symbol, called generically (LLVM arg/result types derive from the call
  * site's IR types, which is exactly the contract the C prototypes pin).
@@ -549,6 +646,9 @@ const LIB_FN_SYMS = {
     "http.resWriteHeadPairs": "scr_http_res_write_head_pairs",
     "http.resWriteHeadDyn": "scr_http_res_write_head_dyn",
     "http.serverJoinDupHeaders": "scr_http_server_join_duplicate_headers",
+    "http.serverTimeoutGet": "scr_net_server_timeout_get",
+    "http.serverTimeoutSet": "scr_net_server_timeout_set",
+    "http.serverTimeoutOptionSet": "scr_net_server_timeout_option_set",
     "http.clientWrite": "scr_http_client_write_str",
     "http.clientWriteBytes": "scr_http_client_write_bytes",
     "http.clientEnd": "scr_http_client_end",
@@ -771,6 +871,9 @@ const DV_SET_KIND = {
 };
 class LlEmitter {
     mod;
+    sizeType;
+    cycleColorOffset;
+    wasi;
     /** Interned string literals: UTF-8 text → { symbol, byte length } —
      * first-use order, the C emitter's determinism discipline. */
     literals = new Map();
@@ -811,6 +914,9 @@ class LlEmitter {
     fnByName = new Map();
     /** Manifest-bound native imports, used by ffiCall emission. */
     ffiByName = new Map();
+    /** C-ABI callback trampolines and (for raw/no-userdata callbacks) their
+     * distinct call-scoped TLS closure slots. */
+    ffiCallbackAdapters;
     globalTypes = new Map();
     /** May-throw analysis (the C emitter's computeMayThrow, shared): pending
      * checks are emitted only after calls that can actually raise. */
@@ -873,7 +979,7 @@ class LlEmitter {
     jumpTargets = [];
     currentLocals = new Map();
     captureIds = new Set();
-    /** Active canonical byte-loop induction bindings: local id → i64 slot. */
+    /** Active canonical byte-loop induction bindings: local id → size_t slot. */
     integerLoopBindings = new Map();
     /** Enclosing try-with-FINALLY regions, innermost last: a `return`
      * inside one runs every crossed finally (innermost first) before the
@@ -894,6 +1000,9 @@ class LlEmitter {
     /** Return type of the function being emitted — the unwind path returns
      * a dummy of this type (never read: callers check the flag first). */
     currentReturnType = VOID;
+    /** Active only while emitting a wasm32 async body lowered with LLVM's
+     * switched-coroutine intrinsics. */
+    currentWasiCoro = null;
     /** The generator channels of the function being emitted (null outside
      * generator bodies): yieldExpr emission reads them, and emitTryCatch's
      * catch prologue emits the GENRET sentinel re-unwind exactly here. */
@@ -901,12 +1010,20 @@ class LlEmitter {
     /** Active optional-chain bind slots, by chain id (chainRecv reads). */
     chainSlots = new Map();
     logArgSlots = 0;
-    constructor(mod) {
+    constructor(mod, options) {
         this.mod = mod;
+        this.sizeType = options.pointerBits === 32 ? "i32" : "i64";
+        this.wasi = options.wasi === true;
+        // ScrCycHdr is { ptr trace; ptr free; i32 color; i16 buffered;
+        // i16 gen; size_t buf_index }. The object follows it, so color is 12
+        // bytes behind a wasm32 object and 16 bytes behind a 64-bit object.
+        this.cycleColorOffset = options.pointerBits === 32 ? 12 : 16;
+        this.ffiCallbackAdapters = allocateFfiCallbackAdapters(mod.ffiImports ?? []);
         for (const fn of mod.functions)
             this.fnByName.set(fn.name, fn);
-        for (const entry of mod.ffiImports ?? [])
+        for (const entry of mod.ffiImports ?? []) {
             this.ffiByName.set(entry.name, entry);
+        }
         const mt = computeMayThrow(mod);
         this.mayThrow = mt.fns;
         this.indirectMayThrow = mt.indirect;
@@ -978,9 +1095,9 @@ class LlEmitter {
                 lib: rec.lib,
             });
         }
-        if (mod.embedded !== undefined && mod.embedded.modules.length > 0) {
-            throw new LlvmUnsupportedError("npmEmbedding");
-        }
+    }
+    abiOffset(native64, wasm32) {
+        return this.sizeType === "i32" ? wasm32 : native64;
     }
     // ── types ───────────────────────────────────────────────────────────────
     llType(t) {
@@ -1037,6 +1154,93 @@ class LlEmitter {
         }
     }
     // ── module assembly ─────────────────────────────────────────────────────
+    ffiCallbackAdapter(binding, id) {
+        const adapter = this.ffiCallbackAdapters.get(`${binding}:${id}`);
+        if (!adapter)
+            throw new Error(`llvm emitter bug: no callback adapter for ${binding}:${id}`);
+        return adapter;
+    }
+    /** C-callable scalar callback trampolines. A callback with an explicit
+     * context entry receives the closure at that exact ABI position. A raw
+     * callback loads it from a call-scoped TLS slot installed around the
+     * outer native call. */
+    emitFfiCallbackDefs() {
+        const globals = [];
+        const defs = [];
+        if (this.ffiCallbackAdapters.size === 0)
+            return { globals, defs };
+        this.declare(`declare zeroext i1 @scr_exc_pending()`);
+        this.declare(`declare void @scr_trap(ptr)`);
+        const expired = this.cstr("scriptc: native callback invoked outside its call-scoped lifetime\n");
+        for (const adapter of this.ffiCallbackAdapters.values()) {
+            const cb = adapter.callback;
+            if (adapter.tls !== null)
+                globals.push(`@${adapter.tls} = internal thread_local global ptr null`);
+            const params = cb.params.map((param, i) => isFfiContextParam(param) ? `ptr %ctx` : `${ffiNativeTypeLl(param)} %a${i}`);
+            const ret = ffiNativeTypeLl(cb.returns);
+            defs.push(`define internal ${ret} @${adapter.symbol}(${params.join(", ")}) ${FN_ATTRS} {`, `entry:`, adapter.tls === null ? `  %cb = getelementptr inbounds i8, ptr %ctx, i64 0` : `  %cb = load ptr, ptr @${adapter.tls}`, `  %missing = icmp eq ptr %cb, null`, `  br i1 %missing, label %expired, label %ready`, `expired:`, `  call void @scr_trap(ptr ${expired})`, `  unreachable`, `ready:`, `  %pending = call zeroext i1 @scr_exc_pending()`, `  br i1 %pending, label %skip, label %invoke`, `skip:`, `  ret ${ffiCallbackDummyLl(cb)}`, `invoke:`, `  %fnp = getelementptr inbounds %ScrClosure, ptr %cb, i64 0, i32 1`, `  %fn = load ptr, ptr %fnp`);
+            const scriptArgs = [];
+            for (let i = 0; i < cb.params.length; i++) {
+                const param = cb.params[i];
+                if (isFfiContextParam(param))
+                    continue;
+                switch (param) {
+                    case "f64":
+                        scriptArgs.push(`double %a${i}`);
+                        break;
+                    case "bool":
+                        defs.push(`  %s${i} = icmp ne i8 %a${i}, 0`);
+                        scriptArgs.push(`i1 %s${i}`);
+                        break;
+                    case "u8":
+                        defs.push(`  %s${i} = uitofp i8 %a${i} to double`);
+                        scriptArgs.push(`double %s${i}`);
+                        break;
+                    case "u32":
+                        defs.push(`  %s${i} = uitofp i32 %a${i} to double`);
+                        scriptArgs.push(`double %s${i}`);
+                        break;
+                    case "i32":
+                        defs.push(`  %s${i} = sitofp i32 %a${i} to double`);
+                        scriptArgs.push(`double %s${i}`);
+                        break;
+                }
+            }
+            const ft = ffiCallbackType(cb);
+            const internalRet = this.llType(ft.ret);
+            const callArgs = [`ptr %cb`, ...scriptArgs].join(", ");
+            if (cb.returns === "void") {
+                defs.push(`  call void %fn(${callArgs})`, `  ret void`, `}`, ``);
+                continue;
+            }
+            defs.push(`  %result = call ${internalRet} %fn(${callArgs})`);
+            switch (cb.returns) {
+                case "f64":
+                    defs.push(`  ret double %result`);
+                    break;
+                case "bool":
+                    defs.push(`  %out = zext i1 %result to i8`, `  ret i8 %out`);
+                    break;
+                case "u8":
+                case "u32":
+                    this.declare(`declare double @scr_bit_ushr(double, double)`);
+                    defs.push(`  %coerced = call double @scr_bit_ushr(double %result, double ${f64Lit(0)})`, `  %wide = fptoui double %coerced to i32`);
+                    if (cb.returns === "u8") {
+                        defs.push(`  %out = trunc i32 %wide to i8`, `  ret i8 %out`);
+                    }
+                    else {
+                        defs.push(`  ret i32 %wide`);
+                    }
+                    break;
+                case "i32":
+                    this.declare(`declare double @scr_bit_or(double, double)`);
+                    defs.push(`  %coerced = call double @scr_bit_or(double %result, double ${f64Lit(0)})`, `  %out = fptosi double %coerced to i32`, `  ret i32 %out`);
+                    break;
+            }
+            defs.push(`}`, ``);
+        }
+        return { globals, defs };
+    }
     emit() {
         // Function bodies first (the literal/unit/fn-value tables fill as they
         // emit), then the file assembles around them — the C emitter's order.
@@ -1048,6 +1252,24 @@ class LlEmitter {
         const classObjDefs = emitClassObjDefs(this, this.classMeta, this.classObjs, this.fnByName, (t) => this.llType(t));
         const wrappers = this.emitFnValueDefs();
         const asyncDefs = this.emitAsyncScaffolding();
+        const ffiCallbacks = this.emitFfiCallbackDefs();
+        const embedded = this.mod.embedded;
+        const usesIsland = embedded !== undefined && embedded.modules.length > 0;
+        const storeNpmText = (text) => {
+            const plain = Buffer.from(text, "utf8");
+            if (text.length < NPM_COMPRESS_MIN)
+                return { bytes: plain, raw: 0 };
+            const deflated = deflateRawSync(plain, { level: 9 });
+            return deflated.length < plain.length
+                ? { bytes: deflated, raw: plain.length }
+                : { bytes: plain, raw: 0 };
+        };
+        const npmStored = usesIsland
+            ? embedded.modules.map((m) => ({
+                src: storeNpmText(m.source),
+                esm: m.esm === undefined ? null : storeNpmText(m.esm),
+            }))
+            : [];
         // Module globals, FIRST OCCURRENCE per id: a class-expression static
         // instantiated through several mixin applications registers one global
         // id several times (2041-mixin-values) — C's tentative definitions
@@ -1107,8 +1329,20 @@ class LlEmitter {
         // any island entry (the engine's lazy boot consults it) — cc.ts
         // compiles scr_fetch.c on the same predicate.
         const usesFetch = moduleUsesFetch(this.mod);
-        const snapshotsTlsCa = moduleUsesTls(this.mod) || moduleUsesTlsCa(this.mod);
+        const embedsZlib = moduleEmbedsBuiltin(this.mod, "node:zlib");
+        const embedsNet = moduleEmbedsBuiltin(this.mod, "node:http") ||
+            moduleEmbedsBuiltin(this.mod, "node:https") ||
+            moduleEmbedsBuiltin(this.mod, "node:net") ||
+            moduleEmbedsBuiltin(this.mod, "node:tls");
+        const snapshotsTlsCa = moduleUsesTls(this.mod) || moduleUsesTlsCa(this.mod) ||
+            moduleEmbedsBuiltin(this.mod, "node:https") ||
+            moduleEmbedsBuiltin(this.mod, "node:tls");
         const hasRefGlobals = globals.some((g) => isRefCounted(g.type)) || fnValueProps.length > 0;
+        // The process verdict has the same precedence as the C reference
+        // emitter: node:test owns the final status when present; otherwise an
+        // embedded process.exitCode owns it; ordinary programs return zero.
+        const usesNodeTest = moduleUsesNodeTest(this.mod);
+        const programExitUsesIsland = !usesNodeTest && usesIsland;
         // Declared NOW — the extern block flushes before main assembles.
         if (usesEvents)
             this.declare(`declare void @scr_events_install()`);
@@ -1124,6 +1358,20 @@ class LlEmitter {
             this.declare(`declare void @scr_http_dyn_install()`);
         if (usesFetch)
             this.declare(`declare void @scr_fetch_install()`);
+        if (embedsZlib)
+            this.declare(`declare void @scr_zlib_island_install()`);
+        if (embedsNet)
+            this.declare(`declare void @scr_net_island_install()`);
+        if (usesIsland) {
+            this.declare(`declare void @scr_island_modules(ptr, ${this.sizeType}, ptr, ${this.sizeType})`);
+            this.declare(`declare i32 @scr_island_exit_code()`);
+            if (moduleEmbedsCompressedNpm(this.mod)) {
+                this.declare(`declare void @scr_island_set_inflate(ptr)`);
+                this.declare(`declare zeroext i1 @scr_zlib_inflate_exact(ptr, ${this.sizeType}, ptr, ${this.sizeType})`);
+            }
+        }
+        if (usesNodeTest)
+            this.declare(`declare i32 @scr_test_exit_code()`);
         if (snapshotsTlsCa) {
             this.declare(`declare void @scr_tls_ca_install()`);
         }
@@ -1145,11 +1393,12 @@ class LlEmitter {
         const entryMayThrow = this.mayThrow.has(this.mod.entry);
         // The event loop runs when timers appeared OR any async/generator
         // function exists (the C main's hasAsync || hasGenerators ||
-        // usesTimers gate; the island stays refused). Generator programs run
+        // usesTimers gate). Generator programs run
         // the loop too: its exit accounting notes still-suspended generator
         // fibers as abandoned, so the RC audit downgrades exactly like the
         // async loop-exhaustion story.
         const runsLoop = this.usesTimers ||
+            usesIsland ||
             this.mod.functions.some((f) => f.async === true || f.generator !== undefined);
         const uncaughtReleases = entryMayThrow && !asyncEntry ? globalReleaseLines("gu") : [];
         const loopReleasesU = runsLoop ? globalReleaseLines("gl") : [];
@@ -1171,7 +1420,40 @@ class LlEmitter {
             this.declare(`declare i32 @scr_promise_finish_top_level(ptr)`);
             this.declare(`declare void @scr_promise_rethrow_top_level(ptr)`);
             this.declare(`declare void @scr_promise_release(ptr)`);
+            this.declare(`declare void @scr_exit_code_note(i32)`);
+            if (programExitUsesIsland && usesEvents && hasRefGlobals) {
+                this.declare(`declare ${this.sizeType} @scr_island_exit_code_version()`);
+            }
         }
+        const topPendingExitLines = () => {
+            if (!asyncEntry)
+                return [];
+            const lines = [];
+            if (usesNodeTest) {
+                lines.push(`  %tla_program_exit = call i32 @scr_test_exit_code()`);
+            }
+            else if (usesIsland) {
+                lines.push(`  %tla_program_exit = call i32 @scr_island_exit_code()`);
+            }
+            if (usesNodeTest || usesIsland) {
+                lines.push(`  %tla_program_exit_zero = icmp eq i32 %tla_program_exit, 0`, `  %tla_exit_status = select i1 %tla_program_exit_zero, i32 %tla_status, i32 %tla_program_exit`);
+            }
+            const exitStatus = usesNodeTest || usesIsland ? "%tla_exit_status" : "%tla_status";
+            const tracksIslandExit = programExitUsesIsland && usesEvents && hasRefGlobals;
+            if (tracksIslandExit) {
+                lines.push(`  %tla_exit_version = call ${this.sizeType} @scr_island_exit_code_version()`);
+            }
+            // finish_top_level initially notes 13. Replace that hint before exit
+            // listeners run when a higher-priority verdict was already selected.
+            lines.push(`  call void @scr_exit_code_note(i32 ${exitStatus})`);
+            lines.push(...exitListenerLines("xp"));
+            if (tracksIslandExit) {
+                lines.push(`  %tla_exit_version_after = call ${this.sizeType} @scr_island_exit_code_version()`, `  %tla_exit_changed = icmp ne ${this.sizeType} %tla_exit_version_after, %tla_exit_version`, `  br i1 %tla_exit_changed, label %tla_exit_updated, label %tla_exit_unchanged`, `tla_exit_updated:`, `  %tla_listener_exit = call i32 @scr_island_exit_code()`, `  call void @scr_exit_code_note(i32 %tla_listener_exit)`, `  br label %tla_exit_done`, `tla_exit_unchanged:`, `  br label %tla_exit_done`, `tla_exit_done:`, `  %tla_final_exit = phi i32 [ %tla_listener_exit, %tla_exit_updated ], [ ${exitStatus}, %tla_exit_unchanged ]`);
+            }
+            lines.push(...topPendingReleases);
+            lines.push(`  ret i32 ${tracksIslandExit ? "%tla_final_exit" : exitStatus}`);
+            return lines;
+        };
         // LIBRARY mode: the runtime entry points the generated library
         // symbols delegate to — declared before the extern block flushes.
         if (this.mod.lib !== undefined) {
@@ -1182,10 +1464,10 @@ class LlEmitter {
             this.declare(`declare void @scr_library_arena_reset()`);
             this.declare(`declare void @scr_library_collect()`);
             if (this.mod.lib.exports.some((e) => e.params.includes("string"))) {
-                this.declare(`declare ptr @scr_library_str_in(ptr, i64)`);
+                this.declare(`declare ptr @scr_library_str_in(ptr, ${this.sizeType})`);
             }
             if (this.mod.lib.exports.some((e) => e.params.includes("bytes"))) {
-                this.declare(`declare ptr @scr_library_bytes_in(ptr, i64, ptr)`);
+                this.declare(`declare ptr @scr_library_bytes_in(ptr, ${this.sizeType}, ptr)`);
             }
             if (this.mod.lib.exports.some((e) => e.params.includes("i64"))) {
                 this.declare(`declare double @scr_library_i64_in(i64, ptr)`);
@@ -1212,59 +1494,69 @@ class LlEmitter {
             // the C layout (4 bytes padding after the tag). ScrUnion/ScrClosure
             // mirror scr_runtime.h field-for-field (tag reads, slot peeks, the
             // fn pointer, and the caps[] tail all address through them).
-            `%ScrStr = type { i64, i64, i64 }`,
+            `%ScrStr = type { ${this.sizeType}, ${this.sizeType}, ${this.sizeType} }`,
             `%ScrLogArg = type { i32, i64 }`,
-            `%ScrVt = type { i64, i64, ptr }`,
-            `%ScrUnion = type { i64, i32, ptr, ptr, ptr, i64 }`,
-            `%ScrClosure = type { i64, ptr, i64, ptr }`,
-            `%ScrRegex = type { i64, ptr, ptr, ptr }`,
+            `%ScrVt = type { ${this.sizeType}, ${this.sizeType}, ptr }`,
+            `%ScrUnion = type { ${this.sizeType}, i32, ptr, ptr, ptr, i64 }`,
+            `%ScrClosure = type { ${this.sizeType}, ptr, ${this.sizeType}, ptr }`,
+            `%ScrRegex = type { ${this.sizeType}, ptr, ptr, ptr }`,
             // ScrArr mirror { rc, len, cap, elem(i32+pad), elem_retain,
             // elem_release, elem_trace, data } — the immortal tagged-template
             // strings objects lay out through it (nothing GEPs into live heap
             // arrays; those stay behind the runtime's own entry points).
-            `%ScrArr = type { i64, i64, i64, i32, ptr, ptr, ptr, ptr }`,
+            `%ScrArr = type { ${this.sizeType}, ${this.sizeType}, ${this.sizeType}, i32, ptr, ptr, ptr, ptr }`,
             // The runtime error prefix { rc, vt, name, message, code } and the
             // class-object shape { rc, pre, post, ctor, name } — field reads on
             // builtin errors and classval loads GEP through these.
-            `%ScrError = type { i64, ptr, ptr, ptr, ptr }`,
-            `%ScrClassObj = type { i64, i64, i64, ptr, ptr }`,
+            `%ScrError = type { ${this.sizeType}, ptr, ptr, ptr, ptr }`,
+            `%ScrClassObj = type { ${this.sizeType}, ${this.sizeType}, ${this.sizeType}, ptr, ptr }`,
             // The runtime emitter prefix { rc, vt, reg, cls } — user subclasses
             // embed it (classes.ts), and bare-emitter GEPs address through it.
-            `%ScrEmitter = type { i64, ptr, ptr, ptr }`,
+            `%ScrEmitter = type { ${this.sizeType}, ptr, ptr, ptr }`,
             // The runtime stream layout { rc, vt, reg, cls, st } — one struct
             // for all five stream classes; stream subclasses embed it.
-            `%ScrStream = type { i64, ptr, ptr, ptr, ptr }`,
+            `%ScrStream = type { ${this.sizeType}, ptr, ptr, ptr, ptr }`,
             // The catch-binding snapshot box { rc, kind, f64, b, payload,
             // retain_fn, release_fn, trace_fn } — caughtTest kind reads and
             // caughtNarrow payload extraction GEP through it (offsets match
             // scr_runtime.h's natural alignment: kind at 8, f64 at 16, b at 24,
             // payload at 32).
-            `%ScrCaught = type { i64, i32, double, i8, ptr, ptr, ptr, ptr }`,
+            `%ScrCaught = type { ${this.sizeType}, i32, double, i8, ptr, ptr, ptr, ptr }`,
             // ScrBytes { rc, len, elem(i32+pad), data, backing }. Indexed
             // typed-array access GEPs through this directly: the IR type already
             // fixes elem, so the hot path needs neither a runtime kind load nor
             // the generic scr_bytes_get/set call.
-            `%ScrBytes = type { i64, i64, i32, ptr, ptr }`,
+            `%ScrBytes = type { ${this.sizeType}, ${this.sizeType}, i32, ptr, ptr }`,
             // The capture box { rc, kind, obj_retain, obj_release, obj_trace,
             // slot } — TDZ reads peek the payload slot (offset 40) directly.
-            `%ScrBox = type { i64, i32, ptr, ptr, ptr, i64 }`,
+            `%ScrBox = type { ${this.sizeType}, i32, ptr, ptr, ptr, i64 }`,
             // The stack buffer of the emitted JSON serializers { data, len, cap }.
-            `%ScrJsonBuf = type { ptr, i64, i64, ptr, i64, i64 }`,
+            `%ScrJsonBuf = type { ptr, ${this.sizeType}, ${this.sizeType}, ptr, ${this.sizeType}, ${this.sizeType} }`,
             // The dynCheck error-path spine { parent, key, index } — the emitted
             // builders stack-allocate one per recursion level (dyn.ts).
-            `%ScrDynPath = type { ptr, ptr, i64 }`,
+            `%ScrDynPath = type { ptr, ptr, ${this.sizeType} }`,
+            `%ScrIslandModule = type { ptr, ptr, ${this.sizeType}, ${this.sizeType}, i32, ptr, ${this.sizeType}, ${this.sizeType} }`,
+            `%ScrIslandEdge = type { ptr, ptr, ptr, i32 }`,
         ];
         out.push(...shapes.typeDefs);
         out.push(...classShapes.typeDefs);
-        out.push(``, `@scr_error_vts = external global [5 x %ScrVt]`, `declare void @scr_init()`, `declare void @scr_lib_init(i32, ptr)`);
+        // Thread-instanced library state (abi.instance_per_thread): the
+        // program TU's mutable globals — module globals, run-once guards, the
+        // lazily-compiled regex literal caches — and the runtime globals its
+        // init stamps live in thread-local storage, matching the runtime
+        // objects compiled with -DSCR_THREAD_INSTANCES. Immutable interned
+        // data (string literals, unit arms, template arrays, vtables) stays
+        // shared.
+        const tl = this.mod.lib?.threadInstances === true ? "thread_local " : "";
+        out.push(``, `@scr_error_vts = external ${tl}global [5 x %ScrVt]`, `declare void @scr_init()`, `declare void @scr_lib_init(i32, ptr)`);
         for (const d of this.decls)
             out.push(d);
         out.push(``);
         for (const [text, lit] of this.literals) {
             // Immortal interned ScrStr: { rc = SIZE_MAX, len, cap = len, bytes\0 } —
             // the C emitter's static table, retain/release skip rc == SIZE_MAX.
-            out.push(`@${lit.sym} = internal global { i64, i64, i64, [${lit.len + 1} x i8] } ` +
-                `{ i64 -1, i64 ${lit.len}, i64 ${lit.len}, [${lit.len + 1} x i8] c"${llStrBytes(text)}" }`);
+            out.push(`@${lit.sym} = internal global { ${this.sizeType}, ${this.sizeType}, ${this.sizeType}, [${lit.len + 1} x i8] } ` +
+                `{ ${this.sizeType} -1, ${this.sizeType} ${lit.len}, ${this.sizeType} ${lit.len}, [${lit.len + 1} x i8] c"${llStrBytes(text)}" }`);
         }
         if (this.literals.size > 0)
             out.push(``);
@@ -1273,7 +1565,7 @@ class LlEmitter {
             // slot and RC entry points zero — retain/release/collector all skip
             // rc == SIZE_MAX, so these never join the RC audit or a trace walk.
             const [unionId, tag] = key.split(":");
-            out.push(`@${sym} = internal global %ScrUnion { i64 -1, i32 ${tag}, ptr null, ptr null, ptr null, i64 0 } ; ${unionId} unit arm`);
+            out.push(`@${sym} = internal global %ScrUnion { ${this.sizeType} -1, i32 ${tag}, ptr null, ptr null, ptr null, i64 0 } ; ${unionId} unit arm`);
         }
         if (this.unitInstances.size > 0)
             out.push(``);
@@ -1281,7 +1573,7 @@ class LlEmitter {
             // One immortal ScrRegex per (pattern, flags) literal, pointing at
             // the interned source/flags strings. The bc slot starts null (lazy
             // compile, cached by the runtime) — a mutable global, not constant.
-            out.push(`@${re.sym} = internal global %ScrRegex { i64 -1, ptr ${re.src}, ptr ${re.fl}, ptr null } ; ${key.replace(/\n/g, "\\n")}`);
+            out.push(`@${re.sym} = internal ${tl}global %ScrRegex { ${this.sizeType} -1, ptr ${re.src}, ptr ${re.fl}, ptr null } ; ${key.replace(/\n/g, "\\n")}`);
         }
         if (this.regexInstances.size > 0)
             out.push(``);
@@ -1291,7 +1583,7 @@ class LlEmitter {
             // over it (rc == SIZE_MAX, len == cap, SCR_ELEM_STR = 2, no REF
             // entry points). Reads retain immortal strings — a no-op.
             const n = inst.slots.length;
-            out.push(`@${inst.sym}_data = internal constant [${n} x ptr] [ ${inst.slots.map((s) => `ptr ${s}`).join(", ")} ]`, `@${inst.sym} = internal global %ScrArr { i64 -1, i64 ${n}, i64 ${n}, i32 2, ptr null, ptr null, ptr null, ptr @${inst.sym}_data }`);
+            out.push(`@${inst.sym}_data = internal constant [${n} x ptr] [ ${inst.slots.map((s) => `ptr ${s}`).join(", ")} ]`, `@${inst.sym} = internal global %ScrArr { ${this.sizeType} -1, ${this.sizeType} ${n}, ${this.sizeType} ${n}, i32 2, ptr null, ptr null, ptr null, ptr @${inst.sym}_data }`);
         }
         if (this.templateStringsInstances.size > 0)
             out.push(``);
@@ -1302,14 +1594,52 @@ class LlEmitter {
         }
         if (this.cstrs.size > 0)
             out.push(``);
+        if (usesIsland) {
+            const fmt = { esm: 0, cjs: 1, json: 2 };
+            const edgeKind = { any: 0, import: 1, require: 2 };
+            embedded.modules.forEach((m, i) => {
+                const stored = npmStored[i];
+                const key = Buffer.from(m.key, "utf8");
+                out.push(`@sc_npm_key_${i} = internal constant [${key.length + 1} x i8] c"${llBytes(key)}"`, `@sc_npm_src_${i} = internal constant [${stored.src.bytes.length + 1} x i8] c"${llBytes(stored.src.bytes)}"`);
+                if (stored.esm !== null) {
+                    out.push(`@sc_npm_esm_${i} = internal constant [${stored.esm.bytes.length + 1} x i8] c"${llBytes(stored.esm.bytes)}"`);
+                }
+            });
+            const moduleRows = embedded.modules.map((m, i) => {
+                const stored = npmStored[i];
+                const esm = stored.esm === null
+                    ? `ptr null, ${this.sizeType} 0, ${this.sizeType} 0`
+                    : `ptr @sc_npm_esm_${i}, ${this.sizeType} ${stored.esm.bytes.length}, ${this.sizeType} ${stored.esm.raw}`;
+                return `%ScrIslandModule { ptr @sc_npm_key_${i}, ptr @sc_npm_src_${i}, ` +
+                    `${this.sizeType} ${stored.src.bytes.length}, ${this.sizeType} ${stored.src.raw}, ` +
+                    `i32 ${fmt[m.format]}, ${esm} }`;
+            });
+            out.push(`@sc_npm_modules = internal constant [${moduleRows.length} x %ScrIslandModule] [ ${moduleRows.join(", ")} ]`);
+            embedded.edges.forEach((edge, i) => {
+                for (const [part, text] of [["from", edge.from], ["spec", edge.specifier], ["to", edge.to]]) {
+                    const bytes = Buffer.from(text, "utf8");
+                    out.push(`@sc_npm_edge_${i}_${part} = internal constant [${bytes.length + 1} x i8] c"${llBytes(bytes)}"`);
+                }
+            });
+            if (embedded.edges.length > 0) {
+                const edgeRows = embedded.edges.map((edge, i) => `%ScrIslandEdge { ptr @sc_npm_edge_${i}_from, ptr @sc_npm_edge_${i}_spec, ` +
+                    `ptr @sc_npm_edge_${i}_to, i32 ${edgeKind[edge.kind]} }`);
+                out.push(`@sc_npm_edges = internal constant [${edgeRows.length} x %ScrIslandEdge] [ ${edgeRows.join(", ")} ]`);
+            }
+            out.push(``);
+        }
+        out.push(...ffiCallbacks.globals);
+        if (ffiCallbacks.globals.length > 0)
+            out.push(``);
         for (const g of globals) {
             const ty = this.llType(g.type);
             const zero = ty === "double" ? f64Lit(0) : ty === "ptr" ? "null" : "false";
-            out.push(`@${mangleGlobal(g.id)} = internal global ${ty} ${zero} ; ${g.name}`);
+            out.push(`@${mangleGlobal(g.id)} = internal ${tl}global ${ty} ${zero} ; ${g.name}`);
         }
         if (globals.length > 0)
             out.push(``);
         out.push(...helpers);
+        out.push(...ffiCallbacks.defs);
         out.push(...shapes.defs);
         out.push(...classShapes.defs);
         out.push(...classObjDefs);
@@ -1327,22 +1657,22 @@ class LlEmitter {
         const stamps = [];
         for (const iv of this.errorIntervals) {
             for (const [field, value] of [[0, iv.pre], [1, iv.post]]) {
-                stamps.push(`  store i64 ${value}, ptr getelementptr inbounds ([5 x %ScrVt], ptr @scr_error_vts, i64 0, i64 ${iv.kind}, i32 ${field})${field === 1 ? ` ; ${iv.lib}` : ""}`);
+                stamps.push(`  store ${this.sizeType} ${value}, ptr getelementptr inbounds ([5 x %ScrVt], ptr @scr_error_vts, i64 0, i64 ${iv.kind}, i32 ${field})${field === 1 ? ` ; ${iv.lib}` : ""}`);
             }
         }
         if (this.emitterInterval !== null) {
             // The runtime emitter vtable's interval (emitterVtStampLines): bare
             // EventEmitter instances answer instanceof and dispatch dynamic
             // teardown under THIS module's preorder numbering.
-            out.push(`@scr_emitter_vt = external global %ScrVt`, ``);
-            stamps.push(`  store i64 ${this.emitterInterval.pre}, ptr getelementptr inbounds (%ScrVt, ptr @scr_emitter_vt, i64 0, i32 0)`, `  store i64 ${this.emitterInterval.post}, ptr getelementptr inbounds (%ScrVt, ptr @scr_emitter_vt, i64 0, i32 1) ; EventEmitter`);
+            out.push(`@scr_emitter_vt = external ${tl}global %ScrVt`, ``);
+            stamps.push(`  store ${this.sizeType} ${this.emitterInterval.pre}, ptr getelementptr inbounds (%ScrVt, ptr @scr_emitter_vt, i64 0, i32 0)`, `  store ${this.sizeType} ${this.emitterInterval.post}, ptr getelementptr inbounds (%ScrVt, ptr @scr_emitter_vt, i64 0, i32 1) ; EventEmitter`);
         }
         for (const iv of this.streamIntervals) {
             // The runtime stream vtables' intervals (streamVtStampLines) — the
             // emitter story: instanceof and dynamic teardown dispatch through
             // them.
             out.push(`@${iv.vt} = external global %ScrVt`);
-            stamps.push(`  store i64 ${iv.pre}, ptr getelementptr inbounds (%ScrVt, ptr @${iv.vt}, i64 0, i32 0)`, `  store i64 ${iv.post}, ptr getelementptr inbounds (%ScrVt, ptr @${iv.vt}, i64 0, i32 1) ; ${iv.lib}`);
+            stamps.push(`  store ${this.sizeType} ${iv.pre}, ptr getelementptr inbounds (%ScrVt, ptr @${iv.vt}, i64 0, i32 0)`, `  store ${this.sizeType} ${iv.post}, ptr getelementptr inbounds (%ScrVt, ptr @${iv.vt}, i64 0, i32 1) ; ${iv.lib}`);
         }
         if (this.streamIntervals.length > 0)
             out.push(``);
@@ -1366,17 +1696,28 @@ class LlEmitter {
             // LIBRARY mode: no @main — the profile-declared external
             // symbols instead, from the same IR facts the C emission consumes.
             out.push(...this.emitLibDefs(globals, globalReleaseLines, stamps));
-            out.push(`attributes #0 = { sanitize_address }`, ``);
+            out.push(`attributes #0 = { sanitize_address }`);
+            if (this.wasi)
+                out.push(`attributes #1 = { sanitize_address presplitcoroutine }`);
+            out.push(``);
             return out.join("\n");
         }
-        out.push(`define i32 @main(i32 %argc, ptr %argv) ${FN_ATTRS} {`, `entry:`, `  call void @scr_init()`, ...stamps, 
+        out.push(`define i32 @${this.wasi ? "__main_argc_argv" : "main"}(i32 %argc, ptr %argv) ${FN_ATTRS} {`, `entry:`, `  call void @scr_init()`, ...stamps, 
         // Event-surface programs (signal/exit listeners) fill the loop's
         // nullable event hooks before %main — scr_events.c links only when
         // this line is emitted (cc.ts gates on the same predicate).
         ...(usesEvents ? [`  call void @scr_events_install()`] : []), 
         // fs.watch programs fill the loop's watch hooks the same way —
         // scr_watch.c links only when this line is emitted.
-        ...(usesFsWatch ? [`  call void @scr_watch_install()`] : []), ...(snapshotsTlsCa ? [`  call void @scr_tls_ca_install()`] : []), ...(usesFetch ? [`  call void @scr_fetch_install()`] : []), ...(usesNet ? [`  call void @scr_net_install()`, `  call void @scr_net_dyn_install()`] : []), ...(usesHttp ? [`  call void @scr_http_dyn_install()`] : []), ...(usesStream ? [`  call void @scr_stream_install()`] : []), `  call void @scr_lib_init(i32 %argc, ptr %argv)`, ...(asyncEntry
+        ...(usesFsWatch ? [`  call void @scr_watch_install()`] : []), ...(snapshotsTlsCa ? [`  call void @scr_tls_ca_install()`] : []), ...(usesFetch ? [`  call void @scr_fetch_install()`] : []), ...(embedsZlib ? [`  call void @scr_zlib_island_install()`] : []), ...(embedsNet ? [`  call void @scr_net_island_install()`] : []), ...(usesNet ? [`  call void @scr_net_install()`, `  call void @scr_net_dyn_install()`] : []), ...(usesHttp ? [`  call void @scr_http_dyn_install()`] : []), ...(usesStream ? [`  call void @scr_stream_install()`] : []), `  call void @scr_lib_init(i32 %argc, ptr %argv)`, ...(usesIsland
+            ? [
+                ...(moduleEmbedsCompressedNpm(this.mod)
+                    ? [`  call void @scr_island_set_inflate(ptr @scr_zlib_inflate_exact)`]
+                    : []),
+                `  call void @scr_island_modules(ptr @sc_npm_modules, ${this.sizeType} ${embedded.modules.length}, ` +
+                    `ptr ${embedded.edges.length > 0 ? "@sc_npm_edges" : "null"}, ${this.sizeType} ${embedded.edges.length})`,
+            ]
+            : []), ...(asyncEntry
             ? [`  %top = call ptr @${mangleAsyncSpawn(this.mod.entry)}()`]
             : [`  call void @${mangleFunction(this.mod.entry)}()`]), 
         // Uncaught exception from top-level code: Node exits 1.
@@ -1447,18 +1788,20 @@ class LlEmitter {
                         `  %tla_pending = icmp eq i32 %tla_status, 13`,
                         `  br i1 %tla_pending, label %tla_stuck, label %tla_ok`,
                         `tla_stuck:`,
-                        ...exitListenerLines("xp"),
-                        ...topPendingReleases,
-                        `  ret i32 13`,
+                        ...topPendingExitLines(),
                         `tla_ok:`,
                     ]
                     : []),
             ]
-            : []), ...exitListenerLines("xn"), ...globalReleases, `  ret i32 0`, `}`, ``, 
+            : []), ...exitListenerLines("xn"), ...globalReleases, ...(usesNodeTest
+            ? [`  %test_exit = call i32 @scr_test_exit_code()`, `  ret i32 %test_exit`]
+            : usesIsland
+                ? [`  %island_exit = call i32 @scr_island_exit_code()`, `  ret i32 %island_exit`]
+                : [`  ret i32 0`]), `}`, ``, 
         // sanitize_address is inert under the plain pipeline; the sanitized
         // lane's -fsanitize=address link activates instrumentation over the
         // emitted functions too (the runtime TUs get theirs from clang).
-        `attributes #0 = { sanitize_address }`, ``);
+        `attributes #0 = { sanitize_address }`, ...(this.wasi ? [`attributes #1 = { sanitize_address presplitcoroutine }`] : []), ``);
         return out.join("\n");
     }
     /** LIBRARY mode: the profile-declared external definitions — the
@@ -1510,7 +1853,7 @@ class LlEmitter {
         });
         out.push(ovlCells.length === 0
             ? `@scr_library_trap_overlays = constant [1 x ptr] zeroinitializer`
-            : `@scr_library_trap_overlays = constant [${ovlCells.length} x ptr] [${ovlCells.join(", ")}]`, `@scr_library_trap_overlays_len = constant i64 ${lib.trapOverlays.length}`, ``);
+            : `@scr_library_trap_overlays = constant [${ovlCells.length} x ptr] [${ovlCells.join(", ")}]`, `@scr_library_trap_overlays_len = constant ${this.sizeType} ${lib.trapOverlays.length}`, ``);
         // The init entry: full deterministic reset-and-reevaluate. Program
         // globals release and zero first (run-once guards included), then the
         // runtime session reset, the error-vt interval stamps verbatim from
@@ -1596,13 +1939,13 @@ class LlEmitter {
                         args.push(`double %c${i}`);
                         break;
                     case "string":
-                        params.push(`ptr %a${i}_ptr`, `i64 %a${i}_len`);
-                        body.push(`  %c${i} = call ptr @scr_library_str_in(ptr %a${i}_ptr, i64 %a${i}_len)`);
+                        params.push(`ptr %a${i}_ptr`, `${this.sizeType} %a${i}_len`);
+                        body.push(`  %c${i} = call ptr @scr_library_str_in(ptr %a${i}_ptr, ${this.sizeType} %a${i}_len)`);
                         args.push(`ptr %c${i}`);
                         break;
                     case "bytes":
-                        params.push(`ptr %a${i}_ptr`, `i64 %a${i}_len`);
-                        body.push(`  %c${i} = call ptr @scr_library_bytes_in(ptr %a${i}_ptr, i64 %a${i}_len, ptr @sc_lib_bytes_trap_${e.symbol})`);
+                        params.push(`ptr %a${i}_ptr`, `${this.sizeType} %a${i}_len`);
+                        body.push(`  %c${i} = call ptr @scr_library_bytes_in(ptr %a${i}_ptr, ${this.sizeType} %a${i}_len, ptr @sc_lib_bytes_trap_${e.symbol})`);
                         args.push(`ptr %c${i}`);
                         break;
                 }
@@ -1676,7 +2019,7 @@ class LlEmitter {
             // scr_box_retain is a static inline (increment-unless-immortal, then
             // mark the cycle header live — every box is collector-headered);
             // emitted once with internal linkage, like the record retains.
-            defs.push(`define internal ptr @sc_retain_box(ptr %b) ${FN_ATTRS} {`, `entry:`, `  %rc = load i64, ptr %b`, `  %imm = icmp eq i64 %rc, -1`, `  br i1 %imm, label %done, label %inc`, `inc:`, `  %n = add i64 %rc, 1`, `  store i64 %n, ptr %b`, `  %colorp = getelementptr i8, ptr %b, i64 -16`, `  store i32 0, ptr %colorp ; mark live`, `  br label %done`, `done:`, `  ret ptr %b`, `}`, ``);
+            defs.push(`define internal ptr @sc_retain_box(ptr %b) ${FN_ATTRS} {`, `entry:`, `  %rc = load ${this.sizeType}, ptr %b`, `  %imm = icmp eq ${this.sizeType} %rc, -1`, `  br i1 %imm, label %done, label %inc`, `inc:`, `  %n = add ${this.sizeType} %rc, 1`, `  store ${this.sizeType} %n, ptr %b`, `  %colorp = getelementptr i8, ptr %b, ${this.sizeType} -${this.cycleColorOffset}`, `  store i32 0, ptr %colorp ; mark live`, `  br label %done`, `done:`, `  ret ptr %b`, `}`, ``);
         }
         // The declarations these helpers added must land in the extern block,
         // which already flushed — append here instead (LLVM is order-free).
@@ -1696,7 +2039,7 @@ class LlEmitter {
             // never the inner return type.
             const ret = fn.async === true || fn.generator !== undefined ? "ptr" : this.llType(fn.returnType);
             const call = `call ${ret} @${this.callTarget(name)}(${args})`;
-            out.push(`define internal ${ret} @${mangleWrapper(name)}(ptr %env${params.length ? ", " + params.join(", ") : ""}) ${FN_ATTRS} { ; ${name} as a value`, `entry:`, ret === "void" ? `  ${call}` : `  %r = ${call}`, ret === "void" ? `  ret void` : `  ret ${ret} %r`, `}`, `@${mangleFnClosure(name)} = internal global %ScrClosure { i64 -1, ptr @${mangleWrapper(name)}, i64 0, ptr null }`, ``);
+            out.push(`define internal ${ret} @${mangleWrapper(name)}(ptr %env${params.length ? ", " + params.join(", ") : ""}) ${FN_ATTRS} { ; ${name} as a value`, `entry:`, ret === "void" ? `  ${call}` : `  %r = ${call}`, ret === "void" ? `  ret void` : `  ret ${ret} %r`, `}`, `@${mangleFnClosure(name)} = internal global %ScrClosure { ${this.sizeType} -1, ptr @${mangleWrapper(name)}, ${this.sizeType} 0, ptr null }`, ``);
         }
         return out;
     }
@@ -1709,6 +2052,11 @@ class LlEmitter {
      * fiber eagerly to its first suspension and returns the promise). */
     emitAsyncScaffolding() {
         const out = [];
+        if (this.wasi) {
+            this.declare(`declare void @llvm.coro.resume(ptr)`);
+            this.declare(`declare void @llvm.coro.destroy(ptr)`);
+            out.push(`define void @scr_wasi_coro_resume(ptr %handle) ${FN_ATTRS} {`, `entry:`, `  call void @llvm.coro.resume(ptr %handle)`, `  ret void`, `}`, `define void @scr_wasi_coro_destroy(ptr %handle) ${FN_ATTRS} {`, `entry:`, `  call void @llvm.coro.destroy(ptr %handle)`, `  ret void`, `}`, ``);
+        }
         for (const fn of this.mod.functions) {
             if (fn.async !== true)
                 continue;
@@ -1716,9 +2064,9 @@ class LlEmitter {
             const lifted = fn.captures !== undefined;
             const fieldTys = [...(lifted ? ["ptr"] : []), ...fn.params.map((p) => this.llType(p.type))];
             out.push(`%${pack} = type { ${fieldTys.join(", ") || "i8"} } ; ${fn.name} args`);
-            const sizeOf = `ptrtoint (ptr getelementptr (%${pack}, ptr null, i32 1) to i64)`;
+            const sizeOf = `ptrtoint (ptr getelementptr (%${pack}, ptr null, i32 1) to ${this.sizeType})`;
             this.declare(`declare void @free(ptr)`);
-            this.declare(`declare ptr @malloc(i64)`);
+            this.declare(`declare ptr @malloc(${this.sizeType})`);
             this.declare(`declare zeroext i1 @scr_exc_pending()`);
             this.declare(`declare ptr @scr_fiber_promise(ptr)`);
             this.declare(`declare ptr @scr_async_spawn(ptr, ptr)`);
@@ -1738,41 +2086,49 @@ class LlEmitter {
             const retTy = this.llType(ret);
             const bodyCall = `call ${retTy} @${mangleFunction(fn.name)}(${loads.join(", ")})`;
             tr.push(retTy === "void" ? `  ${bodyCall}` : `  %r = ${bodyCall}`);
-            if (lifted) {
-                this.declare(`declare void @scr_closure_release(ptr)`);
-                tr.push(`  call void @scr_closure_release(ptr %a0)`);
+            if (this.wasi) {
+                // The coroutine body settles its own promise and owns the retained
+                // lifted environment until final suspension. Its initial call
+                // returns here at the first suspend (or final suspend).
+                tr.push(`  ret void`, `}`, ``);
             }
-            tr.push(`  %pend = call zeroext i1 @scr_exc_pending()`, `  br i1 %pend, label %thrown, label %clean`, `clean:`, `  %pr = call ptr @scr_fiber_promise(ptr %self)`);
-            switch (ret.kind) {
-                case "void":
-                    this.declare(`declare void @scr_promise_fulfill_void(ptr)`);
-                    tr.push(`  call void @scr_promise_fulfill_void(ptr %pr)`);
-                    break;
-                case "f64":
-                case "date":
-                    this.declare(`declare void @scr_promise_fulfill_f64(ptr, double)`);
-                    tr.push(`  call void @scr_promise_fulfill_f64(ptr %pr, double %r)`);
-                    break;
-                case "bool":
-                    this.declare(`declare void @scr_promise_fulfill_bool(ptr, i1 zeroext)`);
-                    tr.push(`  call void @scr_promise_fulfill_bool(ptr %pr, i1 %r)`);
-                    break;
-                case "string":
-                    this.declare(`declare void @scr_promise_fulfill_str(ptr, ptr)`);
-                    tr.push(`  call void @scr_promise_fulfill_str(ptr %pr, ptr %r) ; moves in`);
-                    break;
-                default: {
-                    const v = vAdapters(this, ret);
-                    this.declare(`declare void @scr_promise_fulfill_ref(ptr, ptr, ptr, ptr, ptr)`);
-                    tr.push(`  call void @scr_promise_fulfill_ref(ptr %pr, ptr %r, ptr ${v.retain}, ptr ${v.release}, ptr ${traceArg(this, ret)})`);
+            else {
+                if (lifted) {
+                    this.declare(`declare void @scr_closure_release(ptr)`);
+                    tr.push(`  call void @scr_closure_release(ptr %a0)`);
                 }
+                tr.push(`  %pend = call zeroext i1 @scr_exc_pending()`, `  br i1 %pend, label %thrown, label %clean`, `clean:`, `  %pr = call ptr @scr_fiber_promise(ptr %self)`);
+                switch (ret.kind) {
+                    case "void":
+                        this.declare(`declare void @scr_promise_fulfill_void(ptr)`);
+                        tr.push(`  call void @scr_promise_fulfill_void(ptr %pr)`);
+                        break;
+                    case "f64":
+                    case "date":
+                        this.declare(`declare void @scr_promise_fulfill_f64(ptr, double)`);
+                        tr.push(`  call void @scr_promise_fulfill_f64(ptr %pr, double %r)`);
+                        break;
+                    case "bool":
+                        this.declare(`declare void @scr_promise_fulfill_bool(ptr, i1 zeroext)`);
+                        tr.push(`  call void @scr_promise_fulfill_bool(ptr %pr, i1 %r)`);
+                        break;
+                    case "string":
+                        this.declare(`declare void @scr_promise_fulfill_str(ptr, ptr)`);
+                        tr.push(`  call void @scr_promise_fulfill_str(ptr %pr, ptr %r) ; moves in`);
+                        break;
+                    default: {
+                        const v = vAdapters(this, ret);
+                        this.declare(`declare void @scr_promise_fulfill_ref(ptr, ptr, ptr, ptr, ptr)`);
+                        tr.push(`  call void @scr_promise_fulfill_ref(ptr %pr, ptr %r, ptr ${v.retain}, ptr ${v.release}, ptr ${traceArg(this, ret)})`);
+                    }
+                }
+                tr.push(`  ret void`, `thrown:`);
+                if (ret.kind !== "void" && isRefCounted(ret)) {
+                    // An escaping throw means %r is the never-read dummy (NULL).
+                    tr.push(`  call void ${releaseSym(this, ret)}(ptr %r)`);
+                }
+                tr.push(`  ret void`, `}`, ``);
             }
-            tr.push(`  ret void`, `thrown:`);
-            if (ret.kind !== "void" && isRefCounted(ret)) {
-                // An escaping throw means %r is the never-read dummy (NULL).
-                tr.push(`  call void ${releaseSym(this, ret)}(ptr %r)`);
-            }
-            tr.push(`  ret void`, `}`, ``);
             out.push(...tr);
             // Spawn wrapper: pack the args (+1 moves in), spawn the fiber.
             const params = fieldTys.map((ty, i) => `${ty} %a${i}`);
@@ -1799,7 +2155,7 @@ class LlEmitter {
                         `cache_miss:`,
                     ]
                     : []),
-                `  %ap = call ptr @malloc(i64 ${sizeOf})`,
+                `  %ap = call ptr @malloc(${this.sizeType} ${sizeOf})`,
                 `  %isnull = icmp eq ptr %ap, null`,
                 `  br i1 %isnull, label %oom, label %ok`,
                 `oom:`,
@@ -1867,9 +2223,9 @@ class LlEmitter {
             const lifted = fn.captures !== undefined;
             const fieldTys = [...(lifted ? ["ptr"] : []), ...fn.params.map((p) => this.llType(p.type))];
             out.push(`%${pack} = type { ${fieldTys.join(", ") || "i8"} } ; ${fn.name} args`);
-            const sizeOf = `ptrtoint (ptr getelementptr (%${pack}, ptr null, i32 1) to i64)`;
+            const sizeOf = `ptrtoint (ptr getelementptr (%${pack}, ptr null, i32 1) to ${this.sizeType})`;
             this.declare(`declare void @free(ptr)`);
-            this.declare(`declare ptr @malloc(i64)`);
+            this.declare(`declare ptr @malloc(${this.sizeType})`);
             this.declare(`declare zeroext i1 @scr_exc_pending()`);
             this.declare(`declare zeroext i1 @scr_exc_genret_pending()`);
             this.declare(`declare void @scr_exc_clear()`);
@@ -1891,7 +2247,7 @@ class LlEmitter {
             const retTy = this.llType(ret);
             const bodyCall = `call ${retTy} @${mangleFunction(fn.name)}(${loads.join(", ")})`;
             tr.push(retTy === "void" ? `  ${bodyCall}` : `  %r = ${bodyCall}`);
-            if (lifted) {
+            if (lifted && !this.wasi) {
                 this.declare(`declare void @scr_closure_release(ptr)`);
                 tr.push(`  call void @scr_closure_release(ptr %a0)`);
             }
@@ -1899,31 +2255,36 @@ class LlEmitter {
             // with the NONE slot — JS's undefined done-value. A GENRET unwind
             // consumes the sentinel and promotes the parked .return value; a
             // real exception stays pending (the consumer-side resume moves it).
-            tr.push(`  %g = call ptr @scr_gen_of_fiber(ptr %self)`, `  %pend = call zeroext i1 @scr_exc_pending()`, `  br i1 %pend, label %thrown, label %clean`, `clean:`);
-            switch (ret.kind) {
-                case "void":
-                    tr.push(`  br label %done ; void body: the done value is undefined (NONE)`);
-                    break;
-                case "f64":
-                case "date":
-                    this.declare(`declare void @scr_gen_out_f64(ptr, double)`);
-                    tr.push(`  call void @scr_gen_out_f64(ptr %g, double %r)`, `  br label %done`);
-                    break;
-                case "bool":
-                    this.declare(`declare void @scr_gen_out_bool(ptr, i1 zeroext)`);
-                    tr.push(`  call void @scr_gen_out_bool(ptr %g, i1 %r)`, `  br label %done`);
-                    break;
-                default: {
-                    const v = vAdapters(this, ret);
-                    this.declare(`declare void @scr_gen_out_ref(ptr, ptr, ptr)`);
-                    tr.push(`  call void @scr_gen_out_ref(ptr %g, ptr %r, ptr ${v.release})`, `  br label %done`);
-                }
+            if (this.wasi) {
+                tr.push(`  ret void`, `}`, ``);
             }
-            tr.push(`thrown:`, `  %genret = call zeroext i1 @scr_exc_genret_pending()`, `  br i1 %genret, label %promote, label %dropdummy`, `promote:`, `  call void @scr_exc_clear()`, `  call void @scr_gen_ret_to_out(ptr %g)`, `  br label %dropdummy`, `dropdummy:`);
-            if (ret.kind !== "void" && isRefCounted(ret)) {
-                tr.push(`  call void ${releaseSym(this, ret)}(ptr %r) ; unwound: the never-read dummy`);
+            else {
+                tr.push(`  %g = call ptr @scr_gen_of_fiber(ptr %self)`, `  %pend = call zeroext i1 @scr_exc_pending()`, `  br i1 %pend, label %thrown, label %clean`, `clean:`);
+                switch (ret.kind) {
+                    case "void":
+                        tr.push(`  br label %done ; void body: the done value is undefined (NONE)`);
+                        break;
+                    case "f64":
+                    case "date":
+                        this.declare(`declare void @scr_gen_out_f64(ptr, double)`);
+                        tr.push(`  call void @scr_gen_out_f64(ptr %g, double %r)`, `  br label %done`);
+                        break;
+                    case "bool":
+                        this.declare(`declare void @scr_gen_out_bool(ptr, i1 zeroext)`);
+                        tr.push(`  call void @scr_gen_out_bool(ptr %g, i1 %r)`, `  br label %done`);
+                        break;
+                    default: {
+                        const v = vAdapters(this, ret);
+                        this.declare(`declare void @scr_gen_out_ref(ptr, ptr, ptr)`);
+                        tr.push(`  call void @scr_gen_out_ref(ptr %g, ptr %r, ptr ${v.release})`, `  br label %done`);
+                    }
+                }
+                tr.push(`thrown:`, `  %genret = call zeroext i1 @scr_exc_genret_pending()`, `  br i1 %genret, label %promote, label %dropdummy`, `promote:`, `  call void @scr_exc_clear()`, `  call void @scr_gen_ret_to_out(ptr %g)`, `  br label %dropdummy`, `dropdummy:`);
+                if (ret.kind !== "void" && isRefCounted(ret)) {
+                    tr.push(`  call void ${releaseSym(this, ret)}(ptr %r) ; unwound: the never-read dummy`);
+                }
+                tr.push(`  br label %done`, `done:`, `  ret void`, `}`, ``);
             }
-            tr.push(`  br label %done`, `done:`, `  ret void`, `}`, ``);
             out.push(...tr);
             // The never-started teardown: drop the packed (+1) arguments.
             const dr = [
@@ -1952,7 +2313,7 @@ class LlEmitter {
             const sp = [
                 `define internal ptr @${mangleGenSpawn(fn.name)}(${params.join(", ")}) ${FN_ATTRS} { ; gen spawn ${fn.name}`,
                 `entry:`,
-                `  %ap = call ptr @malloc(i64 ${sizeOf})`,
+                `  %ap = call ptr @malloc(${this.sizeType} ${sizeOf})`,
                 `  %isnull = icmp eq ptr %ap, null`,
                 `  br i1 %isnull, label %oom, label %ok`,
                 `oom:`,
@@ -2124,6 +2485,10 @@ class LlEmitter {
             return;
         }
         this.releaseForJump(0, 0);
+        if (this.currentWasiCoro !== null) {
+            this.B.terminate(`br label %${this.currentWasiCoro.finalLabel}`);
+            return;
+        }
         const t = this.currentReturnType;
         if (t.kind === "void")
             this.B.terminate("ret void");
@@ -2207,8 +2572,8 @@ class LlEmitter {
                 const len = B.tmp();
                 const t = B.tmp();
                 B.line(`${lenp} = getelementptr inbounds %ScrStr, ptr ${v.name}, i64 0, i32 1`);
-                B.line(`${len} = load i64, ptr ${lenp}`);
-                B.line(`${t} = icmp ne i64 ${len}, 0`);
+                B.line(`${len} = load ${this.sizeType}, ptr ${lenp}`);
+                B.line(`${t} = icmp ne ${this.sizeType} ${len}, 0`);
                 return t;
             }
             case "date":
@@ -2303,8 +2668,8 @@ class LlEmitter {
                             const len = B.tmp();
                             const t = B.tmp();
                             B.line(`${lenp} = getelementptr inbounds %ScrStr, ptr ${p}, i64 0, i32 1`);
-                            B.line(`${len} = load i64, ptr ${lenp}`);
-                            B.line(`${t} = icmp ne i64 ${len}, 0`);
+                            B.line(`${len} = load ${this.sizeType}, ptr ${lenp}`);
+                            B.line(`${t} = icmp ne ${this.sizeType} ${len}, 0`);
                             B.line(`store i1 ${t}, ptr ${slot}`);
                             break;
                         }
@@ -2459,7 +2824,7 @@ class LlEmitter {
         B.line(`${vtp} = getelementptr inbounds %${classStructSym(staticClassName)}, ptr ${objName}, i64 0, i32 1`);
         B.line(`${vt} = load ptr, ptr ${vtp}`);
         B.line(`${prep} = getelementptr inbounds %ScrVt, ptr ${vt}, i64 0, i32 0`);
-        B.line(`${pre} = load i64, ptr ${prep}`);
+        B.line(`${pre} = load ${this.sizeType}, ptr ${prep}`);
         return pre;
     }
     /** The class object's static symbol (classes as values), registering it
@@ -2652,6 +3017,93 @@ class LlEmitter {
             return mangleGenSpawn(fnName);
         return mangleFunction(fnName);
     }
+    /** Queue the current wasm coroutine and suspend it. The runtime decides
+     * whether the promise waiter list or the ready FIFO owns the continuation;
+     * LLVM keeps all live locals in the coroutine frame. */
+    emitWasiSuspend(promise) {
+        const coro = this.currentWasiCoro;
+        if (coro === null)
+            throw new Error("llvm emitter bug: wasm suspension outside async body");
+        if (promise === null) {
+            this.declare(`declare void @scr_wasi_await_hop_prepare(ptr)`);
+            this.B.line(`call void @scr_wasi_await_hop_prepare(ptr ${coro.self})`);
+        }
+        else {
+            this.declare(`declare void @scr_wasi_await_prepare(ptr, ptr)`);
+            this.B.line(`call void @scr_wasi_await_prepare(ptr ${coro.self}, ptr ${promise})`);
+        }
+        this.emitWasiSuspendPrepared();
+    }
+    /** Suspend after a target-specific runtime helper already queued the
+     * continuation (used by module awaits, which skip the hop when settled). */
+    emitWasiSuspendPrepared() {
+        const coro = this.currentWasiCoro;
+        if (coro === null)
+            throw new Error("llvm emitter bug: wasm suspension outside async body");
+        const save = this.B.tmp();
+        const state = this.B.tmp();
+        const resume = this.B.newLabel("coro.resume");
+        this.B.line(`${save} = call token @llvm.coro.save(ptr ${coro.handle})`);
+        this.B.line(`${state} = call i8 @llvm.coro.suspend(token ${save}, i1 false)`);
+        this.B.terminate(`switch i8 ${state}, label %${coro.suspendLabel} [ i8 0, label %${resume} i8 1, label %${coro.cleanupLabel} ]`);
+        this.B.startBlock(resume);
+    }
+    /** Move a clean async return value into the current fiber's promise. */
+    emitWasiFulfill(v) {
+        const coro = this.currentWasiCoro;
+        if (coro === null)
+            throw new Error("llvm emitter bug: wasm fulfillment outside async body");
+        const ret = this.currentReturnType;
+        if (coro.kind === "generator") {
+            this.declare(`declare ptr @scr_gen_of_fiber(ptr)`);
+            const gen = this.B.tmp();
+            this.B.line(`${gen} = call ptr @scr_gen_of_fiber(ptr ${coro.self})`);
+            switch (ret.kind) {
+                case "void":
+                    return;
+                case "f64":
+                case "date":
+                    this.declare(`declare void @scr_gen_out_f64(ptr, double)`);
+                    this.B.line(`call void @scr_gen_out_f64(ptr ${gen}, double ${v.name})`);
+                    return;
+                case "bool":
+                    this.declare(`declare void @scr_gen_out_bool(ptr, i1 zeroext)`);
+                    this.B.line(`call void @scr_gen_out_bool(ptr ${gen}, i1 ${v.name})`);
+                    return;
+                default:
+                    this.declare(`declare void @scr_gen_out_ref(ptr, ptr, ptr)`);
+                    this.B.line(`call void @scr_gen_out_ref(ptr ${gen}, ptr ${v.name}, ptr ${vAdapters(this, ret).release})`);
+                    return;
+            }
+        }
+        this.declare(`declare ptr @scr_fiber_promise(ptr)`);
+        const pr = this.B.tmp();
+        this.B.line(`${pr} = call ptr @scr_fiber_promise(ptr ${coro.self})`);
+        switch (ret.kind) {
+            case "void":
+                this.declare(`declare void @scr_promise_fulfill_void(ptr)`);
+                this.B.line(`call void @scr_promise_fulfill_void(ptr ${pr})`);
+                break;
+            case "f64":
+            case "date":
+                this.declare(`declare void @scr_promise_fulfill_f64(ptr, double)`);
+                this.B.line(`call void @scr_promise_fulfill_f64(ptr ${pr}, double ${v.name})`);
+                break;
+            case "bool":
+                this.declare(`declare void @scr_promise_fulfill_bool(ptr, i1 zeroext)`);
+                this.B.line(`call void @scr_promise_fulfill_bool(ptr ${pr}, i1 ${v.name})`);
+                break;
+            case "string":
+                this.declare(`declare void @scr_promise_fulfill_str(ptr, ptr)`);
+                this.B.line(`call void @scr_promise_fulfill_str(ptr ${pr}, ptr ${v.name}) ; moves in`);
+                break;
+            default: {
+                const rc = vAdapters(this, ret);
+                this.declare(`declare void @scr_promise_fulfill_ref(ptr, ptr, ptr, ptr, ptr)`);
+                this.B.line(`call void @scr_promise_fulfill_ref(ptr ${pr}, ptr ${v.name}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${traceArg(this, ret)})`);
+            }
+        }
+    }
     emitFunction(fn) {
         const B = new BlockBuilder();
         this.B = B;
@@ -2666,7 +3118,41 @@ class LlEmitter {
         this.tryStack = [];
         this.currentReturnType = fn.returnType;
         this.currentGenerator = fn.generator ?? null;
+        this.currentWasiCoro = null;
         this.logArgSlots = 0;
+        if (this.wasi && (fn.async === true || fn.generator !== undefined)) {
+            this.declare(`declare token @llvm.coro.id(i32, ptr, ptr, ptr)`);
+            this.declare(`declare ${this.sizeType} @llvm.coro.size.${this.sizeType}()`);
+            this.declare(`declare ptr @llvm.coro.begin(token, ptr)`);
+            this.declare(`declare token @llvm.coro.save(ptr)`);
+            this.declare(`declare i8 @llvm.coro.suspend(token, i1)`);
+            this.declare(`declare ptr @llvm.coro.free(token, ptr)`);
+            this.declare(`declare i1 @llvm.coro.end(ptr, i1, token)`);
+            this.declare(`declare ptr @malloc(${this.sizeType})`);
+            this.declare(`declare void @free(ptr)`);
+            this.declare(`declare void @scr_wasi_coro_started(ptr)`);
+            this.declare(`declare ptr @scr_fiber_self()`);
+            const id = B.tmp();
+            const size = B.tmp();
+            const mem = B.tmp();
+            const handle = B.tmp();
+            const self = B.tmp();
+            B.line(`${id} = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)`);
+            B.line(`${size} = call ${this.sizeType} @llvm.coro.size.${this.sizeType}()`);
+            B.line(`${mem} = call ptr @malloc(${this.sizeType} ${size})`);
+            B.line(`${handle} = call ptr @llvm.coro.begin(token ${id}, ptr ${mem})`);
+            B.line(`call void @scr_wasi_coro_started(ptr ${handle})`);
+            B.line(`${self} = call ptr @scr_fiber_self()`);
+            this.currentWasiCoro = {
+                kind: fn.async === true ? "async" : "generator",
+                id,
+                handle,
+                self,
+                finalLabel: B.newLabel("coro.final"),
+                cleanupLabel: B.newLabel("coro.cleanup"),
+                suspendLabel: B.newLabel("coro.suspend"),
+            };
+        }
         const paramIds = new Set(fn.params.map((p) => p.localId));
         for (const local of fn.locals) {
             // Boxed locals' slots hold their capture BOX (a ptr); captured
@@ -2688,9 +3174,11 @@ class LlEmitter {
         // Captured bindings come in through the environment — borrowed for the
         // whole call (the closure owns them): bound here, never released here.
         (fn.captures ?? []).forEach((c, i) => {
+            const caps = B.tmp();
             const p = B.tmp();
             const box = B.tmp();
-            B.line(`${p} = getelementptr inbounds i8, ptr %sc_env, i64 ${32 + 8 * i} ; caps[${i}]`);
+            B.line(`${caps} = getelementptr inbounds %ScrClosure, ptr %sc_env, i64 1 ; caps`);
+            B.line(`${p} = getelementptr inbounds ptr, ptr ${caps}, ${this.sizeType} ${i} ; caps[${i}]`);
             B.line(`${box} = load ptr, ptr ${p}`);
             B.line(`store ptr ${box}, ptr %${mangleLocal(c.localId)} ; captured ${c.name}`);
         });
@@ -2720,9 +3208,51 @@ class LlEmitter {
         // whose unwind released everything down to depth 0).
         if (fn.returnType.kind === "void" && !B.isTerminated()) {
             this.releaseScope(this.scopes[0]);
-            B.terminate("ret void");
+            if (this.currentWasiCoro !== null) {
+                this.emitWasiFulfill(null);
+                B.terminate(`br label %${this.currentWasiCoro.finalLabel}`);
+            }
+            else {
+                B.terminate("ret void");
+            }
         }
         this.scopes.pop();
+        const coro = this.currentWasiCoro;
+        if (coro !== null) {
+            B.startBlock(coro.finalLabel);
+            if (fn.captures !== undefined) {
+                this.declare(`declare void @scr_closure_release(ptr)`);
+                B.line(`call void @scr_closure_release(ptr %sc_env)`);
+            }
+            if (coro.kind === "generator") {
+                this.declare(`declare void @scr_wasi_gen_finish(ptr)`);
+                B.line(`call void @scr_wasi_gen_finish(ptr ${coro.self})`);
+            }
+            else {
+                this.declare(`declare void @scr_wasi_async_finish(ptr)`);
+                B.line(`call void @scr_wasi_async_finish(ptr ${coro.self})`);
+            }
+            const finalState = B.tmp();
+            B.line(`${finalState} = call i8 @llvm.coro.suspend(token none, i1 true)`);
+            B.terminate(`switch i8 ${finalState}, label %${coro.suspendLabel} [ i8 1, label %${coro.cleanupLabel} ]`);
+            B.startBlock(coro.cleanupLabel);
+            const frame = B.tmp();
+            B.line(`${frame} = call ptr @llvm.coro.free(token ${coro.id}, ptr ${coro.handle})`);
+            B.line(`call void @free(ptr ${frame})`);
+            B.br(coro.suspendLabel);
+            B.startBlock(coro.suspendLabel);
+            const ended = B.tmp();
+            B.line(`${ended} = call i1 @llvm.coro.end(ptr ${coro.handle}, i1 false, token none)`);
+            const ret = this.llType(fn.returnType);
+            if (ret === "void")
+                B.terminate(`ret void`);
+            else if (ret === "double")
+                B.terminate(`ret double ${f64Lit(0)}`);
+            else if (ret === "i1")
+                B.terminate(`ret i1 false`);
+            else
+                B.terminate(`ret ptr null`);
+        }
         if (this.logArgSlots > 0) {
             B.entryAllocas.push(`%logargs = alloca [${this.logArgSlots} x %ScrLogArg]`);
         }
@@ -2731,7 +3261,8 @@ class LlEmitter {
         if (fn.captures !== undefined)
             params.unshift("ptr %sc_env");
         const ret = this.llType(fn.returnType);
-        return `define internal ${ret} @${mangleFunction(fn.name)}(${params.join(", ")}) ${FN_ATTRS} { ; ${fn.name}\n${B.render()}\n}`;
+        const attrs = coro !== null ? "#1" : FN_ATTRS;
+        return `define internal ${ret} @${mangleFunction(fn.name)}(${params.join(", ")}) ${attrs} { ; ${fn.name}\n${B.render()}\n}`;
     }
     // ── statements ──────────────────────────────────────────────────────────
     emitStmts(stmts) {
@@ -2960,7 +3491,7 @@ class LlEmitter {
                         B.line(`${kp} = getelementptr inbounds %ScrDynPath, ptr ${pathSlot}, i64 0, i32 1`);
                         B.line(`store ptr ${this.cstr(f.name)}, ptr ${kp}`);
                         B.line(`${ip} = getelementptr inbounds %ScrDynPath, ptr ${pathSlot}, i64 0, i32 2`);
-                        B.line(`store i64 0, ptr ${ip}`);
+                        B.line(`store ${this.sizeType} 0, ptr ${ip}`);
                         const helper = this.dyn.dynCheckHelper(f.type);
                         const fty = this.llType(f.type);
                         const nv = B.tmp();
@@ -3129,8 +3660,8 @@ class LlEmitter {
                 let integerSlot = null;
                 if (integerLoop) {
                     integerSlot = B.slot();
-                    B.entryAllocas.push(`${integerSlot} = alloca i64 ; integer induction ${this.currentLocals.get(integerLoop.localId).name}`);
-                    B.line(`store i64 0, ptr ${integerSlot}`);
+                    B.entryAllocas.push(`${integerSlot} = alloca ${this.sizeType} ; integer induction ${this.currentLocals.get(integerLoop.localId).name}`);
+                    B.line(`store ${this.sizeType} 0, ptr ${integerSlot}`);
                     this.integerLoopBindings.set(integerLoop.localId, integerSlot);
                 }
                 else if (s.init) {
@@ -3156,9 +3687,9 @@ class LlEmitter {
                     const index = B.tmp();
                     const inBounds = B.tmp();
                     B.line(`${lenPtr} = getelementptr inbounds %ScrBytes, ptr ${receiver.name}, i64 0, i32 1`);
-                    B.line(`${len} = load i64, ptr ${lenPtr}`);
-                    B.line(`${index} = load i64, ptr ${integerSlot}`);
-                    B.line(`${inBounds} = icmp ult i64 ${index}, ${len}`);
+                    B.line(`${len} = load ${this.sizeType}, ptr ${lenPtr}`);
+                    B.line(`${index} = load ${this.sizeType}, ptr ${integerSlot}`);
+                    B.line(`${inBounds} = icmp ult ${this.sizeType} ${index}, ${len}`);
                     B.condBr(inBounds, lb, le);
                 }
                 else if (s.cond)
@@ -3196,9 +3727,9 @@ class LlEmitter {
                     if (integerLoop && integerSlot) {
                         const old = B.tmp();
                         const next = B.tmp();
-                        B.line(`${old} = load i64, ptr ${integerSlot}`);
-                        B.line(`${next} = add nuw i64 ${old}, 1`);
-                        B.line(`store i64 ${next}, ptr ${integerSlot}`);
+                        B.line(`${old} = load ${this.sizeType}, ptr ${integerSlot}`);
+                        B.line(`${next} = add nuw ${this.sizeType} ${old}, 1`);
+                        B.line(`store ${this.sizeType} ${next}, ptr ${integerSlot}`);
                     }
                     else if (s.update)
                         this.emitStmt(s.update);
@@ -3376,10 +3907,16 @@ class LlEmitter {
                 else {
                     this.releaseForJump(0, 0);
                 }
-                if (v === null)
-                    B.terminate("ret void");
-                else
-                    B.terminate(`ret ${this.llType(s.value.type)} ${v.name}`);
+                if (!B.isTerminated()) {
+                    if (this.currentWasiCoro !== null) {
+                        this.emitWasiFulfill(v);
+                        B.terminate(`br label %${this.currentWasiCoro.finalLabel}`);
+                    }
+                    else if (v === null)
+                        B.terminate("ret void");
+                    else
+                        B.terminate(`ret ${this.llType(s.value.type)} ${v.name}`);
+                }
                 break;
             }
             case "throw": {
@@ -3408,8 +3945,8 @@ class LlEmitter {
                 // the construct (message) with the SC code stamped on `code`,
                 // then unwind exactly like `throw`. SCR_ERR_ERROR = 0.
                 const bytes = Buffer.byteLength(s.message, "utf8");
-                this.declare(`declare void @scr_throw_error_msg_code(i32, ptr, i64, ptr)`);
-                B.line(`call void @scr_throw_error_msg_code(i32 0, ptr ${this.cstr(s.message)}, i64 ${bytes}, ptr ${this.cstr(s.code)})`);
+                this.declare(`declare void @scr_throw_error_msg_code(i32, ptr, ${this.sizeType}, ptr)`);
+                B.line(`call void @scr_throw_error_msg_code(i32 0, ptr ${this.cstr(s.message)}, ${this.sizeType} ${bytes}, ptr ${this.cstr(s.code)})`);
                 this.emitUnwind();
                 break;
             }
@@ -3689,8 +4226,8 @@ class LlEmitter {
                 if (integerSlot !== undefined) {
                     const integer = B.tmp();
                     const number = B.tmp();
-                    B.line(`${integer} = load i64, ptr ${integerSlot}`);
-                    B.line(`${number} = uitofp i64 ${integer} to double`);
+                    B.line(`${integer} = load ${this.sizeType}, ptr ${integerSlot}`);
+                    B.line(`${number} = uitofp ${this.sizeType} ${integer} to double`);
                     return { name: number, type: e.type };
                 }
                 const b = this.binding(e.localId);
@@ -4817,15 +5354,17 @@ class LlEmitter {
                 }
                 // Lifted async lambdas enter through their spawn wrapper (which
                 // takes sc_env first, like every lifted function).
-                this.declare(`declare ptr @scr_closure_new(ptr, i64)`);
+                this.declare(`declare ptr @scr_closure_new(ptr, ${this.sizeType})`);
                 const c = B.tmp();
-                B.line(`${c} = call ptr @scr_closure_new(ptr @${this.callTarget(e.fnName)}, i64 ${e.captures.length})`);
+                B.line(`${c} = call ptr @scr_closure_new(ptr @${this.callTarget(e.fnName)}, ${this.sizeType} ${e.captures.length})`);
                 const out = this.own({ name: c, type: e.type });
                 e.captures.forEach((localId, i) => {
                     const box = this.loadBox(`%${mangleLocal(localId)}`);
                     const retained = this.retainBox(box);
+                    const caps = B.tmp();
                     const capp = B.tmp();
-                    B.line(`${capp} = getelementptr inbounds i8, ptr ${c}, i64 ${32 + 8 * i} ; caps[${i}]`);
+                    B.line(`${caps} = getelementptr inbounds %ScrClosure, ptr ${c}, i64 1 ; caps`);
+                    B.line(`${capp} = getelementptr inbounds ptr, ptr ${caps}, ${this.sizeType} ${i} ; caps[${i}]`);
                     B.line(`store ptr ${retained}, ptr ${capp}`);
                 });
                 return out;
@@ -4904,11 +5443,49 @@ class LlEmitter {
                 if (!entry)
                     throw new Error(`llvm emitter bug: unknown FFI import ${e.import}`);
                 const args = e.args.map((arg) => this.emitExpr(arg));
+                const sourceArgs = new Map();
+                const callbackArgs = new Map();
+                let sourceIndex = 0;
+                entry.params.forEach((param, abiIndex) => {
+                    if (isFfiContextParam(param))
+                        return;
+                    const arg = args[sourceIndex++];
+                    sourceArgs.set(abiIndex, arg);
+                    if (isFfiCallbackParam(param))
+                        callbackArgs.set(param.callback.id, arg);
+                });
+                const rawContexts = [];
+                for (const param of entry.params) {
+                    if (!isFfiCallbackParam(param))
+                        continue;
+                    const adapter = this.ffiCallbackAdapter(entry.name, param.callback.id);
+                    if (adapter.tls === null)
+                        continue;
+                    const callback = callbackArgs.get(param.callback.id);
+                    const previous = B.tmp();
+                    B.line(`${previous} = load ptr, ptr @${adapter.tls}`);
+                    B.line(`store ptr ${callback.name}, ptr @${adapter.tls}`);
+                    rawContexts.push({ tls: adapter.tls, previous });
+                }
                 const nativeArgs = [];
                 const nativeParamTypes = [];
-                entry.params.forEach((cls, i) => {
-                    const arg = args[i];
-                    switch (cls) {
+                entry.params.forEach((param, i) => {
+                    if (isFfiCallbackParam(param)) {
+                        const adapter = this.ffiCallbackAdapter(entry.name, param.callback.id);
+                        nativeParamTypes.push("ptr");
+                        nativeArgs.push(`ptr @${adapter.symbol}`);
+                        return;
+                    }
+                    if (isFfiContextParam(param)) {
+                        const callback = callbackArgs.get(param.context);
+                        if (!callback)
+                            throw new Error(`llvm emitter bug: FFI context '${param.context}' has no callback arg`);
+                        nativeParamTypes.push("ptr");
+                        nativeArgs.push(`ptr ${callback.name}`);
+                        return;
+                    }
+                    const arg = sourceArgs.get(i);
+                    switch (param) {
                         case "f64":
                             nativeParamTypes.push("double");
                             nativeArgs.push(`double ${arg.name}`);
@@ -4927,7 +5504,7 @@ class LlEmitter {
                             const asU32 = B.tmp();
                             B.line(`${asDouble} = call double @scr_bit_ushr(double ${arg.name}, double ${f64Lit(0)})`);
                             B.line(`${asU32} = fptoui double ${asDouble} to i32`);
-                            if (cls === "u8") {
+                            if (param === "u8") {
                                 const asU8 = B.tmp();
                                 B.line(`${asU8} = trunc i32 ${asU32} to i8`);
                                 nativeParamTypes.push("i8");
@@ -4975,29 +5552,47 @@ class LlEmitter {
                         }
                     }
                 });
-                const retTy = entry.returns === "f64" ? "double"
-                    : entry.returns === "bool" || entry.returns === "u8" ? "i8"
-                        : entry.returns === "u32" || entry.returns === "i32" ? "i32"
-                            : "void";
+                const retTy = ffiNativeTypeLl(entry.returns);
                 this.declare(`declare ${retTy} @${entry.symbol}(${nativeParamTypes.join(", ")})`);
                 const call = `call ${retTy} @${entry.symbol}(${nativeArgs.join(", ")})`;
+                const restoreRawContexts = () => {
+                    for (let i = rawContexts.length - 1; i >= 0; i--) {
+                        const saved = rawContexts[i];
+                        B.line(`store ptr ${saved.previous}, ptr @${saved.tls}`);
+                    }
+                };
+                const callbacksMayThrow = callbackArgs.size > 0;
                 if (entry.returns === "void") {
                     B.line(call);
+                    restoreRawContexts();
+                    if (callbacksMayThrow)
+                        this.emitPendingCheck();
                     return { name: "", type: e.type };
                 }
                 const raw = B.tmp();
                 B.line(`${raw} = ${call}`);
-                if (entry.returns === "f64")
-                    return { name: raw, type: e.type };
+                restoreRawContexts();
+                if (entry.returns === "f64") {
+                    const result = { name: raw, type: e.type };
+                    if (callbacksMayThrow)
+                        this.emitPendingCheck();
+                    return result;
+                }
                 if (entry.returns === "bool") {
                     const value = B.tmp();
                     B.line(`${value} = icmp ne i8 ${raw}, 0`);
-                    return { name: value, type: e.type };
+                    const result = { name: value, type: e.type };
+                    if (callbacksMayThrow)
+                        this.emitPendingCheck();
+                    return result;
                 }
                 const value = B.tmp();
                 const op = entry.returns === "i32" ? "sitofp" : "uitofp";
                 B.line(`${value} = ${op} ${retTy} ${raw} to double`);
-                return { name: value, type: e.type };
+                const result = { name: value, type: e.type };
+                if (callbacksMayThrow)
+                    this.emitPendingCheck();
+                return result;
             }
             case "new": {
                 // Allocate (fields zeroed, vt stamped), then run the ctor. The
@@ -5116,8 +5711,8 @@ class LlEmitter {
                 const ge = B.tmp();
                 const le = B.tmp();
                 const t = B.tmp();
-                B.line(`${ge} = icmp sge i64 ${pre}, ${target.pre}`);
-                B.line(`${le} = icmp sle i64 ${pre}, ${target.post}`);
+                B.line(`${ge} = icmp sge ${this.sizeType} ${pre}, ${target.pre}`);
+                B.line(`${le} = icmp sle ${this.sizeType} ${pre}, ${target.post}`);
                 B.line(`${t} = and i1 ${ge}, ${le} ; instanceof ${e.className}`);
                 return { name: t, type: e.type };
             }
@@ -5135,14 +5730,14 @@ class LlEmitter {
                 const tpostp = B.tmp();
                 const tpost = B.tmp();
                 B.line(`${tprep} = getelementptr inbounds %ScrClassObj, ptr ${target.name}, i64 0, i32 1`);
-                B.line(`${tpre} = load i64, ptr ${tprep}`);
+                B.line(`${tpre} = load ${this.sizeType}, ptr ${tprep}`);
                 B.line(`${tpostp} = getelementptr inbounds %ScrClassObj, ptr ${target.name}, i64 0, i32 2`);
-                B.line(`${tpost} = load i64, ptr ${tpostp}`);
+                B.line(`${tpost} = load ${this.sizeType}, ptr ${tpostp}`);
                 const ge = B.tmp();
                 const le = B.tmp();
                 const t = B.tmp();
-                B.line(`${ge} = icmp sge i64 ${pre}, ${tpre}`);
-                B.line(`${le} = icmp sle i64 ${pre}, ${tpost}`);
+                B.line(`${ge} = icmp sge ${this.sizeType} ${pre}, ${tpre}`);
+                B.line(`${le} = icmp sle ${this.sizeType} ${pre}, ${tpost}`);
                 B.line(`${t} = and i1 ${ge}, ${le}`);
                 return { name: t, type: e.type };
             }
@@ -5154,9 +5749,9 @@ class LlEmitter {
                 const c = this.emitExpr(e.value);
                 if (e.test === "instanceof") {
                     const target = this.classMetaOf(e.className);
-                    this.declare(`declare zeroext i1 @scr_caught_instanceof(ptr, i64, i64)`);
+                    this.declare(`declare zeroext i1 @scr_caught_instanceof(ptr, ${this.sizeType}, ${this.sizeType})`);
                     const t = B.tmp();
-                    B.line(`${t} = call zeroext i1 @scr_caught_instanceof(ptr ${c.name}, i64 ${target.pre}, i64 ${target.post})`);
+                    B.line(`${t} = call zeroext i1 @scr_caught_instanceof(ptr ${c.name}, ${this.sizeType} ${target.pre}, ${this.sizeType} ${target.post})`);
                     if (e.negated !== true)
                         return { name: t, type: e.type };
                     const n = B.tmp();
@@ -5221,9 +5816,9 @@ class LlEmitter {
                 const c = this.emitExpr(e.value);
                 const target = this.classMetaOf(e.className);
                 const display = e.className.startsWith("%") ? e.className.slice(1) : e.className;
-                this.declare(`declare ptr @scr_caught_check_obj(ptr, i64, i64, ptr)`);
+                this.declare(`declare ptr @scr_caught_check_obj(ptr, ${this.sizeType}, ${this.sizeType}, ptr)`);
                 const t = B.tmp();
-                B.line(`${t} = call ptr @scr_caught_check_obj(ptr ${c.name}, i64 ${target.pre}, i64 ${target.post}, ptr ${this.cstr(display)})`);
+                B.line(`${t} = call ptr @scr_caught_check_obj(ptr ${c.name}, ${this.sizeType} ${target.pre}, ${this.sizeType} ${target.post}, ptr ${this.cstr(display)})`);
                 const out = this.own({ name: t, type: e.type });
                 this.emitPendingCheck();
                 return out;
@@ -5334,7 +5929,7 @@ class LlEmitter {
                     return compact;
                 const rewriter = this.walkers.jsonIndentHelper();
                 const t2 = B.tmp();
-                B.line(`${t2} = call ptr @${rewriter}(ptr ${compact.name}, ptr ${this.cstr(indent)}, i64 ${Buffer.byteLength(indent, "utf8")})`);
+                B.line(`${t2} = call ptr @${rewriter}(ptr ${compact.name}, ptr ${this.cstr(indent)}, ${this.sizeType} ${Buffer.byteLength(indent, "utf8")})`);
                 return this.own({ name: t2, type: e.type });
             }
             case "bytesNew": {
@@ -5389,18 +5984,50 @@ class LlEmitter {
                 const v = this.emitExpr(e.value);
                 const yt = e.value.type;
                 if (yt.kind === "f64" || yt.kind === "date") {
-                    this.declare(`declare void @scr_gen_yield_f64(double)`);
-                    B.line(`call void @scr_gen_yield_f64(double ${v.name})`);
+                    if (this.wasi) {
+                        const coro = this.currentWasiCoro;
+                        this.declare(`declare ptr @scr_gen_of_fiber(ptr)`);
+                        this.declare(`declare void @scr_gen_out_f64(ptr, double)`);
+                        const g = B.tmp();
+                        B.line(`${g} = call ptr @scr_gen_of_fiber(ptr ${coro.self})`);
+                        B.line(`call void @scr_gen_out_f64(ptr ${g}, double ${v.name})`);
+                    }
+                    else {
+                        this.declare(`declare void @scr_gen_yield_f64(double)`);
+                        B.line(`call void @scr_gen_yield_f64(double ${v.name})`);
+                    }
                 }
                 else if (yt.kind === "bool") {
-                    this.declare(`declare void @scr_gen_yield_bool(i1 zeroext)`);
-                    B.line(`call void @scr_gen_yield_bool(i1 ${v.name})`);
+                    if (this.wasi) {
+                        const coro = this.currentWasiCoro;
+                        this.declare(`declare ptr @scr_gen_of_fiber(ptr)`);
+                        this.declare(`declare void @scr_gen_out_bool(ptr, i1 zeroext)`);
+                        const g = B.tmp();
+                        B.line(`${g} = call ptr @scr_gen_of_fiber(ptr ${coro.self})`);
+                        B.line(`call void @scr_gen_out_bool(ptr ${g}, i1 ${v.name})`);
+                    }
+                    else {
+                        this.declare(`declare void @scr_gen_yield_bool(i1 zeroext)`);
+                        B.line(`call void @scr_gen_yield_bool(i1 ${v.name})`);
+                    }
                 }
                 else {
                     this.moveTemp(v); // the OUT slot takes ownership
-                    this.declare(`declare void @scr_gen_yield_ref(ptr, ptr)`);
-                    B.line(`call void @scr_gen_yield_ref(ptr ${v.name}, ptr ${vAdapters(this, yt).release})`);
+                    if (this.wasi) {
+                        const coro = this.currentWasiCoro;
+                        this.declare(`declare ptr @scr_gen_of_fiber(ptr)`);
+                        this.declare(`declare void @scr_gen_out_ref(ptr, ptr, ptr)`);
+                        const g = B.tmp();
+                        B.line(`${g} = call ptr @scr_gen_of_fiber(ptr ${coro.self})`);
+                        B.line(`call void @scr_gen_out_ref(ptr ${g}, ptr ${v.name}, ptr ${vAdapters(this, yt).release})`);
+                    }
+                    else {
+                        this.declare(`declare void @scr_gen_yield_ref(ptr, ptr)`);
+                        B.line(`call void @scr_gen_yield_ref(ptr ${v.name}, ptr ${vAdapters(this, yt).release})`);
+                    }
                 }
+                if (this.wasi)
+                    this.emitWasiSuspendPrepared();
                 this.emitPendingCheck();
                 if (e.type.kind === "void") {
                     // An undefined next-channel: nothing to read (the frontend
@@ -5532,6 +6159,8 @@ class LlEmitter {
                 // refcounted results arrive +1 and join the frame pre-check so an
                 // unwind releases the dummy (NULL) harmlessly.
                 const pr = this.emitExpr(e.value);
+                if (this.wasi)
+                    this.emitWasiSuspend(pr.name);
                 if (e.type.kind === "void") {
                     this.declare(`declare void @scr_await_void(ptr)`);
                     B.line(`call void @scr_await_void(ptr ${pr.name})`);
@@ -5586,10 +6215,18 @@ class LlEmitter {
                     B.condBr(isP, lp, lh);
                     B.startBlock(lp);
                     this.declare(`declare void @scr_await_void(ptr)`);
-                    B.line(`call void @scr_await_void(ptr ${this.unionPeek(u.name)})`);
+                    {
+                        const promise = this.unionPeek(u.name);
+                        if (this.wasi)
+                            this.emitWasiSuspend(promise);
+                        B.line(`call void @scr_await_void(ptr ${promise})`);
+                    }
                     B.br(lj);
                     B.startBlock(lh);
-                    B.line(`call void @scr_await_hop()`);
+                    if (this.wasi)
+                        this.emitWasiSuspend(null);
+                    else
+                        B.line(`call void @scr_await_hop()`);
                     B.br(lj);
                     B.startBlock(lj);
                     this.emitPendingCheck();
@@ -5618,6 +6255,8 @@ class LlEmitter {
                 B.condBr(isP, lp, lh);
                 B.startBlock(lp);
                 const peek = this.unionPeek(u.name);
+                if (this.wasi)
+                    this.emitWasiSuspend(peek);
                 let awaited;
                 if (inner.kind === "f64" || inner.kind === "date") {
                     this.declare(`declare double @scr_await_f64(ptr)`);
@@ -5646,7 +6285,10 @@ class LlEmitter {
                 B.line(`store ptr ${this.unionNewOwned(innerTag, awaited)}, ptr ${slot}`);
                 B.br(lj);
                 B.startBlock(lh);
-                B.line(`call void @scr_await_hop()`);
+                if (this.wasi)
+                    this.emitWasiSuspend(null);
+                else
+                    B.line(`call void @scr_await_hop()`);
                 const unitTags = def.arms.flatMap((a, i) => (isUnitType(a) ? [i] : []));
                 if (unitTags.length === 1) {
                     B.line(`store ptr ${this.unitInstanceRef(resUnionId, resTagOf(def.arms[unitTags[0]]))}, ptr ${slot}`);
@@ -5772,8 +6414,27 @@ class LlEmitter {
                     // Internal ESM dependency wait: pending promises park the module
                     // fiber, while settled ones continue synchronously.
                     const p = this.emitExpr(e.args[0]);
-                    this.declare(`declare void @scr_module_await(ptr)`);
-                    B.line(`call void @scr_module_await(ptr ${p.name})`);
+                    if (this.wasi) {
+                        const coro = this.currentWasiCoro;
+                        if (coro === null)
+                            throw new Error("llvm emitter bug: module await outside wasm coroutine");
+                        this.declare(`declare zeroext i1 @scr_wasi_module_await_prepare(ptr, ptr)`);
+                        const needsSuspend = B.tmp();
+                        const suspend = B.newLabel("ma.suspend");
+                        const ready = B.newLabel("ma.ready");
+                        B.line(`${needsSuspend} = call zeroext i1 @scr_wasi_module_await_prepare(ptr ${coro.self}, ptr ${p.name})`);
+                        B.condBr(needsSuspend, suspend, ready);
+                        B.startBlock(suspend);
+                        this.emitWasiSuspendPrepared();
+                        B.br(ready);
+                        B.startBlock(ready);
+                        this.declare(`declare void @scr_module_await(ptr)`);
+                        B.line(`call void @scr_module_await(ptr ${p.name})`);
+                    }
+                    else {
+                        this.declare(`declare void @scr_module_await(ptr)`);
+                        B.line(`call void @scr_module_await(ptr ${p.name})`);
+                    }
                     this.emitPendingCheck();
                     return { name: "", type: e.type };
                 }
@@ -5807,7 +6468,7 @@ class LlEmitter {
                     const len = B.tmp();
                     const cap = B.tmp();
                     B.line(`${len} = call double @scr_arr_len(ptr ${ps.name})`);
-                    B.line(`${cap} = fptoui double ${len} to i64`);
+                    B.line(`${cap} = fptoui double ${len} to ${this.sizeType}`);
                     const vals = B.tmp();
                     B.line(`${vals} = ${arrNewCall(this, elem, cap)}`);
                     this.own({ name: vals, type: e.type.inner });
@@ -5929,8 +6590,8 @@ class LlEmitter {
                     }
                 });
                 const fn = e.name === "console.error" ? "scr_console_error" : "scr_console_log";
-                this.declare(`declare void @${fn}(i64, ptr)`);
-                B.line(`call void @${fn}(i64 ${args.length}, ptr %logargs)`);
+                this.declare(`declare void @${fn}(${this.sizeType}, ptr)`);
+                B.line(`call void @${fn}(${this.sizeType} ${args.length}, ptr %logargs)`);
                 return { name: "", type: e.type };
             }
             case "dynFrom": {
@@ -5972,9 +6633,9 @@ class LlEmitter {
                         this.liveDynRefAdapters.set(key, adapter);
                     }
                     const rc = vAdapters(this, v.type);
-                    this.declare(`declare ptr @scr_dyn_new_typed_ref(ptr, ptr, ptr, ptr, i64, ptr, ptr)`);
+                    this.declare(`declare ptr @scr_dyn_new_typed_ref(ptr, ptr, ptr, ptr, ${this.sizeType}, ptr, ptr)`);
                     const boxed = B.tmp();
-                    B.line(`${boxed} = call ptr @scr_dyn_new_typed_ref(ptr ${v.name}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${this.cstr(key)}, i64 ${Buffer.byteLength(key, "utf8")}, ptr @${adapter.snapshot}, ptr ${adapter.commit})`);
+                    B.line(`${boxed} = call ptr @scr_dyn_new_typed_ref(ptr ${v.name}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${this.cstr(key)}, ${this.sizeType} ${Buffer.byteLength(key, "utf8")}, ptr @${adapter.snapshot}, ptr ${adapter.commit})`);
                     return this.own({ name: boxed, type: e.type });
                 }
                 if (v.type.kind === "func") {
@@ -6075,14 +6736,14 @@ class LlEmitter {
                     B.entryAllocas.push(`${arr} = alloca [${args.length} x ptr]`);
                     args.forEach((a, i) => {
                         const p = B.tmp();
-                        B.line(`${p} = getelementptr inbounds [${args.length} x ptr], ptr ${arr}, i64 0, i64 ${i}`);
+                        B.line(`${p} = getelementptr inbounds [${args.length} x ptr], ptr ${arr}, i64 0, ${this.sizeType} ${i}`);
                         B.line(`store ptr ${a.name}, ptr ${p}`);
                     });
                     argsPtr = arr;
                 }
-                this.declare(`declare ptr @scr_dyn_call(ptr, ptr, i64, ptr)`);
+                this.declare(`declare ptr @scr_dyn_call(ptr, ptr, ${this.sizeType}, ptr)`);
                 const t = B.tmp();
-                B.line(`${t} = call ptr @scr_dyn_call(ptr ${callee.name}, ptr ${argsPtr}, i64 ${args.length}, ptr ${this.cstr(e.calleeName)})`);
+                B.line(`${t} = call ptr @scr_dyn_call(ptr ${callee.name}, ptr ${argsPtr}, ${this.sizeType} ${args.length}, ptr ${this.cstr(e.calleeName)})`);
                 const out = this.own({ name: t, type: e.type });
                 this.emitPendingCheck();
                 return out;
@@ -6099,14 +6760,14 @@ class LlEmitter {
                     B.entryAllocas.push(`${arr} = alloca [${args.length} x ptr]`);
                     args.forEach((a, i) => {
                         const p = B.tmp();
-                        B.line(`${p} = getelementptr inbounds [${args.length} x ptr], ptr ${arr}, i64 0, i64 ${i}`);
+                        B.line(`${p} = getelementptr inbounds [${args.length} x ptr], ptr ${arr}, i64 0, ${this.sizeType} ${i}`);
                         B.line(`store ptr ${a.name}, ptr ${p}`);
                     });
                     argsPtr = arr;
                 }
-                this.declare(`declare ptr @scr_dyn_invoke(ptr, ptr, ptr, i64, ptr)`);
+                this.declare(`declare ptr @scr_dyn_invoke(ptr, ptr, ptr, ${this.sizeType}, ptr)`);
                 const t = B.tmp();
-                B.line(`${t} = call ptr @scr_dyn_invoke(ptr ${recv.name}, ptr ${this.cstr(e.method)}, ptr ${argsPtr}, i64 ${args.length}, ptr ${this.cstr(e.calleeName)})`);
+                B.line(`${t} = call ptr @scr_dyn_invoke(ptr ${recv.name}, ptr ${this.cstr(e.method)}, ptr ${argsPtr}, ${this.sizeType} ${args.length}, ptr ${this.cstr(e.calleeName)})`);
                 const out = this.own({ name: t, type: e.type });
                 this.emitPendingCheck();
                 return out;
@@ -6173,11 +6834,11 @@ class LlEmitter {
                 B.line(`${isObj} = icmp eq i32 ${kd}, ${DK.OBJ}`);
                 B.condBr(isObj, lObj, lNotObj);
                 B.startBlock(lObj);
-                this.declare(`declare ptr @scr_dyn_obj_get(ptr, ptr, i64)`);
+                this.declare(`declare ptr @scr_dyn_obj_get(ptr, ptr, ${this.sizeType})`);
                 const keyBytes = Buffer.byteLength(e.key, "utf8");
                 const m = B.tmp();
                 const has = B.tmp();
-                B.line(`${m} = call ptr @scr_dyn_obj_get(ptr ${d.name}, ptr ${this.cstr(e.key)}, i64 ${keyBytes})`);
+                B.line(`${m} = call ptr @scr_dyn_obj_get(ptr ${d.name}, ptr ${this.cstr(e.key)}, ${this.sizeType} ${keyBytes})`);
                 B.line(`${has} = icmp ne ptr ${m}, null`);
                 B.line(`store i1 ${has}, ptr ${slot}`);
                 B.br(lj);
@@ -6195,8 +6856,8 @@ class LlEmitter {
                     const len = B.tmp();
                     const inR = B.tmp();
                     B.line(`${lenp} = getelementptr inbounds i8, ptr ${d.name}, i64 16 ; ->v.arr.len`);
-                    B.line(`${len} = load i64, ptr ${lenp}`);
-                    B.line(`${inR} = icmp ugt i64 ${len}, ${e.key}`);
+                    B.line(`${len} = load ${this.sizeType}, ptr ${lenp}`);
+                    B.line(`${inR} = icmp ugt ${this.sizeType} ${len}, ${e.key}`);
                     B.line(`store i1 ${inR}, ptr ${slot}`);
                 }
                 B.br(lj);
@@ -6309,10 +6970,10 @@ class LlEmitter {
                     const lj = B.newLabel("dts.j");
                     B.condBr(isObj, lObj, lj);
                     B.startBlock(lObj);
-                    this.declare(`declare ptr @scr_dyn_obj_get(ptr, ptr, i64)`);
+                    this.declare(`declare ptr @scr_dyn_obj_get(ptr, ptr, ${this.sizeType})`);
                     const m = B.tmp();
                     const has = B.tmp();
-                    B.line(`${m} = call ptr @scr_dyn_obj_get(ptr ${d.name}, ptr ${this.cstr("%error")}, i64 6)`);
+                    B.line(`${m} = call ptr @scr_dyn_obj_get(ptr ${d.name}, ptr ${this.cstr("%error")}, ${this.sizeType} 6)`);
                     B.line(`${has} = icmp ne ptr ${m}, null`);
                     B.line(`store i1 ${has}, ptr ${slot}`);
                     B.br(lj);
@@ -6420,7 +7081,7 @@ class LlEmitter {
                 }
                 const helper = this.dyn.dynIterNHelper();
                 const t = B.tmp();
-                B.line(`${t} = call ptr @${helper}(ptr ${v.name}, i64 ${e.count})`);
+                B.line(`${t} = call ptr @${helper}(ptr ${v.name}, ${this.sizeType} ${e.count})`);
                 const out = this.own({ name: t, type: e.type });
                 this.emitPendingCheck();
                 return out;
@@ -7174,13 +7835,13 @@ class LlEmitter {
         this.resolveThunkDefs.push(...d);
         return sym;
     }
-    /** Loads a dyn node's kind tag (i32 at +8) — the dyn expression tests'
+    /** Loads a dyn node's kind tag after its size_t RC word — the dyn expression tests'
      * shared read. */
     dynKind(d) {
         const B = this.B;
         const p = B.tmp();
         const k = B.tmp();
-        B.line(`${p} = getelementptr inbounds i8, ptr ${d}, i64 8 ; ->kind`);
+        B.line(`${p} = getelementptr inbounds i8, ptr ${d}, i64 ${this.sizeType === "i32" ? 4 : 8} ; ->kind`);
         B.line(`${k} = load i32, ptr ${p}`);
         return k;
     }
@@ -7486,11 +8147,11 @@ class LlEmitter {
         }
         this.declare(`declare ptr @scr_union_new_f64(i32, double)`);
         this.declare(`declare ptr @scr_union_new_ref(i32, ptr, ptr, ptr, ptr)`);
-        this.declare(`declare ptr @scr_str_new(ptr, i64)`);
-        this.declare(`declare i64 @strlen(ptr)`);
+        this.declare(`declare ptr @scr_str_new(ptr, ${this.sizeType})`);
+        this.declare(`declare ${this.sizeType} @strlen(ptr)`);
         this.declare(`declare ptr @scr_str_retain_v(ptr)`);
         this.declare(`declare void @scr_str_release_v(ptr)`);
-        this.resolveThunkDefs.push(`define internal void @${sym}(ptr %cb, i1 zeroext %has, double %code, ptr %sig) ${FN_ATTRS} { ; child exit (code, signal)`, `entry:`, `  %uslot = alloca ptr`, `  %sslot = alloca ptr`, `  br i1 %has, label %num, label %nonum`, `num:`, `  %u1 = call ptr @scr_union_new_f64(i32 ${f64Tag}, double %code)`, `  store ptr %u1, ptr %uslot`, `  br label %sigq`, `nonum:`, `  store ptr ${this.unitInstanceRef(codeParam.unionId, codeNullTag)}, ptr %uslot`, `  br label %sigq`, `sigq:`, `  %hassig = icmp ne ptr %sig, null`, `  br i1 %hassig, label %sigs, label %signull`, `sigs:`, `  %len = call i64 @strlen(ptr %sig)`, `  %ss = call ptr @scr_str_new(ptr %sig, i64 %len)`, `  %su = call ptr @scr_union_new_ref(i32 ${strTag}, ptr %ss, ptr @scr_str_retain_v, ptr @scr_str_release_v, ptr null)`, `  store ptr %su, ptr %sslot`, `  br label %go`, `signull:`, `  store ptr ${this.unitInstanceRef(sigParam.unionId, sigNullTag)}, ptr %sslot`, `  br label %go`, `go:`, `  %u = load ptr, ptr %uslot`, `  %s = load ptr, ptr %sslot`, `  %fnp = getelementptr inbounds %ScrClosure, ptr %cb, i64 0, i32 1`, `  %fn = load ptr, ptr %fnp`, `  call void %fn(ptr %cb, ptr %u, ptr %s)`, `  ret void`, `}`, ``);
+        this.resolveThunkDefs.push(`define internal void @${sym}(ptr %cb, i1 zeroext %has, double %code, ptr %sig) ${FN_ATTRS} { ; child exit (code, signal)`, `entry:`, `  %uslot = alloca ptr`, `  %sslot = alloca ptr`, `  br i1 %has, label %num, label %nonum`, `num:`, `  %u1 = call ptr @scr_union_new_f64(i32 ${f64Tag}, double %code)`, `  store ptr %u1, ptr %uslot`, `  br label %sigq`, `nonum:`, `  store ptr ${this.unitInstanceRef(codeParam.unionId, codeNullTag)}, ptr %uslot`, `  br label %sigq`, `sigq:`, `  %hassig = icmp ne ptr %sig, null`, `  br i1 %hassig, label %sigs, label %signull`, `sigs:`, `  %len = call ${this.sizeType} @strlen(ptr %sig)`, `  %ss = call ptr @scr_str_new(ptr %sig, ${this.sizeType} %len)`, `  %su = call ptr @scr_union_new_ref(i32 ${strTag}, ptr %ss, ptr @scr_str_retain_v, ptr @scr_str_release_v, ptr null)`, `  store ptr %su, ptr %sslot`, `  br label %go`, `signull:`, `  store ptr ${this.unitInstanceRef(sigParam.unionId, sigNullTag)}, ptr %sslot`, `  br label %go`, `go:`, `  %u = load ptr, ptr %uslot`, `  %s = load ptr, ptr %sslot`, `  %fnp = getelementptr inbounds %ScrClosure, ptr %cb, i64 0, i32 1`, `  %fn = load ptr, ptr %fnp`, `  call void %fn(ptr %cb, ptr %u, ptr %s)`, `  ret void`, `}`, ``);
         return sym;
     }
     /** Interned per-union child-stream data adapter — emit-async.ts's
@@ -7521,8 +8182,8 @@ class LlEmitter {
      * POINTER-SIZE slots off the emit tuple's va_list (textual LLVM IR
      * cannot va_arg portably) and calls this function behind the wrapper
      * closure's fn. It re-types each slot to the listener's declared
-     * parameter (f64 from its i64 bit pattern, bool from the zero-extended
-     * slot, refcounted values retained — the callee owns +1 per the
+     * parameter (f64/bool scalars load from the emit site's stack slot,
+     * refcounted values retain the direct pointer — the callee owns +1 per the
      * universal convention) and calls the ORIGINAL listener held by the
      * wrapper's one capture box. A non-void result is discarded (refcounted
      * ones released) — Node ignores listener return values. Interned per
@@ -7556,11 +8217,11 @@ class LlEmitter {
         cbT.params.forEach((p, i) => {
             const ty = this.llType(p);
             if (ty === "double") {
-                d.push(`  %x${i} = ptrtoint ptr %a${i} to i64`, `  %d${i} = bitcast i64 %x${i} to double`);
+                d.push(`  %d${i} = load double, ptr %a${i}`);
                 passed.push(`double %d${i}`);
             }
             else if (ty === "i1") {
-                d.push(`  %x${i} = ptrtoint ptr %a${i} to i64`, `  %b${i} = trunc i64 %x${i} to i1`);
+                d.push(`  %b${i} = load i1, ptr %a${i}`);
                 passed.push(`i1 %b${i}`);
             }
             else if (isRefCounted(p)) {
@@ -7592,11 +8253,11 @@ class LlEmitter {
      * registration call it feeds always moves it into the registry. */
     wrapEmitterListener(target, adapterFn) {
         const B = this.B;
-        this.declare(`declare ptr @scr_closure_new(ptr, i64)`);
+        this.declare(`declare ptr @scr_closure_new(ptr, ${this.sizeType})`);
         this.declare(`declare ptr @scr_box_new(i32)`);
         this.declare(`declare void @scr_box_set_ref(ptr, ptr)`);
         const ad = B.tmp();
-        B.line(`${ad} = call ptr @scr_closure_new(ptr @${adapterFn}, i64 1)`);
+        B.line(`${ad} = call ptr @scr_closure_new(ptr @${adapterFn}, ${this.sizeType} 1)`);
         const bx = B.tmp();
         B.line(`${bx} = call ptr @scr_box_new(i32 4) ; SCR_BOX_FUNC`);
         const capsp = B.tmp();
@@ -7672,7 +8333,7 @@ class LlEmitter {
                 throw new Error("llvm emitter bug: bound-close err union lacks its undefined arm");
             trampoline = `${sym}_cb`;
             this.resolveThunkDefs.push(`define internal void @${trampoline}(ptr %self) ${FN_ATTRS} { ; close cb: fire with no error`, `entry:`, `  %capsp = getelementptr inbounds %ScrClosure, ptr %self, i64 1`, `  %bx = load ptr, ptr %capsp`, `  %inner = call ptr @scr_box_get_ref(ptr %bx) ; +1`, `  %fnp = getelementptr inbounds %ScrClosure, ptr %inner, i64 0, i32 1`, `  %fn = load ptr, ptr %fnp`, `  call void %fn(ptr %inner, ptr ${this.unitInstanceRef(errParam.unionId, undefTag)})`, `  call void @scr_closure_release(ptr %inner)`, `  ret void`, `}`, ``);
-            this.declare(`declare ptr @scr_closure_new(ptr, i64)`);
+            this.declare(`declare ptr @scr_closure_new(ptr, ${this.sizeType})`);
             this.declare(`declare ptr @scr_box_new(i32)`);
             this.declare(`declare void @scr_box_set_ref(ptr, ptr)`);
         }
@@ -7695,7 +8356,7 @@ class LlEmitter {
             `  %pv = load ptr, ptr %pp`,
         ];
         if (oneParam) {
-            d.push(`  %reg = call ptr @scr_closure_new(ptr @${trampoline}, i64 1)`, `  %rbx = call ptr @scr_box_new(i32 4) ; SCR_BOX_FUNC`, `  %rcp = getelementptr inbounds %ScrClosure, ptr %reg, i64 1`, `  store ptr %rbx, ptr %rcp`, `  %pr = call ptr @scr_closure_retain_v(ptr %pv)`, `  call void @scr_box_set_ref(ptr %rbx, ptr %pr)`, `  store ptr %reg, ptr %regslot`);
+            d.push(`  %reg = call ptr @scr_closure_new(ptr @${trampoline}, ${this.sizeType} 1)`, `  %rbx = call ptr @scr_box_new(i32 4) ; SCR_BOX_FUNC`, `  %rcp = getelementptr inbounds %ScrClosure, ptr %reg, i64 1`, `  store ptr %rbx, ptr %rcp`, `  %pr = call ptr @scr_closure_retain_v(ptr %pv)`, `  call void @scr_box_set_ref(ptr %rbx, ptr %pr)`, `  store ptr %reg, ptr %regslot`);
         }
         else {
             d.push(`  %reg = call ptr @scr_closure_retain_v(ptr %pv)`, `  store ptr %reg, ptr %regslot`);
@@ -7791,8 +8452,8 @@ class LlEmitter {
                 ? "a 'data' listener declaring a Buffer chunk received a string (the stream has an encoding set)"
                 : "a 'data' listener declaring a string chunk received a Buffer (call setEncoding, or declare the chunk as a Buffer)";
             const slot = p.kind === "bytes" ? "%a0" : "%a1";
-            this.declare(`declare void @scr_throw_error_msg(i32, ptr, i64)`);
-            d.push(`  %miss = icmp eq ptr ${slot}, null`, `  br i1 %miss, label %bad, label %ok`, `bad:`, `  call void @scr_throw_error_msg(i32 1, ptr ${this.cstr(msg)}, i64 ${Buffer.byteLength(msg, "utf8")})`, `  call void @scr_closure_release(ptr %orig)`, `  ret void`, `ok:`, `  %r0 = call ptr ${retainSym(this, p)}(ptr ${slot})`);
+            this.declare(`declare void @scr_throw_error_msg(i32, ptr, ${this.sizeType})`);
+            d.push(`  %miss = icmp eq ptr ${slot}, null`, `  br i1 %miss, label %bad, label %ok`, `bad:`, `  call void @scr_throw_error_msg(i32 1, ptr ${this.cstr(msg)}, ${this.sizeType} ${Buffer.byteLength(msg, "utf8")})`, `  call void @scr_closure_release(ptr %orig)`, `  ret void`, `ok:`, `  %r0 = call ptr ${retainSym(this, p)}(ptr ${slot})`);
             finish("%r0");
             d.push(`}`, ``);
         }
@@ -7988,13 +8649,13 @@ class LlEmitter {
         // The stream-owning completion closure (a 1-cap closure boxing the
         // retained stream) — shared by the typed and dyn done shapes.
         const doneClosure = (fnRef, tag) => {
-            this.declare(`declare ptr @scr_closure_new(ptr, i64)`);
+            this.declare(`declare ptr @scr_closure_new(ptr, ${this.sizeType})`);
             this.declare(`declare ptr @scr_box_new_obj(ptr, ptr, ptr)`);
             this.declare(`declare void @scr_box_set_ref(ptr, ptr)`);
             this.declare(`declare ptr @scr_stream_retain_v(ptr)`);
             this.declare(`declare void @scr_stream_release_v(ptr)`);
             this.declare(`declare void @scr_stream_trace(ptr, ptr, ptr)`);
-            d.push(`  %${tag}clo = call ptr @scr_closure_new(ptr ${fnRef}, i64 1)`, `  %${tag}bx = call ptr @scr_box_new_obj(ptr @scr_stream_retain_v, ptr @scr_stream_release_v, ptr @scr_stream_trace)`, `  %${tag}cp = getelementptr inbounds %ScrClosure, ptr %${tag}clo, i64 1`, `  store ptr %${tag}bx, ptr %${tag}cp`, `  %${tag}sr = call ptr @scr_stream_retain_v(ptr %s)`, `  call void @scr_box_set_ref(ptr %${tag}bx, ptr %${tag}sr)`);
+            d.push(`  %${tag}clo = call ptr @scr_closure_new(ptr ${fnRef}, ${this.sizeType} 1)`, `  %${tag}bx = call ptr @scr_box_new_obj(ptr @scr_stream_retain_v, ptr @scr_stream_release_v, ptr @scr_stream_trace)`, `  %${tag}cp = getelementptr inbounds %ScrClosure, ptr %${tag}clo, i64 1`, `  store ptr %${tag}bx, ptr %${tag}cp`, `  %${tag}sr = call ptr @scr_stream_retain_v(ptr %s)`, `  call void @scr_box_set_ref(ptr %${tag}bx, ptr %${tag}sr)`);
             return `%${tag}clo`;
         };
         for (let i = off; i < declared.length; i++) {
@@ -8023,10 +8684,10 @@ class LlEmitter {
                     passed.push(`ptr %dc${i}`);
                 }
                 else if (isEncPos) {
-                    this.declare(`declare ptr @scr_str_new(ptr, i64)`);
+                    this.declare(`declare ptr @scr_str_new(ptr, ${this.sizeType})`);
                     this.declare(`declare ptr @scr_dyn_new_str(ptr)`);
                     this.declare(`declare void @scr_str_release(ptr)`);
-                    d.push(`  %es${i} = call ptr @scr_str_new(ptr ${this.cstr("buffer")}, i64 6)`, `  %ed${i} = call ptr @scr_dyn_new_str(ptr %es${i})`, `  call void @scr_str_release(ptr %es${i})`);
+                    d.push(`  %es${i} = call ptr @scr_str_new(ptr ${this.cstr("buffer")}, ${this.sizeType} 6)`, `  %ed${i} = call ptr @scr_dyn_new_str(ptr %es${i})`, `  call void @scr_str_release(ptr %es${i})`);
                     passed.push(`ptr %ed${i}`);
                 }
                 else if (isErrPos) {
@@ -8048,7 +8709,7 @@ class LlEmitter {
                 }
                 else if (isDonePos) {
                     const glue = `scr_stream_done_dyn_${kind}`;
-                    this.declare(`declare ptr @${glue}(ptr, ptr, i64)`);
+                    this.declare(`declare ptr @${glue}(ptr, ptr, ${this.sizeType})`);
                     this.declare(`declare ptr @scr_dyn_new_func(ptr, ptr, i32, ptr, ptr)`);
                     const clo = doneClosure(`@${glue}`, `dd${i}`);
                     const arity = kind === "t" || kind === "l" ? 2 : 1;
@@ -8068,8 +8729,8 @@ class LlEmitter {
             }
             else if (isEncPos) {
                 // Node's encoding for decoded (Buffer) chunks is 'buffer'.
-                this.declare(`declare ptr @scr_str_new(ptr, i64)`);
-                d.push(`  %en${i} = call ptr @scr_str_new(ptr ${this.cstr("buffer")}, i64 6)`);
+                this.declare(`declare ptr @scr_str_new(ptr, ${this.sizeType})`);
+                d.push(`  %en${i} = call ptr @scr_str_new(ptr ${this.cstr("buffer")}, ${this.sizeType} 6)`);
                 passed.push(`ptr %en${i}`);
             }
             else if (isErrPos) {
@@ -8872,7 +9533,7 @@ class LlEmitter {
         if (slot === undefined)
             return null;
         const index = this.B.tmp();
-        this.B.line(`${index} = load i64, ptr ${slot}`);
+        this.B.line(`${index} = load ${this.sizeType}, ptr ${slot}`);
         return index;
     }
     /** Bounds-check a typed-array element index without an out-of-line call
@@ -8884,16 +9545,16 @@ class LlEmitter {
         const lenPtr = B.tmp();
         const len = B.tmp();
         B.line(`${lenPtr} = getelementptr inbounds %ScrBytes, ptr ${receiver}, i64 0, i32 1`);
-        B.line(`${len} = load i64, ptr ${lenPtr}`);
+        B.line(`${len} = load ${this.sizeType}, ptr ${lenPtr}`);
         if (integerIndex) {
             const inRange = B.tmp();
-            B.line(`${inRange} = icmp ult i64 ${index}, ${len}`);
+            B.line(`${inRange} = icmp ult ${this.sizeType} ${index}, ${len}`);
             const invalid = B.newLabel("bytes.index.invalid");
             const valid = B.newLabel("bytes.index.valid");
             B.condBr(inRange, valid, invalid);
             B.startBlock(invalid);
             const indexF64 = B.tmp();
-            B.line(`${indexF64} = uitofp i64 ${index} to double`);
+            B.line(`${indexF64} = uitofp ${this.sizeType} ${index} to double`);
             this.declare(`declare double @scr_bytes_get(ptr, double)`);
             B.line(`call double @scr_bytes_get(ptr ${receiver}, double ${indexF64})`);
             B.terminate("unreachable");
@@ -8904,7 +9565,7 @@ class LlEmitter {
         const nonnegative = B.tmp();
         const belowLen = B.tmp();
         const inRange = B.tmp();
-        B.line(`${lenF64} = uitofp i64 ${len} to double`);
+        B.line(`${lenF64} = uitofp ${this.sizeType} ${len} to double`);
         B.line(`${nonnegative} = fcmp oge double ${index}, ${f64Lit(0)}`);
         B.line(`${belowLen} = fcmp olt double ${index}, ${lenF64}`);
         B.line(`${inRange} = and i1 ${nonnegative}, ${belowLen}`);
@@ -8916,8 +9577,8 @@ class LlEmitter {
         const idx = B.tmp();
         const roundTrip = B.tmp();
         const integral = B.tmp();
-        B.line(`${idx} = fptoui double ${index} to i64`);
-        B.line(`${roundTrip} = uitofp i64 ${idx} to double`);
+        B.line(`${idx} = fptoui double ${index} to ${this.sizeType}`);
+        B.line(`${roundTrip} = uitofp ${this.sizeType} ${idx} to double`);
         B.line(`${integral} = fcmp oeq double ${roundTrip}, ${index}`);
         B.condBr(integral, valid, invalid);
         B.startBlock(invalid);
@@ -8941,12 +9602,12 @@ class LlEmitter {
         const p = B.tmp();
         const len = B.tmp();
         B.line(`${p} = getelementptr inbounds %ScrBytes, ptr ${receiver}, i64 0, i32 1`);
-        B.line(`${len} = load i64, ptr ${p}`);
+        B.line(`${len} = load ${this.sizeType}, ptr ${p}`);
         const count = bytes && elem !== "u8" ? B.tmp() : len;
         if (count !== len)
-            B.line(`${count} = shl i64 ${len}, 2`);
+            B.line(`${count} = shl ${this.sizeType} ${len}, 2`);
         const out = B.tmp();
-        B.line(`${out} = uitofp i64 ${count} to double`);
+        B.line(`${out} = uitofp ${this.sizeType} ${count} to double`);
         return { name: out, type: F64 };
     }
     /** Kind-specialized typed-array load. */
@@ -8959,7 +9620,7 @@ class LlEmitter {
             const raw = B.tmp();
             const wide = B.tmp();
             const out = B.tmp();
-            B.line(`${p} = getelementptr inbounds i8, ptr ${data}, i64 ${idx}`);
+            B.line(`${p} = getelementptr inbounds i8, ptr ${data}, ${this.sizeType} ${idx}`);
             B.line(`${raw} = load i8, ptr ${p}, align 1`);
             B.line(`${wide} = zext i8 ${raw} to i32`);
             B.line(`${out} = uitofp i32 ${wide} to double`);
@@ -8968,14 +9629,14 @@ class LlEmitter {
         if (elem === "f32") {
             const raw = B.tmp();
             const out = B.tmp();
-            B.line(`${p} = getelementptr inbounds float, ptr ${data}, i64 ${idx}`);
+            B.line(`${p} = getelementptr inbounds float, ptr ${data}, ${this.sizeType} ${idx}`);
             B.line(`${raw} = load float, ptr ${p}, align 1`);
             B.line(`${out} = fpext float ${raw} to double`);
             return { name: out, type: F64 };
         }
         const raw = B.tmp();
         const out = B.tmp();
-        B.line(`${p} = getelementptr inbounds i32, ptr ${data}, i64 ${idx}`);
+        B.line(`${p} = getelementptr inbounds i32, ptr ${data}, ${this.sizeType} ${idx}`);
         B.line(`${raw} = load i32, ptr ${p}, align 1`);
         B.line(`${out} = ${elem === "i32" ? "sitofp" : "uitofp"} i32 ${raw} to double`);
         return { name: out, type: F64 };
@@ -9053,18 +9714,18 @@ class LlEmitter {
         if (elem === "u8") {
             const byte = B.tmp();
             B.line(`${byte} = trunc i32 ${stored} to i8`);
-            B.line(`${p} = getelementptr inbounds i8, ptr ${data}, i64 ${idx}`);
+            B.line(`${p} = getelementptr inbounds i8, ptr ${data}, ${this.sizeType} ${idx}`);
             B.line(`store i8 ${byte}, ptr ${p}, align 1`);
             return;
         }
         if (elem === "f32") {
             const narrowed = B.tmp();
             B.line(`${narrowed} = fptrunc double ${value} to float`);
-            B.line(`${p} = getelementptr inbounds float, ptr ${data}, i64 ${idx}`);
+            B.line(`${p} = getelementptr inbounds float, ptr ${data}, ${this.sizeType} ${idx}`);
             B.line(`store float ${narrowed}, ptr ${p}, align 1`);
             return;
         }
-        B.line(`${p} = getelementptr inbounds i32, ptr ${data}, i64 ${idx}`);
+        B.line(`${p} = getelementptr inbounds i32, ptr ${data}, ${this.sizeType} ${idx}`);
         B.line(`store i32 ${stored}, ptr ${p}, align 1`);
     }
     /** The bytesIntrinsic surface (emit-exprs.ts's switch, .ll flavored).
@@ -9698,7 +10359,7 @@ class LlEmitter {
             const commit = `${snapshot}_commit`;
             const check = this.dyn.dynCheckHelper(t);
             this.declare(`declare void @scr_arr_release(ptr)`);
-            this.resolveThunkDefs.push(`define internal void @${commit}(ptr %target, ptr %d) ${FN_ATTRS} { ; commit live stream element ${typeKey(t)}`, `entry:`, `  %next = call ptr @${check}(ptr %d, ptr null)`, `  %missing = icmp eq ptr %next, null`, `  br i1 %missing, label %done, label %swap`, `swap:`, `  %target_len_ptr = getelementptr inbounds %ScrArr, ptr %target, i64 0, i32 1`, `  %next_len_ptr = getelementptr inbounds %ScrArr, ptr %next, i64 0, i32 1`, `  %target_len = load i64, ptr %target_len_ptr`, `  %next_len = load i64, ptr %next_len_ptr`, `  store i64 %next_len, ptr %target_len_ptr`, `  store i64 %target_len, ptr %next_len_ptr`, `  %target_cap_ptr = getelementptr inbounds %ScrArr, ptr %target, i64 0, i32 2`, `  %next_cap_ptr = getelementptr inbounds %ScrArr, ptr %next, i64 0, i32 2`, `  %target_cap = load i64, ptr %target_cap_ptr`, `  %next_cap = load i64, ptr %next_cap_ptr`, `  store i64 %next_cap, ptr %target_cap_ptr`, `  store i64 %target_cap, ptr %next_cap_ptr`, `  %target_data_ptr = getelementptr inbounds %ScrArr, ptr %target, i64 0, i32 7`, `  %next_data_ptr = getelementptr inbounds %ScrArr, ptr %next, i64 0, i32 7`, `  %target_data = load ptr, ptr %target_data_ptr`, `  %next_data = load ptr, ptr %next_data_ptr`, `  store ptr %next_data, ptr %target_data_ptr`, `  store ptr %target_data, ptr %next_data_ptr`, `  call void @scr_arr_release(ptr %next)`, `  br label %done`, `done:`, `  ret void`, `}`, ``);
+            this.resolveThunkDefs.push(`define internal void @${commit}(ptr %target, ptr %d) ${FN_ATTRS} { ; commit live stream element ${typeKey(t)}`, `entry:`, `  %next = call ptr @${check}(ptr %d, ptr null)`, `  %missing = icmp eq ptr %next, null`, `  br i1 %missing, label %done, label %swap`, `swap:`, `  %target_len_ptr = getelementptr inbounds %ScrArr, ptr %target, i64 0, i32 1`, `  %next_len_ptr = getelementptr inbounds %ScrArr, ptr %next, i64 0, i32 1`, `  %target_len = load ${this.sizeType}, ptr %target_len_ptr`, `  %next_len = load ${this.sizeType}, ptr %next_len_ptr`, `  store ${this.sizeType} %next_len, ptr %target_len_ptr`, `  store ${this.sizeType} %target_len, ptr %next_len_ptr`, `  %target_cap_ptr = getelementptr inbounds %ScrArr, ptr %target, i64 0, i32 2`, `  %next_cap_ptr = getelementptr inbounds %ScrArr, ptr %next, i64 0, i32 2`, `  %target_cap = load ${this.sizeType}, ptr %target_cap_ptr`, `  %next_cap = load ${this.sizeType}, ptr %next_cap_ptr`, `  store ${this.sizeType} %next_cap, ptr %target_cap_ptr`, `  store ${this.sizeType} %target_cap, ptr %next_cap_ptr`, `  %target_data_ptr = getelementptr inbounds %ScrArr, ptr %target, i64 0, i32 7`, `  %next_data_ptr = getelementptr inbounds %ScrArr, ptr %next, i64 0, i32 7`, `  %target_data = load ptr, ptr %target_data_ptr`, `  %next_data = load ptr, ptr %next_data_ptr`, `  store ptr %next_data, ptr %target_data_ptr`, `  store ptr %target_data, ptr %next_data_ptr`, `  call void @scr_arr_release(ptr %next)`, `  br label %done`, `done:`, `  ret void`, `}`, ``);
             return `@${commit}`;
         }
         if (t.kind !== "record")
@@ -9758,7 +10419,7 @@ class LlEmitter {
         }
         const sym = `sc_ldu_${this.liveDynUnionRefAdapters.size}`;
         this.liveDynUnionRefAdapters.set(key, sym);
-        this.declare(`declare ptr @scr_dyn_new_typed_ref(ptr, ptr, ptr, ptr, i64, ptr, ptr)`);
+        this.declare(`declare ptr @scr_dyn_new_typed_ref(ptr, ptr, ptr, ptr, ${this.sizeType}, ptr, ptr)`);
         const adapters = new Map();
         for (const { arm, tag } of mutableArms) {
             const prefix = `${sym}_${tag}`;
@@ -9782,7 +10443,7 @@ class LlEmitter {
             const boxed = B.tmp();
             B.line(`${payloadPtr} = getelementptr inbounds %ScrUnion, ptr %u, i64 0, i32 5`);
             B.line(`${payload} = load ptr, ptr ${payloadPtr}`);
-            B.line(`${boxed} = call ptr @scr_dyn_new_typed_ref(ptr ${payload}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${this.cstr(armKey)}, i64 ${Buffer.byteLength(armKey, "utf8")}, ptr @${adapter.snapshot}, ptr ${adapter.commit})`);
+            B.line(`${boxed} = call ptr @scr_dyn_new_typed_ref(ptr ${payload}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${this.cstr(armKey)}, ${this.sizeType} ${Buffer.byteLength(armKey, "utf8")}, ptr @${adapter.snapshot}, ptr ${adapter.commit})`);
             B.terminate(`ret ptr ${boxed}`);
         });
         B.startBlock(fallback);
@@ -9809,8 +10470,8 @@ class LlEmitter {
         const nested = this.streamTypedRefMaterializeAdapter(t, ctx);
         const rc = vAdapters(this, t);
         const key = typeKey(t);
-        this.declare(`declare ptr @scr_dyn_new_typed_ref(ptr, ptr, ptr, ptr, i64, ptr, ptr)`);
-        B.line(`${boxed} = call ptr @scr_dyn_new_typed_ref(ptr ${value}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${this.cstr(key)}, i64 ${Buffer.byteLength(key, "utf8")}, ptr @${nested.snapshot}, ptr ${nested.commit})`);
+        this.declare(`declare ptr @scr_dyn_new_typed_ref(ptr, ptr, ptr, ptr, ${this.sizeType}, ptr, ptr)`);
+        B.line(`${boxed} = call ptr @scr_dyn_new_typed_ref(ptr ${value}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${this.cstr(key)}, ${this.sizeType} ${Buffer.byteLength(key, "utf8")}, ptr @${nested.snapshot}, ptr ${nested.commit})`);
         return boxed;
     }
     /** LLVM twin of the C stream materializer: mutable reference children
@@ -9865,7 +10526,7 @@ class LlEmitter {
             }
             else {
                 this.declare(`declare ptr @scr_dyn_new_obj()`);
-                this.declare(`declare void @scr_dyn_obj_set(ptr, ptr, i64, ptr)`);
+                this.declare(`declare void @scr_dyn_obj_set(ptr, ptr, ${this.sizeType}, ptr)`);
                 const out = B.tmp();
                 B.line(`${out} = call ptr @scr_dyn_new_obj()`);
                 const byName = new Map(shape.fields.map((field) => [field.name, field]));
@@ -9887,7 +10548,7 @@ class LlEmitter {
                         fieldValue = boolValue;
                     }
                     const boxed = this.streamTypedRefBoxValue(B, field.type, fieldValue, ctx);
-                    B.line(`call void @scr_dyn_obj_set(ptr ${out}, ptr ${this.cstr(field.name)}, i64 ${Buffer.byteLength(field.name, "utf8")}, ptr ${boxed})`);
+                    B.line(`call void @scr_dyn_obj_set(ptr ${out}, ptr ${this.cstr(field.name)}, ${this.sizeType} ${Buffer.byteLength(field.name, "utf8")}, ptr ${boxed})`);
                 }
                 B.terminate(`ret ptr ${out}`);
             }
@@ -9994,7 +10655,7 @@ class LlEmitter {
                 B.line(`${boxed} = call ptr @${this.dyn.toDynHelper(elem)}(ptr ${value})`);
             }
             else {
-                this.declare(`declare ptr @scr_dyn_new_typed_ref(ptr, ptr, ptr, ptr, i64, ptr, ptr)`);
+                this.declare(`declare ptr @scr_dyn_new_typed_ref(ptr, ptr, ptr, ptr, ${this.sizeType}, ptr, ptr)`);
                 const boxedSlot = B.slot();
                 B.entryAllocas.push(`${boxedSlot} = alloca ptr`);
                 const tagPtr = B.tmp();
@@ -10016,7 +10677,7 @@ class LlEmitter {
                     const armBoxed = B.tmp();
                     B.line(`${payloadPtr} = getelementptr inbounds %ScrUnion, ptr ${value}, i64 0, i32 5`);
                     B.line(`${payload} = load ptr, ptr ${payloadPtr}`);
-                    B.line(`${armBoxed} = call ptr @scr_dyn_new_typed_ref(ptr ${payload}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${this.cstr(armKey)}, i64 ${Buffer.byteLength(armKey, "utf8")}, ptr @${armSnapshot}, ptr ${armCommit})`);
+                    B.line(`${armBoxed} = call ptr @scr_dyn_new_typed_ref(ptr ${payload}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${this.cstr(armKey)}, ${this.sizeType} ${Buffer.byteLength(armKey, "utf8")}, ptr @${armSnapshot}, ptr ${armCommit})`);
                     B.line(`store ptr ${armBoxed}, ptr ${boxedSlot}`);
                     B.br(join);
                     this.resolveThunkDefs.push(`define internal ptr @${armSnapshot}(ptr %p) ${FN_ATTRS} { ; materialize stream union arm ${armKey}`, `entry:`, `  %d = call ptr @${this.dyn.toDynHelper(arm)}(ptr %p)`, `  ret ptr %d`, `}`, ``);
@@ -10043,8 +10704,8 @@ class LlEmitter {
                 commit = this.streamTypedRefCommitAdapter(elem, snapshot);
                 this.resolveThunkDefs.push(`define internal ptr @${snapshot}(ptr %p) ${FN_ATTRS} { ; materialize stream element ${key}`, `entry:`, `  %d = call ptr @${this.dyn.toDynHelper(elem)}(ptr %p)`, `  ret ptr %d`, `}`, ``);
             }
-            this.declare(`declare ptr @scr_dyn_new_typed_ref(ptr, ptr, ptr, ptr, i64, ptr, ptr)`);
-            B.line(`${boxed} = call ptr @scr_dyn_new_typed_ref(ptr ${value}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${keyPtr}, i64 ${Buffer.byteLength(key, "utf8")}, ptr @${snapshot}, ptr ${commit})`);
+            this.declare(`declare ptr @scr_dyn_new_typed_ref(ptr, ptr, ptr, ptr, ${this.sizeType}, ptr, ptr)`);
+            B.line(`${boxed} = call ptr @scr_dyn_new_typed_ref(ptr ${value}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${keyPtr}, ${this.sizeType} ${Buffer.byteLength(key, "utf8")}, ptr @${snapshot}, ptr ${commit})`);
         }
         else {
             boxed = B.tmp();
@@ -10785,16 +11446,16 @@ class LlEmitter {
             const tag6 = infoDef.arms.findIndex((a) => a.kind === "record" && this.recordsById.get(a.shapeId)?.fields.find((f) => f.name === "scopeid")?.type.kind === "f64");
             const tag4 = 1 - tag6;
             this.declare(`declare ptr @scr_os_ifaddrs()`);
-            this.declare(`declare i64 @scr_os_ifaddrs_count(ptr)`);
-            this.declare(`declare ptr @scr_os_ifaddrs_name(ptr, i64)`);
-            this.declare(`declare ptr @scr_os_ifaddrs_address(ptr, i64)`);
-            this.declare(`declare ptr @scr_os_ifaddrs_netmask(ptr, i64)`);
-            this.declare(`declare ptr @scr_os_ifaddrs_family(ptr, i64)`);
-            this.declare(`declare ptr @scr_os_ifaddrs_mac(ptr, i64)`);
-            this.declare(`declare zeroext i1 @scr_os_ifaddrs_internal(ptr, i64)`);
-            this.declare(`declare zeroext i1 @scr_os_ifaddrs_ipv6(ptr, i64)`);
-            this.declare(`declare ptr @scr_os_ifaddrs_cidr(ptr, i64)`);
-            this.declare(`declare double @scr_os_ifaddrs_scopeid(ptr, i64)`);
+            this.declare(`declare ${this.sizeType} @scr_os_ifaddrs_count(ptr)`);
+            this.declare(`declare ptr @scr_os_ifaddrs_name(ptr, ${this.sizeType})`);
+            this.declare(`declare ptr @scr_os_ifaddrs_address(ptr, ${this.sizeType})`);
+            this.declare(`declare ptr @scr_os_ifaddrs_netmask(ptr, ${this.sizeType})`);
+            this.declare(`declare ptr @scr_os_ifaddrs_family(ptr, ${this.sizeType})`);
+            this.declare(`declare ptr @scr_os_ifaddrs_mac(ptr, ${this.sizeType})`);
+            this.declare(`declare zeroext i1 @scr_os_ifaddrs_internal(ptr, ${this.sizeType})`);
+            this.declare(`declare zeroext i1 @scr_os_ifaddrs_ipv6(ptr, ${this.sizeType})`);
+            this.declare(`declare ptr @scr_os_ifaddrs_cidr(ptr, ${this.sizeType})`);
+            this.declare(`declare double @scr_os_ifaddrs_scopeid(ptr, ${this.sizeType})`);
             this.declare(`declare void @scr_os_ifaddrs_free(ptr)`);
             this.declare(`declare ptr @scr_union_new_ref(i32, ptr, ptr, ptr, ptr)`);
             this.declare(`declare ptr @scr_union_retain_v(ptr)`);
@@ -10813,11 +11474,11 @@ class LlEmitter {
             const snap = B.tmp();
             const cnt = B.tmp();
             B.line(`${snap} = call ptr @scr_os_ifaddrs()`);
-            B.line(`${cnt} = call i64 @scr_os_ifaddrs_count(ptr ${snap})`);
+            B.line(`${cnt} = call ${this.sizeType} @scr_os_ifaddrs_count(ptr ${snap})`);
             const iSlot = B.slot();
             const rowSlot = B.slot();
-            B.entryAllocas.push(`${iSlot} = alloca i64`, `${rowSlot} = alloca ptr`);
-            B.line(`store i64 0, ptr ${iSlot}`);
+            B.entryAllocas.push(`${iSlot} = alloca ${this.sizeType}`, `${rowSlot} = alloca ptr`);
+            B.line(`store ${this.sizeType} 0, ptr ${iSlot}`);
             const lc = B.newLabel("ni.c");
             const lb = B.newLabel("ni.b");
             const le = B.newLabel("ni.e");
@@ -10825,12 +11486,12 @@ class LlEmitter {
             B.startBlock(lc);
             const i = B.tmp();
             const cont = B.tmp();
-            B.line(`${i} = load i64, ptr ${iSlot}`);
-            B.line(`${cont} = icmp ult i64 ${i}, ${cnt}`);
+            B.line(`${i} = load ${this.sizeType}, ptr ${iSlot}`);
+            B.line(`${cont} = icmp ult ${this.sizeType} ${i}, ${cnt}`);
             B.condBr(cont, lb, le);
             B.startBlock(lb);
             const isV6 = B.tmp();
-            B.line(`${isV6} = call zeroext i1 @scr_os_ifaddrs_ipv6(ptr ${snap}, i64 ${i})`);
+            B.line(`${isV6} = call zeroext i1 @scr_os_ifaddrs_ipv6(ptr ${snap}, ${this.sizeType} ${i})`);
             const l6 = B.newLabel("ni.v6");
             const l4 = B.newLabel("ni.v4");
             const lRow = B.newLabel("ni.r");
@@ -10857,14 +11518,14 @@ class LlEmitter {
                     ["mac", "scr_os_ifaddrs_mac"],
                 ]) {
                     const v = B.tmp();
-                    B.line(`${v} = call ptr @${sym}(ptr ${snap}, i64 ${i}) ; +1`);
+                    B.line(`${v} = call ptr @${sym}(ptr ${snap}, ${this.sizeType} ${i}) ; +1`);
                     B.line(`store ptr ${v}, ptr ${this.recordFieldPtr(r, t.shapeId, field).ptr}`);
                 }
                 const internal = B.tmp();
-                B.line(`${internal} = call zeroext i1 @scr_os_ifaddrs_internal(ptr ${snap}, i64 ${i})`);
+                B.line(`${internal} = call zeroext i1 @scr_os_ifaddrs_internal(ptr ${snap}, ${this.sizeType} ${i})`);
                 this.storeField(this.recordFieldPtr(r, t.shapeId, "internal").ptr, { kind: "bool" }, internal);
                 const cs = B.tmp();
-                B.line(`${cs} = call ptr @scr_os_ifaddrs_cidr(ptr ${snap}, i64 ${i}) ; +1 or null`);
+                B.line(`${cs} = call ptr @scr_os_ifaddrs_cidr(ptr ${snap}, ${this.sizeType} ${i}) ; +1 or null`);
                 const hasCidr = B.tmp();
                 B.line(`${hasCidr} = icmp ne ptr ${cs}, null`);
                 const lcs = B.newLabel("ni.cs");
@@ -10889,7 +11550,7 @@ class LlEmitter {
                 B.line(`store ptr ${cv}, ptr ${this.recordFieldPtr(r, t.shapeId, "cidr").ptr}`);
                 if (v6) {
                     const sc = B.tmp();
-                    B.line(`${sc} = call double @scr_os_ifaddrs_scopeid(ptr ${snap}, i64 ${i})`);
+                    B.line(`${sc} = call double @scr_os_ifaddrs_scopeid(ptr ${snap}, ${this.sizeType} ${i})`);
                     this.storeField(this.recordFieldPtr(r, t.shapeId, "scopeid").ptr, F64, sc);
                 }
                 else {
@@ -10915,7 +11576,7 @@ class LlEmitter {
             const row = B.tmp();
             B.line(`${row} = load ptr, ptr ${rowSlot}`);
             const nm = B.tmp();
-            B.line(`${nm} = call ptr @scr_os_ifaddrs_name(ptr ${snap}, i64 ${i}) ; +1`);
+            B.line(`${nm} = call ptr @scr_os_ifaddrs_name(ptr ${snap}, ${this.sizeType} ${i}) ; +1`);
             const cell = B.tmp();
             B.line(`${cell} = call ptr @scr_map_get_str_ref(ptr ${ovf}, ptr ${nm})`);
             const hasCell = B.tmp();
@@ -10951,8 +11612,8 @@ class LlEmitter {
             B.line(`call void @scr_arr_release(ptr ${rows})`);
             B.line(`call void @scr_str_release(ptr ${nm})`);
             const i2 = B.tmp();
-            B.line(`${i2} = add i64 ${i}, 1`);
-            B.line(`store i64 ${i2}, ptr ${iSlot}`);
+            B.line(`${i2} = add ${this.sizeType} ${i}, 1`);
+            B.line(`store ${this.sizeType} ${i2}, ptr ${iSlot}`);
             B.br(lc);
             B.startBlock(le);
             B.line(`call void @scr_os_ifaddrs_free(ptr ${snap})`);
@@ -10969,21 +11630,21 @@ class LlEmitter {
             const recT = e.type.elem;
             const path = this.emitExpr(e.args[0]);
             this.declare(`declare ptr @scr_fs_scandir(ptr)`);
-            this.declare(`declare i64 @scr_fs_scandir_count(ptr)`);
-            this.declare(`declare ptr @scr_fs_scandir_name(ptr, i64)`);
-            this.declare(`declare double @scr_fs_scandir_type(ptr, i64)`);
+            this.declare(`declare ${this.sizeType} @scr_fs_scandir_count(ptr)`);
+            this.declare(`declare ptr @scr_fs_scandir_name(ptr, ${this.sizeType})`);
+            this.declare(`declare double @scr_fs_scandir_type(ptr, ${this.sizeType})`);
             this.declare(`declare void @scr_fs_scandir_free(ptr)`);
             const snap = B.tmp();
             B.line(`${snap} = call ptr @scr_fs_scandir(ptr ${path.name})`);
             this.emitPendingCheck();
             const cnt = B.tmp();
-            B.line(`${cnt} = call i64 @scr_fs_scandir_count(ptr ${snap})`);
+            B.line(`${cnt} = call ${this.sizeType} @scr_fs_scandir_count(ptr ${snap})`);
             const arr = B.tmp();
             B.line(`${arr} = ${arrNewCall(this, recT, cnt)}`);
             const out = this.own({ name: arr, type: e.type });
             const iSlot = B.slot();
-            B.entryAllocas.push(`${iSlot} = alloca i64`);
-            B.line(`store i64 0, ptr ${iSlot}`);
+            B.entryAllocas.push(`${iSlot} = alloca ${this.sizeType}`);
+            B.line(`store ${this.sizeType} 0, ptr ${iSlot}`);
             const lc = B.newLabel("sd.c");
             const lb = B.newLabel("sd.b");
             const le = B.newLabel("sd.e");
@@ -10991,23 +11652,23 @@ class LlEmitter {
             B.startBlock(lc);
             const i = B.tmp();
             const cont = B.tmp();
-            B.line(`${i} = load i64, ptr ${iSlot}`);
-            B.line(`${cont} = icmp ult i64 ${i}, ${cnt}`);
+            B.line(`${i} = load ${this.sizeType}, ptr ${iSlot}`);
+            B.line(`${cont} = icmp ult ${this.sizeType} ${i}, ${cnt}`);
             B.condBr(cont, lb, le);
             B.startBlock(lb);
             const row = B.tmp();
             B.line(`${row} = call ptr @${mangleRecordNew(recT.shapeId)}()`);
             const dt = B.tmp();
-            B.line(`${dt} = call double @scr_fs_scandir_type(ptr ${snap}, i64 ${i})`);
+            B.line(`${dt} = call double @scr_fs_scandir_type(ptr ${snap}, ${this.sizeType} ${i})`);
             this.storeField(this.recordFieldPtr(row, recT.shapeId, "%dtype").ptr, F64, dt);
             const nm = B.tmp();
-            B.line(`${nm} = call ptr @scr_fs_scandir_name(ptr ${snap}, i64 ${i}) ; +1`);
+            B.line(`${nm} = call ptr @scr_fs_scandir_name(ptr ${snap}, ${this.sizeType} ${i}) ; +1`);
             B.line(`store ptr ${nm}, ptr ${this.recordFieldPtr(row, recT.shapeId, "name").ptr}`);
             B.line(`store ptr ${this.retainValue(path.name, STRING)}, ptr ${this.recordFieldPtr(row, recT.shapeId, "parentPath").ptr}`);
             this.arrPush(arr, "ref", row); // push takes ownership of the row
             const i2 = B.tmp();
-            B.line(`${i2} = add i64 ${i}, 1`);
-            B.line(`store i64 ${i2}, ptr ${iSlot}`);
+            B.line(`${i2} = add ${this.sizeType} ${i}, 1`);
+            B.line(`store ${this.sizeType} ${i2}, ptr ${iSlot}`);
             B.br(lc);
             B.startBlock(le);
             B.line(`call void @scr_fs_scandir_free(ptr ${snap})`);
@@ -11077,22 +11738,19 @@ class LlEmitter {
         }
         if (e.fn === "emitter.emit") {
             // The variadic dispatch: the event's unified tuple rides the C
-            // variadic tail POINTER-CLASSED (f64 as its i64 bit pattern, bool
-            // zero-extended — scr_runtime.h's fixed-shim contract; the emitted
-            // adapters re-type on the way out), every argument borrowed. May
+            // variadic tail POINTER-CLASSED. Scalar values ride pointers to
+            // call-lived stack slots, while reference values ride directly; the
+            // fixed shim can therefore read one pointer-width slot per argument
+            // on both wasm32 and native targets. Every argument is borrowed. May
             // throw (listeners run inside).
             const args = e.args.map((a) => this.emitExpr(a));
             const tuple = args.slice(2).map((a) => {
                 const ty = this.llType(a.type);
-                if (ty === "double") {
-                    const x = B.tmp();
-                    B.line(`${x} = bitcast double ${a.name} to i64`);
-                    return `i64 ${x}`;
-                }
-                if (ty === "i1") {
-                    const x = B.tmp();
-                    B.line(`${x} = zext i1 ${a.name} to i64`);
-                    return `i64 ${x}`;
+                if (ty === "double" || ty === "i1") {
+                    const slot = B.slot();
+                    B.entryAllocas.push(`${slot} = alloca ${ty} ; EventEmitter scalar argument`);
+                    B.line(`store ${ty} ${a.name}, ptr ${slot}`);
+                    return `ptr ${slot}`;
                 }
                 return `ptr ${a.name}`;
             });
@@ -11681,13 +12339,13 @@ class LlEmitter {
                 throw new Error("llvm emitter bug: net.serverCloseBind result not a func");
             const args = e.args.map((a) => this.emitExpr(a));
             const fnSym = this.closeBindThunkFor(e.type.params[0], e.type.ret.kind === "netServer");
-            this.declare(`declare ptr @scr_closure_new(ptr, i64)`);
+            this.declare(`declare ptr @scr_closure_new(ptr, ${this.sizeType})`);
             this.declare(`declare ptr @scr_box_new_obj(ptr, ptr, ptr)`);
             this.declare(`declare void @scr_box_set_ref(ptr, ptr)`);
             this.declare(`declare ptr @scr_net_server_retain_v(ptr)`);
             this.declare(`declare void @scr_net_server_release_v(ptr)`);
             const bound = B.tmp();
-            B.line(`${bound} = call ptr @scr_closure_new(ptr @${fnSym}, i64 1)`);
+            B.line(`${bound} = call ptr @scr_closure_new(ptr @${fnSym}, ${this.sizeType} 1)`);
             const bx = B.tmp();
             B.line(`${bx} = call ptr @scr_box_new_obj(ptr @scr_net_server_retain_v, ptr @scr_net_server_release_v, ptr null)`);
             const capp = B.tmp();
@@ -11988,22 +12646,22 @@ class LlEmitter {
                 if (ca.type.kind === "string") {
                     caData = B.tmp();
                     B.line(`${caLenPtr} = getelementptr inbounds %ScrStr, ptr ${ca.name}, i64 0, i32 1`);
-                    B.line(`${caLen} = load i64, ptr ${caLenPtr}`);
-                    B.line(`${caData} = getelementptr inbounds i8, ptr ${ca.name}, i64 24`);
+                    B.line(`${caLen} = load ${this.sizeType}, ptr ${caLenPtr}`);
+                    B.line(`${caData} = getelementptr inbounds i8, ptr ${ca.name}, i64 ${this.abiOffset(24, 12)}`);
                 }
                 else if (ca.type.kind === "bytes" && ca.type.elem === "u8") {
                     const caDataPtr = B.tmp();
                     caData = B.tmp();
-                    B.line(`${caLenPtr} = getelementptr inbounds i8, ptr ${ca.name}, i64 8`);
-                    B.line(`${caLen} = load i64, ptr ${caLenPtr}`);
-                    B.line(`${caDataPtr} = getelementptr inbounds i8, ptr ${ca.name}, i64 24`);
+                    B.line(`${caLenPtr} = getelementptr inbounds i8, ptr ${ca.name}, i64 ${this.abiOffset(8, 4)}`);
+                    B.line(`${caLen} = load ${this.sizeType}, ptr ${caLenPtr}`);
+                    B.line(`${caDataPtr} = getelementptr inbounds i8, ptr ${ca.name}, i64 ${this.abiOffset(24, 12)}`);
                     B.line(`${caData} = load ptr, ptr ${caDataPtr}`);
                 }
                 else {
                     throw new Error(`llvm emitter bug: ${e.fn} CA is not a string or Buffer`);
                 }
-                callArgs = [...callArgs.slice(0, 8), `ptr ${caData}`, `i64 ${caLen}`];
-                this.declare(`declare ptr @scr_https_request(ptr, double, ptr, ptr, double, ptr, i1 zeroext, i1 zeroext, ptr, i64, ptr, ptr)`);
+                callArgs = [...callArgs.slice(0, 8), `ptr ${caData}`, `${this.sizeType} ${caLen}`];
+                this.declare(`declare ptr @scr_https_request(ptr, double, ptr, ptr, double, ptr, i1 zeroext, i1 zeroext, ptr, ${this.sizeType}, ptr, ptr)`);
             }
             else {
                 const decls = head.map((a) => (this.llType(a.type) === "i1" ? "i1 zeroext" : this.llType(a.type)));