@scriptc/compiler 0.1.7 → 0.2.1

package/dist/backend/llvm/emitter.js

@@ -1,81 +1,40 @@
+import { emitLlvmLayouts } from "./layouts.js";
+import { llvmBytes as llBytes } from "../literals.js";
 import { InternalCompilerError } from "../../errors.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). Its textual module is either lowered by scriptc's native
- * helper and linked with a runtime pack or occupies the legacy compiler
- * driver's program-TU seat. Both paths use the same scr_* C ABI.
+/** Lower typed IR to LLVM, using the runtime's 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.
+ * Reference-counted temporaries own one reference. Declarations, assignments,
+ * returns and arguments move that ownership; frame and scope exits release
+ * everything remaining. Slot-backed entries release the slot's current value.
  *
- * 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 use a pending flag and explicit cleanup edges. Throwing calls
+ * test scr_exc_pending before consuming results, release the scopes crossed,
+ * and branch to the innermost handler or return to the caller. Catch bindings
+ * hold ScrCaught snapshots; finally runs on normal, throwing and returning
+ * paths. This keeps ownership cleanup intact without nonlocal jumps.
  *
- * 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 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 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.
+ * Program objects are emitted by the packaged LLVM helper and linked with
+ * runtime packs. Sanitizer development builds use an external LLVM driver.
+ * Dynamic values and islands share the runtime ABI; embedded npm modules use
+ * compressed source tables that the runtime inflates on demand.
  */
 import { deflateRawSync } from "node:zlib";
 import { endsWithJump, matchStringSelfConcat, streamTypedRefEligible } from "../../ir/analysis.js";
 import { emitLibraryIdentityLines } from "../library-identity-markers.js";
-import { CAUGHT, ffiCallbackType, isDynTypedRefType, isFfiContextParam, isRefCounted, isUnitType, moduleEmbedsBuiltin, moduleEmbedsCompressedNpm, moduleUsesChildProcess, moduleUsesDynInvoke, moduleUsesFetch, moduleUsesFsWatch, moduleUsesHttpServer, moduleUsesNet, moduleUsesNodeTest, moduleUsesProcessEvents, moduleUsesStream, moduleUsesTls, moduleUsesTlsCa, NPM_COMPRESS_MIN, POINTER_KINDS, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, typeKey, VOID } from "../../ir/ir.js";
+import { CAUGHT, ffiCallbackType, isDynTypedRefType, isFfiContextParam, isRefCounted, isUnitType, moduleRuntimeFeatures, moduleEmbedsBuiltin, moduleEmbedsCompressedNpm, NPM_COMPRESS_MIN, POINTER_KINDS, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, typeKey, VOID } from "../../ir/ir.js";
 import { matchIntegerBytesForLoop } from "../../ir/integer-loops.js";
 import { scalarizeNumericRecords } from "../../ir/scalar-records.js";
+import { everyStmtList } from "../../ir/traverse.js";
 import { analyzeIntegerRanges } from "../../ir/integer-ranges.js";
 import { findConstantNumericTables } from "../../ir/constant-tables.js";
 import { allocateFfiCallbackAdapters, hasForeignFfiCallback, hasRetainedFfiCallback } from "../ffi-callbacks.js";
 import { RUNTIME_ABI_MARKER } from "../runtime-abi.js";
-import { computeMayThrow } from "../c/may-throw.js";
-import { mangleArgPack, mangleAsyncSpawn, mangleClassObj, mangleFnClosure, mangleFunction, mangleGenDrop, mangleGenSpawn, mangleGlobal, mangleLocal, mangleRecordStruct, mangleTrampoline, mangleWrapper } from "../mangle.js";
+import { computeMayThrow } from "../may-throw.js";
+import { mangleArgPack, mangleAsyncSpawn, mangleClassObj, mangleClassStruct, mangleFnClosure, mangleFunction, mangleGenDrop, mangleGenSpawn, mangleGlobal, mangleLocal, mangleRecordStruct, mangleTrampoline, mangleWrapper, mangleVtInstance } from "../mangle.js";
 import { BlockBuilder } from "./blocks.js";
 import { LlvmDebugInfo } from "./debug-info.js";
-import { f64Lit, ffiNativeTypeLl, llvmCommentText } from "./common.js";
+import { f64Lit, ffiNativeTypeLl, ffiNativeParamLl, ffiNativeReturnLl, llvmCommentText } from "./common.js";
+import { ffiExtendsNarrowIntegers } from "../targets.js";
 import { emitLiteralExpr, emitOperatorExpr, emitStringExpr, emitContainerExpr, emitRecordExpr } from "./expr-primitives.js";
 import { emitControlExpr } from "./expr-control.js";
 import { emitCallExpr } from "./expr-calls.js";
@@ -94,21 +53,32 @@ import { emitChildProcessLibCall, emitAsyncContextLibCall, emitProcessLibCall, e
 import { emitStreamLibCall } from "./lib-stream.js";
 import { emitNetworkHttpLibCall } from "./lib-network.js";
 import { emitAssertInspectLibCall, emitIoLibCall, emitGenericLibCall, emitLibCall } from "./lib-dispatch.js";
-import { buildClassGraph, classFieldIndex, classStructSym, emitClassObjDefs, emitClassShapes, } from "./classes.js";
+import { buildClassGraph, classEnvironmentIndex, classFieldIndex, classStructSym, } from "./classes.js";
 import { LlDyn } from "./dyn.js";
 import { LlvmUnsupportedError } from "./unsupported.js";
 import { LlWalkers } from "./walkers.js";
-import { arrNewCall, boxAccess, boxNewCall, computeTraced, elemAccess, emitRecordShapes, FN_ATTRS, llFieldType, releaseSym, retainSym, traceArg, vAdapters, } from "./shapes.js";
+import { arrNewCall, boxAccess, boxNewCall, computeTraced, elemAccess, FN_ATTRS, llFieldType, releaseSym, retainSym, traceArg, typedRefConstructor, vAdapters, } from "./shapes.js";
 export { LlvmUnsupportedError } from "./unsupported.js";
 function ffiCallbackDummyLl(callback) {
     switch (callback.returns) {
+        case "i64":
+        case "u64":
+            return "i64 0";
+        case "pointer":
+            return "ptr null";
         case "void":
             return "void";
         case "f64":
             return "double 0.0";
+        case "f32":
+            return "float 0.0";
         case "bool":
         case "u8":
+        case "i8":
             return "i8 0";
+        case "u16":
+        case "i16":
+            return "i16 0";
         case "u32":
         case "i32":
             return "i32 0";
@@ -118,39 +88,28 @@ export function emitLlvmModule(mod, options = {}) {
     // Keep source storage intact for debugger inspection in dev builds.
     return new LlEmitter(options.debugSources === undefined ? scalarizeNumericRecords(mod) : mod, options).emit();
 }
-/** LLVM c"..." payload for a UTF-8 literal, NUL-terminated like the C
- * emitter's flexible-array-member initializer. */
-function llBytes(bytes) {
-    let s = "";
-    for (const b of bytes) {
-        s +=
-            b >= 0x20 && b < 0x7f && b !== 0x22 && b !== 0x5c
-                ? String.fromCharCode(b)
-                : `\\${b.toString(16).padStart(2, "0").toUpperCase()}`;
-    }
-    return `${s}\\00`;
-}
 function llStrBytes(text) {
     return llBytes(Buffer.from(text, "utf8"));
 }
-class LlEmitter {
+export class LlEmitter {
     mod;
     debug;
     debugScope = null;
     sizeType;
+    ffiExtendNarrowIntegers;
     cycleColorOffset;
     wasi;
     emitLibraryIdentity;
     runtimeAbiMarker;
     /** Interned string literals: UTF-8 text → { symbol, byte length } —
-     * first-use order, the C emitter's determinism discipline. */
+     * first-use order, the runtime ABI’s determinism discipline. */
     literals = new Map();
     /** Interned unit-armed union instances: "unionId:tag" → symbol — one
-     * immortal (rc == SIZE_MAX) static per (union, unit tag), exactly the
-     * C emitter's table. RC entry points and the collector skip immortals. */
+     * immortal (rc == SIZE_MAX) static per (union, unit tag).
+     * RC entry points and the collector skip immortals. */
     unitInstances = new Map();
-    /** Interned regex literals: "<flags>/<pattern>" → { symbol, interned
-     * source/flags literal refs } — one immortal ScrRegex per distinct
+    /** Regex literal templates: "<flags>/<pattern>" → { symbol, interned
+     * source/flags literal refs } — one immortal ScrRegex template per distinct
      * (pattern, flags) pair; the bytecode slot starts null and the runtime
      * compiles it lazily on first use. The source/flags strings intern at
      * REGISTRATION (bodies emit before the literal table flushes). */
@@ -166,10 +125,12 @@ class LlEmitter {
     /** Type-directed walker functions (JSON serializers, the indent
      * rewriter, union ToString/join) — interned per typeKey/unionId, defs
      * flushed with the shape helpers. */
-    walkers = new LlWalkers(this);
+    walkers;
     /** The dyn (ScrDyn dyn) helper registry — dyn.ts's interned ports of
      * walkers.ts's dyn slice. */
-    dyn = new LlDyn(this);
+    dyn;
+    /** Explicit callback boundary for standalone layout and walker stages. */
+    shapeHost;
     /** External declarations, in first-use order. */
     decls = new Set();
     /** Declared functions referenced as values: each needs an env-signature
@@ -192,19 +153,20 @@ class LlEmitter {
     ffiHasRetainedCallback;
     ffiHasForeignCallback;
     globalTypes = new Map();
+    tdzGlobals = new Map();
     constantNumericTables;
-    /** May-throw analysis (the C emitter's computeMayThrow, shared): pending
+    /** May-throw analysis (computeMayThrow): pending
      * checks are emitted only after calls that can actually raise. */
     mayThrow;
     indirectMayThrow;
     /** Method names with at least one may-throw implementation — the
-     * virtualCall pending check's key (CEmitter.mayThrowMethods). */
+     * virtualCall pending check's key. */
     mayThrowMethods = new Set();
     /** setTimeout and friends appeared somewhere: main must run the event
-     * loop even in programs with no async functions (CEmitter.usesTimers). */
+     * loop even in programs with no async functions. */
     usesTimers = false;
     /** Emitted ref-kind resolve thunks for new Promise, interned per inner
-     * typeKey → thunk symbol (CEmitter.resolveThunks). */
+     * typeKey → thunk symbol. */
     resolveThunks = new Map();
     resolveThunkDefs = [];
     /** ReadableStream.from adapters keep typed arrays by reference and box
@@ -222,15 +184,16 @@ class LlEmitter {
     tracedShapes;
     tracedUnions;
     /** The class graph (buildClassGraph): preorder numbering, hierarchy
-     * membership, virtual slot lists — the CEmitter classMeta, ported. */
+     * membership, virtual slot lists. */
     classMeta;
     /** Class objects (classes as first-class values): className → the
      * interned .name literal ref — registered during body emission, the
      * statics and construct thunks assemble around the bodies. */
     classObjs = new Map();
+    unionFieldReadGroups = new Map();
     /** Preorder intervals of the runtime error classes under THIS module's
      * class-forest numbering (main() stamps scr_error_vts with them, exactly
-     * like the C emitter's errorVtStampLines). */
+     * like the runtime ABI’s errorVtStampLines). */
     errorIntervals = [];
     /** The runtime emitter vtable's preorder interval, when the program
      * touches node:events (the class def rides the module exactly then) —
@@ -245,6 +208,10 @@ class LlEmitter {
     B = new BlockBuilder();
     frames = [];
     scopes = [];
+    /** Scope slots dominate every throw site. Share their exceptional cleanup
+     * for identical live bindings and handlers; statement temporaries stay at
+     * their own throw sites because their SSA values are path-dependent. */
+    unwindCleanups = new Map();
     /** Enclosing break/continue targets. `kind` separates loops from
      * switches and labeled blocks: an unlabeled break binds to the innermost
      * NON-BLOCK entry (loop or switch — blocks only enter the stack when
@@ -260,7 +227,7 @@ class LlEmitter {
     integerRanges = new Map();
     /** Enclosing try-with-FINALLY regions, innermost last: a `return`
      * inside one runs every crossed finally (innermost first) before the
-     * actual ret — the C emitter's pending-return path, with the finally
+     * actual ret — the runtime ABI’s pending-return path, with the finally
      * bodies emitted inline at the return site instead of behind a goto.
      * `tryDepth` snapshots tryStack.length at region entry: a throw inside
      * a pending-return finally copy propagates OUT of the completing try
@@ -269,7 +236,7 @@ class LlEmitter {
      * emitFinallysForJump. */
     finallyStack = [];
     /** Enclosing try contexts, innermost last — the compile-time unwind
-     * targets (CEmitter.tryStack): a pending check or `throw` inside a try
+     * targets: a pending check or `throw` inside a try
      * releases frames/scopes down to the recorded depths and branches to
      * `label` (the catch, or the exception-path finally) instead of
      * returning out of the function. Entering a try emits no code. */
@@ -287,17 +254,22 @@ class LlEmitter {
     /** Active optional-chain bind slots, by chain id (chainRecv reads). */
     chainSlots = new Map();
     logArgSlots = 0;
+    stackTraces;
     constructor(mod, options) {
         this.mod = mod;
+        this.stackTraces = mod.functions.some((fn) => !everyStmtList(fn.body, {
+            stmt: () => true, expr: (expr) => !(expr.kind === "libCall" && expr.fn === "error.stack"),
+        }));
         this.debug = options.debugSources === undefined ? null : new LlvmDebugInfo(mod.sourceFile, options.debugSources, options.pointerBits, mod.unions);
         this.constantNumericTables = findConstantNumericTables(mod);
         this.sizeType = options.pointerBits === 32 ? "i32" : "i64";
+        this.ffiExtendNarrowIntegers = options.wasi === true || ffiExtendsNarrowIntegers(options.targetTriple);
         this.wasi = options.wasi === true;
         this.emitLibraryIdentity = options.emitLibraryIdentity !== false;
         this.runtimeAbiMarker = options.runtimeAbiMarker === 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.
+        // ScrCycHdr.color stays 12 bytes behind a wasm32 object and 16 bytes
+        // behind a 64-bit object. The wasm32 header pads before color so its
+        // payload remains double-aligned without changing this ABI offset.
         this.cycleColorOffset = options.pointerBits === 32 ? 12 : 16;
         this.ffiCallbackAdapters = allocateFfiCallbackAdapters(mod.ffiImports ?? []);
         this.ffiHasRetainedCallback = hasRetainedFfiCallback(mod.ffiImports ?? []);
@@ -323,11 +295,35 @@ class LlEmitter {
         const traced = computeTraced(mod);
         this.tracedShapes = traced.shapes;
         this.tracedUnions = traced.unions;
+        this.shapeHost = {
+            sizeType: this.sizeType,
+            cycleColorOffset: this.cycleColorOffset,
+            tracedShapes: this.tracedShapes,
+            tracedUnions: this.tracedUnions,
+            recordsById: this.recordsById,
+            recordCloneShapes: this.recordCloneShapes,
+            unionsById: this.unionsById,
+            declare: (decl) => this.declare(decl),
+            needOom: () => this.needOom(),
+            needBadTag: () => this.needBadTag(),
+            internLiteral: (text) => this.internLiteral(text),
+            cstr: (text) => this.cstr(text),
+            unitInstanceRef: (unionId, tag) => this.unitInstanceRef(unionId, tag),
+            liveDynRefAdapter: (type) => this.liveDynRefAdapter(type),
+            dynPromiseAdapter: (type) => this.dynPromiseAdapter(type),
+            isErrorClass: (name) => this.classMeta.get(name)?.root.def.name === "%Error",
+            classSubtypes: (name) => {
+                const target = this.classMetaOf(name);
+                return [...this.classMeta.values()].filter((meta) => target.pre <= meta.pre && meta.pre <= target.post).map((meta) => meta.def.name);
+            },
+        };
+        this.walkers = new LlWalkers(this.shapeHost);
+        this.dyn = new LlDyn(this.shapeHost);
         for (const g of mod.globals ?? []) {
             // Module globals: scalar (f64/bool) storage is a zero-initialized
             // LLVM global, ref-kind storage a null-initialized ptr — load/store
             // like a local, assigned by the %init functions. Refcounted globals
-            // are released at the end of main (the C emitter's
+            // are released at the end of main (the runtime ABI’s
             // sc_release_globals), before the RC audit would run.
             try {
                 this.llType(g.type); // refuses out-of-tier kinds
@@ -338,12 +334,11 @@ class LlEmitter {
                 throw err;
             }
             this.globalTypes.set(g.id, g.type);
+            if (g.tdz)
+                this.tdzGlobals.set(g.id, g.name);
         }
-        // User classes are IN the tier (phase 3), and so are the runtime
-        // error classes and the runtime EventEmitter/stream classes (phase 6
-        // — subclasses embed the ScrEmitter/ScrStream prefixes, classes.ts).
-        // Anything else runtime-flagged refuses by name, exactly the
-        // classDef:* histogram key.
+        // Runtime error, EventEmitter, and stream classes have known layouts.
+        // Subclasses embed the ScrEmitter/ScrStream prefixes from classes.ts.
         const classes = mod.classes ?? [];
         for (const cls of classes) {
             if (cls.runtime &&
@@ -354,9 +349,8 @@ class LlEmitter {
             }
         }
         // The class graph: base/children links, hierarchy membership, the
-        // whole-program preorder numbering (identical to CEmitter's, so
-        // runtime-made and compiled error objects agree on instanceof through
-        // either backend), and the per-hierarchy virtual slot lists.
+        // whole-program preorder numbering for instanceof over runtime and
+        // compiled error objects, and the per-hierarchy virtual slot lists.
         this.classMeta = buildClassGraph(mod, this.fnByName);
         for (const [name, rec] of RUNTIME_ERROR_CLASSES) {
             const meta = this.classMeta.get(name);
@@ -384,7 +378,7 @@ class LlEmitter {
     }
     // ── types ───────────────────────────────────────────────────────────────
     llType(t) {
-        if (POINTER_KINDS.has(t.kind) && t.kind !== "http2Session" && t.kind !== "http2Stream")
+        if (POINTER_KINDS.has(t.kind))
             return "ptr";
         switch (t.kind) {
             case "f64":
@@ -427,7 +421,7 @@ class LlEmitter {
             if (adapter.tls !== null)
                 globals.push(`@${adapter.tls} = internal thread_local global ptr null`);
             if (adapter.global !== null)
-                globals.push(`@${adapter.global} = internal global ptr null`);
+                globals.push(`@${adapter.global} = internal thread_local global ptr null`);
             if (adapter.table !== null) {
                 globals.push(`@${adapter.table} = internal global %ScrFfiTable zeroinitializer`);
             }
@@ -437,11 +431,11 @@ class LlEmitter {
                 if (param === "string" || param === "bytes") {
                     return [`ptr %a${i}`, `${this.sizeType} %a${i}_len`];
                 }
-                return [`${ffiNativeTypeLl(param)} %a${i}`];
+                return [`${ffiNativeParamLl(param, this.ffiExtendNarrowIntegers)} %a${i}`];
             });
-            const ret = ffiNativeTypeLl(cb.returns);
             if (cb.invoke === "foreign") {
-                if (adapter.table === null || !cb.params.some(isFfiContextParam) || cb.returns !== "void") {
+                if (adapter.table === null || !cb.params.some(isFfiContextParam) || cb.returns !== "void" ||
+                    cb.params.some(param => param === "i64" || param === "u64" || param === "pointer")) {
                     throw new InternalCompilerError("llvm emitter bug: invalid foreign FFI callback descriptor");
                 }
                 const dispatch = `${adapter.symbol}_dispatch`;
@@ -458,6 +452,10 @@ class LlEmitter {
                         continue;
                     switch (param) {
                         case "f64":
+                        case "f32":
+                        case "i8":
+                        case "u16":
+                        case "i16":
                             this.declare(`declare double @scr_ffi_call_get_f64(ptr, ${this.sizeType})`);
                             dispatchBody.push(`  %s${i} = call double @scr_ffi_call_get_f64(ptr %call, ${this.sizeType} ${i})`);
                             scriptArgs.push(`double %s${i}`);
@@ -494,7 +492,8 @@ class LlEmitter {
                     }
                 }
                 dispatchBody.push(`  call void %fn(${[`ptr %cb`, ...scriptArgs].join(", ")})`, `  ret void`, `}`, ``);
-                defs.push(...dispatchBody);
+                for (const line of dispatchBody)
+                    defs.push(line);
                 this.declare(`declare ptr @scr_ffi_call_new(ptr, ptr, ptr, ${this.sizeType})`);
                 this.declare(`declare void @scr_ffi_post(ptr)`);
                 defs.push(`define internal void @${adapter.symbol}(${params.join(", ")}) ${FN_ATTRS} {`, `entry:`, `  %cb = getelementptr inbounds i8, ptr %ctx, i64 0`, `  %call = call ptr @scr_ffi_call_new(ptr @${adapter.table}, ptr %cb, ptr @${dispatch}, ${this.sizeType} ${cb.params.length})`);
@@ -510,6 +509,12 @@ class LlEmitter {
                         this.declare(`declare void @scr_ffi_call_copy_${param}(ptr, ${this.sizeType}, ptr, ${this.sizeType})`);
                         defs.push(`  call void @scr_ffi_call_copy_${param}(ptr %call, ${this.sizeType} ${i}, ptr %a${i}, ${this.sizeType} %a${i}_len)`);
                     }
+                    else if (param === "f32" || param === "i8" || param === "u16" || param === "i16") {
+                        const nativeTy = ffiNativeTypeLl(param);
+                        const op = param === "f32" ? "fpext" : param === "u16" ? "uitofp" : "sitofp";
+                        this.declare(`declare void @scr_ffi_call_set_f64(ptr, ${this.sizeType}, double)`);
+                        defs.push(`  %wide${i} = ${op} ${nativeTy} %a${i} to double`, `  call void @scr_ffi_call_set_f64(ptr %call, ${this.sizeType} ${i}, double %wide${i})`);
+                    }
                     else {
                         const nativeTy = ffiNativeTypeLl(param);
                         this.declare(`declare void @scr_ffi_call_set_${param}(ptr, ${this.sizeType}, ${nativeTy})`);
@@ -519,7 +524,7 @@ class LlEmitter {
                 defs.push(`  call void @scr_ffi_post(ptr %call)`, `  ret void`, `}`, ``);
                 continue;
             }
-            defs.push(`define internal ${ret} @${adapter.symbol}(${params.join(", ")}) ${FN_ATTRS} {`, `entry:`, adapter.tls !== null
+            defs.push(`define internal ${ffiNativeReturnLl(cb.returns, this.ffiExtendNarrowIntegers)} @${adapter.symbol}(${params.join(", ")}) ${FN_ATTRS} {`, `entry:`, adapter.tls !== null
                 ? `  %cb = load ptr, ptr @${adapter.tls}`
                 : adapter.global !== null
                     ? `  %cb = load ptr, ptr @${adapter.global}`
@@ -550,9 +555,28 @@ class LlEmitter {
                 if (isFfiContextParam(param))
                     continue;
                 switch (param) {
+                    case "i64":
+                    case "u64":
+                    case "pointer": {
+                        const ty = ffiNativeTypeLl(param);
+                        this.declare(`declare ptr @scr_bigint_from_${param}(${ty})`);
+                        defs.push(`  %s${i} = call ptr @scr_bigint_from_${param}(${ty} %a${i})`);
+                        scriptArgs.push(`ptr %s${i}`);
+                        break;
+                    }
                     case "f64":
                         scriptArgs.push(`double %a${i}`);
                         break;
+                    case "f32":
+                    case "i8":
+                    case "u16":
+                    case "i16": {
+                        const nativeTy = ffiNativeTypeLl(param);
+                        const op = param === "f32" ? "fpext" : param === "u16" ? "uitofp" : "sitofp";
+                        defs.push(`  %s${i} = ${op} ${nativeTy} %a${i} to double`);
+                        scriptArgs.push(`double %s${i}`);
+                        break;
+                    }
                     case "bool":
                         defs.push(`  %s${i} = icmp ne i8 %a${i}, 0`);
                         scriptArgs.push(`i1 %s${i}`);
@@ -604,18 +628,34 @@ class LlEmitter {
                 defs.push(`  call void @scr_closure_release_v(ptr %invoke_pin)`);
             }
             switch (cb.returns) {
+                case "i64":
+                case "u64":
+                case "pointer": {
+                    const ty = ffiNativeTypeLl(cb.returns);
+                    this.declare(`declare ${ty} @scr_bigint_to_${cb.returns}(ptr)`);
+                    this.declare(`declare void @scr_bigint_release(ptr)`);
+                    defs.push(`  %out = call ${ty} @scr_bigint_to_${cb.returns}(ptr %result)`, `  call void @scr_bigint_release(ptr %result)`, `  ret ${ty} %out`);
+                    break;
+                }
                 case "f64":
                     defs.push(`  ret double %result`);
                     break;
+                case "f32":
+                    defs.push(`  %out = fptrunc double %result to float`, `  ret float %out`);
+                    break;
                 case "bool":
                     defs.push(`  %out = zext i1 %result to i8`, `  ret i8 %out`);
                     break;
                 case "u8":
+                case "i8":
+                case "u16":
+                case "i16":
                 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`);
+                    if (cb.returns !== "u32") {
+                        const nativeTy = ffiNativeTypeLl(cb.returns);
+                        defs.push(`  %out = trunc i32 %wide to ${nativeTy}`, `  ret ${nativeTy} %out`);
                     }
                     else {
                         defs.push(`  ret i32 %wide`);
@@ -632,13 +672,32 @@ class LlEmitter {
     }
     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.
+        // emit), then the file assembles around them — the runtime ABI’s order.
         const fnDefs = [];
         for (const fn of this.mod.functions)
             fnDefs.push(this.emitFunction(fn));
-        const shapes = emitRecordShapes(this, this.mod);
-        const classShapes = emitClassShapes(this, this.mod, this.classMeta);
-        const classObjDefs = emitClassObjDefs(this, this.classMeta, this.classObjs, this.fnByName, (t) => this.llType(t));
+        const errorViews = [];
+        for (const property of ["name", "message"])
+            if (this.mod.functions.some((fn) => fn.name === `%error.${property}.read`)) {
+                this.declare(`declare void @scr_error_install_${property}_reader(ptr)`);
+                errorViews.push(`  call void @scr_error_install_${property}_reader(ptr @${mangleFunction(`%error.${property}.read`)})`);
+            }
+        for (const meta of this.classMeta.values()) {
+            if (meta.def.runtime || meta.root.def.name !== "%Error")
+                continue;
+            const type = { kind: "object", className: meta.def.name };
+            const adapter = this.liveDynRefAdapter(type);
+            const rc = vAdapters(this.shapeHost, type);
+            const key = typeKey(type);
+            const name = `sc_error_view_${errorViews.length}`;
+            this.resolveThunkDefs.push(`define internal ptr @${name}(ptr %v) ${FN_ATTRS} {`, `entry:`, `  %d = call ptr ${typedRefConstructor(this.shapeHost, type)}(ptr %v, ptr ${rc.retain}, ptr ${rc.release}, ptr ${this.cstr(key)}, ${this.sizeType} ${Buffer.byteLength(key, "utf8")}, ptr @${adapter.snapshot}, ptr ${adapter.commit})`, `  ret ptr %d`, `}`, ``);
+            this.declare(`declare void @scr_error_register_dyn(ptr, ptr)`);
+            errorViews.push(`  call void @scr_error_register_dyn(ptr @${mangleVtInstance(meta.def.name)}, ptr @${name})`);
+        }
+        const layouts = emitLlvmLayouts(this.shapeHost, this.mod, this.classMeta, this.classObjs, this.fnByName, (t) => this.llType(t));
+        const shapes = layouts.records;
+        const classShapes = layouts.classes;
+        const classObjDefs = layouts.classObjects;
         const wrappers = this.emitFnValueDefs();
         const asyncDefs = this.emitAsyncScaffolding();
         const ffiCallbacks = this.emitFfiCallbackDefs();
@@ -672,72 +731,88 @@ class LlEmitter {
             seenGlobalIds.add(g.id);
             return true;
         });
-        // Refcounted globals release before main returns — the C emitter's
+        // Refcounted globals release before main returns — the runtime ABI’s
         // sc_release_globals, keeping the RC audit's live count exact. Built
         // before the declaration table flushes (it adds the release symbols).
         // Two spellings with distinct temp names: the normal exit and the
         // uncaught-exception exit are separate blocks of the same function.
         // Interned function-value closures are IMMORTAL (rc == SIZE_MAX), so
         // an own-property table Object.defineProperties hung on one would
-        // outlive the RC audit — release it with the globals (the C emitter's
+        // outlive the RC audit — release it with the globals (the runtime ABI’s
         // sc_release_globals tail). Only when the dispatch unit is even
         // linked (defineProps is the only writer).
-        const fnValueProps = moduleUsesDynInvoke(this.mod) ? [...this.fnValues] : [];
+        const runtimeFeatures = moduleRuntimeFeatures(this.mod);
+        const fnValueProps = [...this.fnValues];
         if (fnValueProps.length > 0)
             this.declare(`declare void @scr_box_release(ptr)`);
+        if (this.classObjs.size > 0)
+            this.declare(`declare void @scr_classobj_clear_properties(ptr)`);
         const globalReleaseLines = (prefix) => {
             const lines = [];
             globals.forEach((g, i) => {
                 if (!isRefCounted(g.type))
                     return;
-                lines.push(`  %${prefix}${i} = load ptr, ptr @${mangleGlobal(g.id)}`, `  call void ${releaseSym(this, g.type)}(ptr %${prefix}${i}) ; ${g.name}`);
+                lines.push(`  %${prefix}${i} = load ptr, ptr @${mangleGlobal(g.id)}`, `  call void ${releaseSym(this.shapeHost, g.type)}(ptr %${prefix}${i}) ; ${g.name}`);
             });
             fnValueProps.forEach((name, i) => {
                 // props sits at %ScrClosure field 3; release is NULL-tolerant —
                 // cleared so a second release path stays idempotent.
                 lines.push(`  %${prefix}fp${i} = load ptr, ptr getelementptr inbounds (%ScrClosure, ptr @${mangleFnClosure(name)}, i64 0, i32 3)`, `  call void @scr_box_release(ptr %${prefix}fp${i}) ; ${name}.props`, `  store ptr null, ptr getelementptr inbounds (%ScrClosure, ptr @${mangleFnClosure(name)}, i64 0, i32 3)`);
             });
+            for (const name of this.classObjs.keys())
+                lines.push(`  call void @scr_classobj_clear_properties(ptr @${mangleClassObj(name)})`);
             return lines;
         };
         // Exit listeners can read MODULE GLOBALS directly, so they must run
-        // BEFORE the global releases (the C emitter's runExitListeners
+        // BEFORE the global releases (the runtime ABI’s runExitListeners
         // ordering — the atexit half becomes an idempotent no-op).
-        const usesEvents = moduleUsesProcessEvents(this.mod);
-        const usesChildProcess = moduleUsesChildProcess(this.mod);
-        const usesFsWatch = moduleUsesFsWatch(this.mod);
+        const usesEvents = runtimeFeatures.processEvents;
+        const usesChildProcess = runtimeFeatures.childProcess;
+        const usesFsWatch = runtimeFeatures.fsWatch;
         // Stream-surface programs fill the loop's stream hook (the deferred
         // next-tick emissions) and the emitter's post-registration flow kick
         // before %main — scr_stream.c links only when the line is emitted
         // (native-toolchain.ts gates on the same predicate).
-        const usesStream = moduleUsesStream(this.mod);
+        const usesStream = runtimeFeatures.stream;
         // Net-surface programs fill the loop's net hooks (and the netSocket
         // handle-dispatch ops for the checked-dynamic boundary); http-surface
         // programs additionally stamp the httpReq/httpRes ops — the C main's
         // install lines, gated on the same predicates native-toolchain.ts links by.
-        const usesNet = moduleUsesNet(this.mod);
-        const usesHttp = moduleUsesHttpServer(this.mod);
+        const usesNet = runtimeFeatures.net;
+        const usesDgram = runtimeFeatures.dgram;
+        const usesHttp2 = runtimeFeatures.http2;
+        const usesHttp = runtimeFeatures.http;
         // Fetch-referencing programs register the native fetch bridge before
         // any island entry (the engine's lazy boot consults it) — native-toolchain.ts
         // compiles scr_fetch.c on the same predicate.
-        const usesFetch = moduleUsesFetch(this.mod);
+        const usesFetch = runtimeFeatures.fetch;
         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) ||
+        const snapshotsTlsCa = runtimeFeatures.tls || runtimeFeatures.tlsCa ||
             moduleEmbedsBuiltin(this.mod, "node:https") ||
             moduleEmbedsBuiltin(this.mod, "node:tls");
         // 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 usesNodeTest = runtimeFeatures.nodeTest;
         const programExitUsesIsland = !usesNodeTest && usesIsland;
         // Declared NOW — the extern block flushes before main assembles.
         if (usesEvents)
             this.declare(`declare void @scr_events_install()`);
         if (usesChildProcess)
             this.declare(`declare void @scr_child_dyn_install()`);
+        const childStreamBoxes = usesChildProcess && usesStream &&
+            this.classMeta.has("%Readable") && this.classMeta.has("%Writable")
+            ? [this.dyn.toDynHelper({ kind: "object", className: "%Readable" }),
+                this.dyn.toDynHelper({ kind: "object", className: "%Writable" })]
+            : null;
+        if (childStreamBoxes) {
+            this.declare(`@scr_stream_child_ops = external constant { ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr }`);
+            this.declare(`declare void @scr_child_dyn_streams_install(ptr, ptr, ptr)`);
+        }
         if (usesFsWatch)
             this.declare(`declare void @scr_watch_install()`);
         if (this.ffiHasForeignCallback)
@@ -748,6 +823,10 @@ class LlEmitter {
             this.declare(`declare void @scr_net_install()`);
             this.declare(`declare void @scr_net_dyn_install()`);
         }
+        if (usesDgram)
+            this.declare(`declare void @scr_dgram_install()`);
+        if (usesHttp2)
+            this.declare(`declare void @scr_http2_dyn_install()`);
         if (usesHttp)
             this.declare(`declare void @scr_http_dyn_install()`);
         if (usesFetch)
@@ -773,13 +852,12 @@ class LlEmitter {
         // the refcounted-global releases, or the retained-FFI atexit ledger
         // sweep (a listener may legitimately release or pump a registration,
         // and only the inline call orders ahead of every atexit handler —
-        // the C emitter's runExitListeners stance). Plain event programs
+        // the runtime ABI’s runExitListeners stance). Plain event programs
         // with neither keep the atexit path, so their listener timing is
         // unchanged.
         const hasRefGlobals = globals.some((g) => isRefCounted(g.type)) || fnValueProps.length > 0;
         const inlineExitListeners = usesEvents && (hasRefGlobals || this.ffiHasRetainedCallback);
-        if (!usesNodeTest && !usesIsland)
-            this.declare(`declare i32 @scr_exit_code_hint_get()`);
+        this.declare(`declare i32 @scr_exit_code_hint_get()`);
         if (inlineExitListeners) {
             this.declare(`declare void @scr_run_exit_listeners(double)`);
             this.declare(`declare i32 @scr_exit_code_hint_get()`);
@@ -852,17 +930,23 @@ class LlEmitter {
             // 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"));
+            for (const line of exitListenerLines("xp"))
+                lines.push(line);
             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);
+            for (const line of topPendingReleases)
+                lines.push(line);
             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) {
+            if (this.wasi) {
+                this.declare(`declare ptr @malloc(${this.sizeType})`);
+                this.declare(`declare void @free(ptr)`);
+            }
             this.declare(`declare void @scr_library_entry(i1 zeroext, ptr)`);
             this.declare(`declare void @scr_library_reset()`);
             this.declare(`declare void @scr_library_check_exc()`);
@@ -916,18 +1000,18 @@ class LlEmitter {
             `%ScrLogArg = type { i32, i64 }`,
             `%ScrVt = type { ${this.sizeType}, ${this.sizeType}, ptr }`,
             `%ScrUnion = type { ${this.sizeType}, i32, ptr, ptr, ptr, i64 }`,
-            `%ScrClosure = type { ${this.sizeType}, ptr, ${this.sizeType}, ptr }`,
+            `%ScrClosure = type { ${this.sizeType}, ptr, ${this.sizeType}, ptr, i32 }`,
             `%ScrFfiTable = type { ptr, ${this.sizeType}, ${this.sizeType}, ptr, i8, ptr, ptr, ${this.sizeType}, ${this.sizeType}, ${this.sizeType}, ptr, ptr }`,
-            `%ScrRegex = type { ${this.sizeType}, ptr, ptr, ptr }`,
+            `%ScrRegex = type { ${this.sizeType}, ptr, ptr, ptr, double, ptr }`,
             // ScrArr mirrors scr_runtime.h field-for-field. Live dynamic stream
             // commits swap its mutable dense, sparse, presence, and property
             // storage while preserving the target object's identity.
-            `%ScrArr = type { ${this.sizeType}, ${this.sizeType}, ${this.sizeType}, i32, ptr, ptr, ptr, ptr, ptr, ptr, ${this.sizeType}, ${this.sizeType}, ptr, ${this.sizeType}, ${this.sizeType} }`,
-            // The runtime error prefix { rc, vt, name, message, code } and the
+            `%ScrArr = type { ${this.sizeType}, ${this.sizeType}, ${this.sizeType}, i32, ptr, ptr, ptr, ptr, ptr, ptr, ${this.sizeType}, ${this.sizeType}, ptr, ${this.sizeType}, ${this.sizeType}, ptr }`,
+            // The runtime error prefix { rc, vt, name, message, code, cause } and the
             // class-object shape { rc, pre, post, ctor, name } — field reads on
             // builtin errors and classval loads GEP through these.
-            `%ScrError = type { ${this.sizeType}, ptr, ptr, ptr, ptr }`,
-            `%ScrClassObj = type { ${this.sizeType}, ${this.sizeType}, ${this.sizeType}, ptr, ptr }`,
+            `%ScrError = type { ${this.sizeType}, ptr, ptr, ptr, ptr, ptr, i8, i8, i8, i8, i8, ptr, ptr }`,
+            `%ScrClassObj = type { ${this.sizeType}, ${this.sizeType}, ${this.sizeType}, ptr, ptr, ${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 { ${this.sizeType}, ptr, ptr, ptr }`,
@@ -944,7 +1028,7 @@ class LlEmitter {
             // 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 { ${this.sizeType}, ${this.sizeType}, i32, ptr, ptr }`,
+            `%ScrBytes = type { ${this.sizeType}, ${this.sizeType}, i32, ptr, ptr, i8 }`,
             // The capture box { rc, kind, obj_retain, obj_release, obj_trace,
             // slot } — TDZ reads peek the payload slot (offset 40) directly.
             `%ScrBox = type { ${this.sizeType}, i32, ptr, ptr, ptr, i64 }`,
@@ -956,8 +1040,10 @@ class LlEmitter {
             `%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);
+        for (const line of shapes.typeDefs)
+            out.push(line);
+        for (const line of classShapes.typeDefs)
+            out.push(line);
         // 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
@@ -966,7 +1052,7 @@ class LlEmitter {
         // 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)`, ...(this.runtimeAbiMarker && this.mod.lib === undefined
+        out.push(``, `@scr_error_vts = external ${tl}global [${RUNTIME_ERROR_CLASSES.size} x %ScrVt]`, `declare void @scr_init()`, `declare void @scr_lib_init(i32, ptr)`, ...(this.runtimeAbiMarker && this.mod.lib === undefined
             ? [`declare void @${RUNTIME_ABI_MARKER}()`]
             : []));
         for (const d of this.decls)
@@ -981,7 +1067,7 @@ class LlEmitter {
         }
         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.
+            // the runtime ABI’s static table, retain/release skip rc == SIZE_MAX.
             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)}" }`);
         }
@@ -1000,7 +1086,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 ${tl}global %ScrRegex { ${this.sizeType} -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, double 0.0, ptr null } ; ${key.replace(/\n/g, "\\n")}`);
         }
         if (this.regexInstances.size > 0)
             out.push(``);
@@ -1014,13 +1100,12 @@ class LlEmitter {
             const present = n === 0
                 ? "zeroinitializer"
                 : `[ ${inst.slots.map(() => "i8 1").join(", ")} ]`;
-            out.push(`@${inst.sym}_data = internal constant [${n} x ptr] [ ${inst.slots.map((s) => `ptr ${s}`).join(", ")} ]`, `@${inst.sym}_present = internal constant [${n} x i8] ${present}`, `@${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, ptr @${inst.sym}_present, ptr null, ${this.sizeType} 0, ${this.sizeType} 0, ptr null, ${this.sizeType} 0, ${this.sizeType} 0 }`);
+            out.push(`@${inst.sym}_data = internal constant [${n} x ptr] [ ${inst.slots.map((s) => `ptr ${s}`).join(", ")} ]`, `@${inst.sym}_present = internal constant [${n} x i8] ${present}`, `@${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, ptr @${inst.sym}_present, ptr null, ${this.sizeType} 0, ${this.sizeType} 0, ptr null, ${this.sizeType} 0, ${this.sizeType} 0, ptr null }`);
         }
         if (this.templateStringsInstances.size > 0)
             out.push(``);
         for (const [text, c] of this.cstrs) {
-            // NUL-terminated byte-array constants: the scr_jb_puts / indent-text
-            // currency (the C emitter passes string literals; these are theirs).
+            // NUL-terminated byte-array constants for scr_jb_puts and indentation.
             out.push(`@${c.sym} = internal constant [${c.len + 1} x i8] c"${llStrBytes(text)}"`);
         }
         if (this.cstrs.size > 0)
@@ -1047,7 +1132,8 @@ class LlEmitter {
             });
             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 parts = [["from", edge.from], ["spec", edge.specifier], ["to", edge.to]];
+                for (const [part, text] of parts) {
                     const bytes = Buffer.from(text, "utf8");
                     out.push(`@sc_npm_edge_${i}_${part} = internal constant [${bytes.length + 1} x i8] c"${llBytes(bytes)}"`);
                 }
@@ -1059,7 +1145,8 @@ class LlEmitter {
             }
             out.push(``);
         }
-        out.push(...ffiCallbacks.globals);
+        for (const line of ffiCallbacks.globals)
+            out.push(line);
         if (ffiCallbacks.globals.length > 0)
             out.push(``);
         for (const g of globals) {
@@ -1070,26 +1157,36 @@ class LlEmitter {
         }
         if (globals.length > 0)
             out.push(``);
-        out.push(...helpers);
-        out.push(...ffiCallbacks.defs);
-        out.push(...shapes.defs);
-        out.push(...classShapes.defs);
-        out.push(...classObjDefs);
-        out.push(...this.walkers.defs);
-        out.push(...this.dyn.defs);
-        out.push(...wrappers);
-        out.push(...asyncDefs);
-        out.push(...this.resolveThunkDefs);
+        for (const line of helpers)
+            out.push(line);
+        for (const line of ffiCallbacks.defs)
+            out.push(line);
+        for (const line of shapes.defs)
+            out.push(line);
+        for (const line of classShapes.defs)
+            out.push(line);
+        for (const line of classObjDefs)
+            out.push(line);
+        for (const line of this.walkers.defs)
+            out.push(line);
+        for (const line of this.dyn.defs)
+            out.push(line);
+        for (const line of wrappers)
+            out.push(line);
+        for (const line of asyncDefs)
+            out.push(line);
+        for (const line of this.resolveThunkDefs)
+            out.push(line);
         out.push(fnDefs.join("\n\n"), ``);
         // main(): scr_init, the program-dependent error-vt interval stamps,
         // scr_lib_init(argc, argv), then the entry function. An uncaught
-        // exception escaping top-level code prints and exits 1 (Node) — the
-        // C emitter's epilogue, emitted exactly when the entry may throw.
-        // No event loop yet: timers/async still refuse (phase 5).
-        const stamps = [];
+        // exception escaping top-level code prints and exits 1 (Node).
+        // The exception epilogue is emitted when the entry may throw.
+        const stamps = [...errorViews];
         for (const iv of this.errorIntervals) {
-            for (const [field, value] of [[0, iv.pre], [1, iv.post]]) {
-                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}` : ""}`);
+            const fields = [[0, iv.pre], [1, iv.post]];
+            for (const [field, value] of fields) {
+                stamps.push(`  store ${this.sizeType} ${value}, ptr getelementptr inbounds ([${RUNTIME_ERROR_CLASSES.size} x %ScrVt], ptr @scr_error_vts, i64 0, i64 ${iv.kind}, i32 ${field})${field === 1 ? ` ; ${iv.lib}` : ""}`);
             }
         }
         if (this.emitterInterval !== null) {
@@ -1122,12 +1219,13 @@ class LlEmitter {
             // order-free — the scr_error_set_traced precedent). Only the
             // printer emits here (nothing else declares it); scr_exc_pending
             // and the loop entry points rode the Set before the flush.
-            out.push(`declare void @scr_exc_print_uncaught()`, ``);
+            out.push(`declare void @scr_exc_print_uncaught()`, `declare zeroext i1 @scr_exc_handle_uncaught(i1 zeroext)`, ``);
         }
         if (this.mod.lib !== undefined) {
             // 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));
+            // symbols specified by the library IR instead.
+            for (const line of this.emitLibDefs(globals, globalReleaseLines, stamps))
+                out.push(line);
             out.push(`attributes #0 = { sanitize_address }`);
             if (this.wasi)
                 out.push(`attributes #1 = { sanitize_address presplitcoroutine }`);
@@ -1142,10 +1240,10 @@ class LlEmitter {
         // 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 (native-toolchain.ts gates on the same predicate).
-        ...(usesEvents ? [`  call void @scr_events_install()`] : []), ...(usesChildProcess ? [`  call void @scr_child_dyn_install()`] : []), 
+        ...(usesEvents ? [`  call void @scr_events_install()`] : []), ...(usesChildProcess ? [`  call void @scr_child_dyn_install()`] : []), ...(childStreamBoxes ? [`  call void @scr_child_dyn_streams_install(ptr @scr_stream_child_ops, ptr @${childStreamBoxes[0]}, ptr @${childStreamBoxes[1]})`] : []), 
         // 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()`] : []), ...(this.ffiHasForeignCallback ? [`  call void @scr_ffi_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
+        ...(usesFsWatch ? [`  call void @scr_watch_install()`] : []), ...(this.ffiHasForeignCallback ? [`  call void @scr_ffi_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()`] : []), ...(usesDgram ? [`  call void @scr_dgram_install()`] : []), ...(usesHttp2 ? [`  call void @scr_http2_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)`]
@@ -1162,10 +1260,14 @@ class LlEmitter {
                 `  %exc = call zeroext i1 @scr_exc_pending()`,
                 `  br i1 %exc, label %uncaught, label %ok`,
                 `uncaught:`,
+                `  %handled = call zeroext i1 @scr_exc_handle_uncaught(i1 false)`,
+                `  br i1 %handled, label %ok, label %fatal`,
+                `fatal:`,
                 `  call void @scr_exc_print_uncaught()`,
                 ...exitListenerLines("xu"),
                 ...uncaughtReleases,
-                `  ret i32 1`,
+                `  %failure_code_0 = call i32 @scr_exit_code_hint_get()`,
+                `  ret i32 %failure_code_0`,
                 `ok:`,
             ]
             : []), 
@@ -1182,7 +1284,8 @@ class LlEmitter {
                 ...(asyncEntry ? [`  call void @scr_promise_release(ptr %top)`] : []),
                 ...exitListenerLines("xl"),
                 ...loopReleasesU,
-                `  ret i32 1`,
+                `  %failure_code_1 = call i32 @scr_exit_code_hint_get()`,
+                `  ret i32 %failure_code_1`,
                 `lok:`,
                 `  br i1 %loop_rejection, label %lreported, label %lclean`,
                 `lreported:`,
@@ -1190,7 +1293,8 @@ class LlEmitter {
                 ...(asyncEntry ? [`  call void @scr_promise_release(ptr %top)`] : []),
                 ...exitListenerLines("xq"),
                 ...loopReportedReleases,
-                `  ret i32 1`,
+                `  %failure_code_2 = call i32 @scr_exit_code_hint_get()`,
+                `  ret i32 %failure_code_2`,
                 `lclean:`,
                 ...(asyncEntry
                     ? [
@@ -1207,7 +1311,8 @@ class LlEmitter {
                         `  call void @scr_exc_print_uncaught()`,
                         ...exitListenerLines("xt"),
                         ...topRejectReleases,
-                        `  ret i32 1`,
+                        `  %failure_code_3 = call i32 @scr_exit_code_hint_get()`,
+                        `  ret i32 %failure_code_3`,
                         `tla_not_rejected:`,
                         `  call void @scr_promise_release(ptr %top)`,
                     ]
@@ -1217,7 +1322,8 @@ class LlEmitter {
                 `lrej:`,
                 ...exitListenerLines("xr"),
                 ...loopReleasesR,
-                `  ret i32 1`,
+                `  %failure_code_4 = call i32 @scr_exit_code_hint_get()`,
+                `  ret i32 %failure_code_4`,
                 `lrok:`,
                 ...(asyncEntry
                     ? [
@@ -1271,11 +1377,15 @@ class LlEmitter {
         for (const e of lib.exports)
             emitSymConst(e.symbol);
         out.push(``);
+        if (this.wasi) {
+            for (const symbol of ["scriptc_alloc", "scriptc_free"])
+                emitSymConst(symbol);
+            out.push(`define ptr @scriptc_alloc(i32 %size) ${FN_ATTRS} {`, `entry:`, `  call void @scr_library_entry(i1 zeroext false, ptr ${symConst("scriptc_alloc")})`, `  %p = call ptr @malloc(i32 %size)`, `  ret ptr %p`, `}`, ``, `define void @scriptc_free(ptr %p) ${FN_ATTRS} {`, `entry:`, `  call void @scr_library_entry(i1 zeroext false, ptr ${symConst("scriptc_free")})`, `  call void @free(ptr %p)`, `  ret void`, `}`, ``);
+        }
         // The runtime detected-trap overlay table (scr_runtime.h declares it,
         // the library trap funnel consults it): flat code/teaching/remediation
         // triples, one per runtime trap code (SC4013–SC4019) the profile
-        // declares text for — the same data the C emission defines, so the
-        // funnel-assembled sink message is emission-invariant by construction.
+        // declares text for. The funnel assembles the structured sink message.
         // The empty table still defines the symbols the funnel links against.
         const ovlCells = [];
         lib.trapOverlays.forEach((o, i) => {
@@ -1309,8 +1419,8 @@ class LlEmitter {
             // Host-callback channels: the per-channel name constants (the
             // registration dispatch's strcmp operands), the per-channel
             // unregistered-call trap constants (the ffiCall sites'
-            // scr_library_cb_require operands — same bytes as the C emission by
-            // construction), and the registration define: a pure store dispatch
+            // scr_library_cb_require operands), and the registration function:
+            // a pure store dispatch
             // (the sink registration's rule — no entry prologue, no poison
             // guard) whose first operation rejects callback-time re-entry
             // (SC4026). An unknown or NULL name is a defined -1, never a store.
@@ -1330,7 +1440,8 @@ class LlEmitter {
             // from the poisoned guard and every runtime touch (ratified), so a
             // host can read them before init and after a trap. The u64 rides
             // i64 two's-complement (LLVM integer constants are signed).
-            out.push(...emitLibraryIdentityLines("llvm", lib.identity, FN_ATTRS));
+            for (const line of emitLibraryIdentityLines(lib.identity, FN_ATTRS))
+                out.push(line);
         }
         if (lib.resultResetSymbol !== null) {
             out.push(`define void @${lib.resultResetSymbol}() ${FN_ATTRS} {`, `entry:`, `  call void @scr_library_entry(i1 zeroext false, ptr ${symConst(lib.resultResetSymbol)})`, `  call void @scr_library_arena_reset()`, `  ret void`, `}`, ``);
@@ -1345,8 +1456,7 @@ class LlEmitter {
             if (e.inboundBytesTrap !== undefined) {
                 // The bytes-in helper's trap message: the compiler-assembled
                 // structured trap-teaching form (0x01 text 0x1F SC4012 0x1F symbol
-                // [0x1F remediation]) — the same bytes the C emission passes, so
-                // the sink message is emission-invariant by construction.
+                // [0x1F remediation]) consumed by the runtime sink.
                 const trapBytes = Buffer.byteLength(e.inboundBytesTrap, "utf8");
                 out.push(`@sc_lib_bytes_trap_${e.symbol} = internal constant [${trapBytes + 1} x i8] c"${llStrBytes(e.inboundBytesTrap)}"`, ``);
             }
@@ -1450,7 +1560,7 @@ class LlEmitter {
     }
     /** The shared abort helpers (emitted only when referenced): the OOM
      * abort of untraced shape allocation and the invalid-union-tag abort —
-     * both print the C emitter's exact message on fd 2 and abort. */
+     * both print the runtime ABI’s exact message on fd 2 and abort. */
     helperDefs() {
         const defs = [];
         const msgHelper = (fnName, msgSym, msg) => {
@@ -1485,7 +1595,7 @@ class LlEmitter {
         return defs.length > 0 ? [...defs] : defs;
     }
     /** Env-signature wrappers + interned immortal closures for declared
-     * functions used as values (the C emitter's sc_w_/sc_fc_ pair): every
+     * functions used as values (the runtime ABI’s sc_w_/sc_fc_ pair): every
      * mention of `f` yields the same pointer, so `f === f` holds. */
     emitFnValueDefs() {
         const out = [];
@@ -1498,7 +1608,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 { ${this.sizeType} -1, ptr @${mangleWrapper(name)}, ${this.sizeType} 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, i32 ${(fn.generator ? 1 : 0) + (fn.async ? 2 : 0) + (fn.ownsPrototype ? 4 : 0)} }`, ``);
         }
         return out;
     }
@@ -1570,7 +1680,8 @@ class LlEmitter {
             if (fn.async !== true || fn.generator !== undefined)
                 continue;
             const { definitions, ret, tr, spawnParams, argPackLines } = this.emitArgPackAndTrampolinePrologue(fn);
-            out.push(...definitions);
+            for (const line of definitions)
+                out.push(line);
             this.declare(`declare ptr @scr_fiber_promise(ptr)`);
             this.declare(`declare ptr @scr_async_spawn(ptr, ptr)`);
             this.needOom();
@@ -1603,20 +1714,25 @@ class LlEmitter {
                         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;
+                    case "dyn":
+                        this.declare(`declare void @scr_promise_resolve_dyn(ptr, ptr)`);
+                        tr.push(`  call void @scr_promise_resolve_dyn(ptr %pr, ptr %r) ; moves in`);
+                        break;
                     default: {
-                        const v = vAdapters(this, ret);
+                        const v = vAdapters(this.shapeHost, 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(`  call void @scr_promise_fulfill_ref(ptr %pr, ptr %r, ptr ${v.retain}, ptr ${v.release}, ptr ${traceArg(this.shapeHost, 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(`  call void ${releaseSym(this.shapeHost, ret)}(ptr %r)`);
                 }
                 tr.push(`  ret void`, `}`, ``);
             }
-            out.push(...tr);
+            for (const line of tr)
+                out.push(line);
             // Spawn wrapper: pack the args (+1 moves in), spawn the fiber.
             const cache = fn.asyncCacheGlobal !== undefined ? mangleGlobal(fn.asyncCacheGlobal) : null;
             const cycleCache = fn.asyncCycleCacheGlobal !== undefined ? mangleGlobal(fn.asyncCycleCacheGlobal) : null;
@@ -1676,9 +1792,11 @@ class LlEmitter {
                     `  store ptr %cycle_cache_owned, ptr @${cycleCache}`,
                 ]
                 : []), `  ret ptr %p`, `}`, ``);
-            out.push(...sp);
+            for (const line of sp)
+                out.push(line);
         }
-        out.push(...this.emitGenScaffolding());
+        for (const line of this.emitGenScaffolding())
+            out.push(line);
         return out;
     }
     /** Per-generator-function machinery — the async scaffolding's lazy
@@ -1693,7 +1811,8 @@ class LlEmitter {
             if (fn.generator === undefined)
                 continue;
             const { definitions, pack, lifted, fieldTys, ret, tr, spawnParams, argPackLines, } = this.emitArgPackAndTrampolinePrologue(fn);
-            out.push(...definitions);
+            for (const line of definitions)
+                out.push(line);
             this.declare(`declare zeroext i1 @scr_exc_genret_pending()`);
             this.declare(`declare void @scr_exc_clear()`);
             this.declare(`declare ptr @scr_gen_of_fiber(ptr)`);
@@ -1726,18 +1845,19 @@ class LlEmitter {
                         tr.push(`  call void @scr_gen_out_bool(ptr %g, i1 %r)`, `  br label %done`);
                         break;
                     default: {
-                        const v = vAdapters(this, ret);
+                        const v = vAdapters(this.shapeHost, 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(`  call void ${releaseSym(this.shapeHost, ret)}(ptr %r) ; unwound: the never-read dummy`);
                 }
                 tr.push(`  br label %done`, `done:`, `  ret void`, `}`, ``);
             }
-            out.push(...tr);
+            for (const line of tr)
+                out.push(line);
             let settleAsync = null;
             if (fn.async) {
                 this.declare(`declare ptr @scr_async_gen_new(ptr, ptr, ptr, ptr)`);
@@ -1754,8 +1874,8 @@ class LlEmitter {
                 const settleKey = `ags:${typeKey(genT)}`;
                 if (!this.resolveThunks.has(settleKey)) {
                     this.resolveThunks.set(settleKey, settleAsync);
-                    const adapters = vAdapters(this, resultT);
-                    this.resolveThunkDefs.push(`define internal void @${settleAsync}(ptr %g, ptr %p) ${FN_ATTRS} {`, `entry:`, `  %r = call ptr @${build}(ptr %g)`, `  call void @scr_promise_fulfill_ref(ptr %p, ptr %r, ptr ${adapters.retain}, ptr ${adapters.release}, ptr ${traceArg(this, resultT)})`, `  ret void`, `}`, ``);
+                    const adapters = vAdapters(this.shapeHost, resultT);
+                    this.resolveThunkDefs.push(`define internal void @${settleAsync}(ptr %g, ptr %p) ${FN_ATTRS} {`, `entry:`, `  %r = call ptr @${build}(ptr %g)`, `  call void @scr_promise_fulfill_ref(ptr %p, ptr %r, ptr ${adapters.retain}, ptr ${adapters.release}, ptr ${traceArg(this.shapeHost, resultT)})`, `  ret void`, `}`, ``);
                 }
                 this.declare(`declare void @scr_promise_fulfill_ref(ptr, ptr, ptr, ptr, ptr)`);
             }
@@ -1775,11 +1895,12 @@ class LlEmitter {
                     dr.push(`  call void @scr_closure_release(ptr %dv${i})`);
                 }
                 else {
-                    dr.push(`  call void ${releaseSym(this, pType)}(ptr %dv${i})`);
+                    dr.push(`  call void ${releaseSym(this.shapeHost, pType)}(ptr %dv${i})`);
                 }
             });
             dr.push(`  call void @free(ptr %ap)`, `  ret void`, `}`, ``);
-            out.push(...dr);
+            for (const line of dr)
+                out.push(line);
             // Spawn wrapper: pack the args (+1 moves in), allocate the
             // SUSPENDED fiber — nothing runs until the first .next().
             if (lifted) {
@@ -1793,11 +1914,12 @@ class LlEmitter {
             sp.push(settleAsync === null
                 ? `  %gg = call ptr @scr_gen_new(ptr @${mangleTrampoline(fn.name)}, ptr %ap, ptr @${mangleGenDrop(fn.name)})`
                 : `  %gg = call ptr @scr_async_gen_new(ptr @${mangleTrampoline(fn.name)}, ptr %ap, ptr @${mangleGenDrop(fn.name)}, ptr @${settleAsync})`, `  ret ptr %gg`, `}`, ``);
-            out.push(...sp);
+            for (const line of sp)
+                out.push(line);
         }
         return out;
     }
-    // ── plumbing (the CEmitter frame/scope machinery, alloca-flavored) ──────
+    // ── plumbing (frame and scope ownership) ──────
     internLiteral(text) {
         let lit = this.literals.get(text);
         if (!lit) {
@@ -1877,20 +1999,26 @@ class LlEmitter {
      * the `_v` table (immortals skip, exactly the C retain calls). */
     retainValue(name, type) {
         const t = this.B.tmp();
-        this.B.line(`${t} = call ptr ${retainSym(this, type)}(ptr ${name})`);
+        this.B.line(`${t} = call ptr ${retainSym(this.shapeHost, type)}(ptr ${name})`);
         return t;
     }
     /** The release call for one owned refcounted value — type-directed like
      * releaseCallC (all runtime releases are NULL-tolerant). */
     releaseValue(name, type) {
-        this.B.line(`call void ${releaseSym(this, type)}(ptr ${name})`);
+        this.B.line(`call void ${releaseSym(this.shapeHost, type)}(ptr ${name})`);
     }
     releaseFrame(frame) {
         for (const v of frame) {
             if (v.slot) {
                 const t = this.B.tmp();
                 this.B.line(`${t} = load ptr, ptr ${v.name}`);
-                this.releaseValue(t, v.type);
+                if (v.boxed) {
+                    this.declare(`declare void @scr_box_release(ptr)`);
+                    this.B.line(`call void @scr_box_release(ptr ${t})`);
+                }
+                else {
+                    this.releaseValue(t, v.type);
+                }
             }
             else {
                 this.releaseValue(v.name, v.type);
@@ -1913,7 +2041,7 @@ class LlEmitter {
     /** THE release-on-jump path (break/continue/return): pending statement
      * frames and entered scopes down to the given depths, innermost first —
      * everything whose normal fall-through releases the jump bypasses.
-     * Ported verbatim from CEmitter.releaseForJump. */
+     * Release every scope crossed by the control-flow edge. */
     releaseForJump(frameDepth, scopeDepth) {
         for (let i = this.frames.length - 1; i >= frameDepth; i--)
             this.releaseFrame(this.frames[i]);
@@ -1953,29 +2081,47 @@ class LlEmitter {
      * function — and branch to the handler / return a dummy value (never
      * read: callers of a may-throw function test the pending flag before
      * using the result). Callers own the surrounding pending branch; a
-     * `throw` unwinds unconditionally. CEmitter.emitUnwind, block-flavored. */
+     * `throw` unwinds unconditionally. */
     emitUnwind() {
         const target = this.tryStack[this.tryStack.length - 1];
+        const frameDepth = target?.frameDepth ?? 0;
+        const scopeDepth = target?.scopeDepth ?? 0;
+        for (let i = this.frames.length - 1; i >= frameDepth; i--)
+            this.releaseFrame(this.frames[i]);
+        let terminator;
         if (target) {
-            this.releaseForJump(target.frameDepth, target.scopeDepth);
             target.used = true;
-            this.B.terminate(`br label %${target.label}`);
-            return;
+            terminator = `br label %${target.label}`;
         }
-        this.releaseForJump(0, 0);
-        if (this.currentWasiCoro !== null) {
-            this.B.terminate(`br label %${this.currentWasiCoro.finalLabel}`);
+        else if (this.currentWasiCoro !== null) {
+            terminator = `br label %${this.currentWasiCoro.finalLabel}`;
+        }
+        else {
+            const t = this.currentReturnType;
+            terminator = t.kind === "void" ? "ret void"
+                : t.kind === "f64" || t.kind === "date" ? `ret double ${f64Lit(0)}`
+                    : t.kind === "bool" ? "ret i1 false" : "ret ptr null";
+        }
+        // Copy the entries now: later declarations extend these lexical scopes.
+        // Release order and the handler are part of the shared block's identity.
+        const entries = [];
+        let key = terminator;
+        for (let i = this.scopes.length - 1; i >= scopeDepth; i--) {
+            for (const entry of this.scopes[i]) {
+                entries.push(entry);
+                key += `\0${entry.slot}\0${entry.boxed ? "@scr_box_release" : releaseSym(this.shapeHost, entry.type)}`;
+            }
+        }
+        if (entries.length === 0) {
+            this.B.terminate(terminator);
             return;
         }
-        const t = this.currentReturnType;
-        if (t.kind === "void")
-            this.B.terminate("ret void");
-        else if (t.kind === "f64" || t.kind === "date")
-            this.B.terminate(`ret double ${f64Lit(0)}`);
-        else if (t.kind === "bool")
-            this.B.terminate("ret i1 false");
-        else
-            this.B.terminate("ret ptr null");
+        let cleanup = this.unwindCleanups.get(key);
+        if (!cleanup) {
+            cleanup = { label: this.B.newLabel("exc.cleanup"), entries, terminator };
+            this.unwindCleanups.set(key, cleanup);
+        }
+        this.B.br(cleanup.label);
     }
     /** The emitter contract for exceptions: after EVERY call that can throw
      * (per the may-throw analysis), test the pending flag and unwind. The
@@ -2021,28 +2167,32 @@ class LlEmitter {
             // Hierarchy instances carry a vtable word: the OBJ kind keeps the
             // dynamic class inspectable (catch-binding instanceof, the uncaught
             // printer's "name: message" for Error instances).
-            const rc = vAdapters(this, t);
+            const rc = vAdapters(this.shapeHost, t);
             this.declare(`declare void @scr_throw_obj(ptr, ptr, ptr, ptr)`);
-            B.line(`call void @scr_throw_obj(ptr ${v.name}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${traceArg(this, t)})`);
+            B.line(`call void @scr_throw_obj(ptr ${v.name}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${traceArg(this.shapeHost, t)})`);
         }
         else if (t.kind === "symbol" || t.kind === "bigint" || t.kind === "func" || t.kind === "classval") {
-            const rc = vAdapters(this, t);
+            const rc = vAdapters(this.shapeHost, t);
             this.declare(`declare void @scr_throw_primitive_ref(ptr, ptr, ptr, ptr)`);
             B.line(`call void @scr_throw_primitive_ref(ptr ${v.name}, ptr ${rc.retain}, ptr ${rc.release}, ptr null)`);
         }
-        else if (t.kind === "dyn" || t.kind === "jsval") {
-            const rc = vAdapters(this, t);
-            const test = t.kind === "dyn" ? "scr_dyn_is_object" : "scr_jsval_is_object";
+        else if (t.kind === "dyn") {
+            this.declare(`declare void @scr_dyn_throw(ptr)`);
+            B.line(`call void @scr_dyn_throw(ptr ${v.name})`);
+        }
+        else if (t.kind === "jsval") {
+            const rc = vAdapters(this.shapeHost, t);
+            const test = "scr_jsval_is_object";
             this.declare(`declare zeroext i1 @${test}(ptr)`);
             this.declare(`declare void @scr_throw_ref_classified(ptr, ptr, ptr, ptr, i1 zeroext)`);
             const object = B.tmp();
             B.line(`${object} = call zeroext i1 @${test}(ptr ${v.name})`);
-            B.line(`call void @scr_throw_ref_classified(ptr ${v.name}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${traceArg(this, t)}, i1 zeroext ${object})`);
+            B.line(`call void @scr_throw_ref_classified(ptr ${v.name}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${traceArg(this.shapeHost, t)}, i1 zeroext ${object})`);
         }
         else {
-            const rc = vAdapters(this, t);
+            const rc = vAdapters(this.shapeHost, t);
             this.declare(`declare void @scr_throw_ref(ptr, ptr, ptr, ptr)`);
-            B.line(`call void @scr_throw_ref(ptr ${v.name}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${traceArg(this, t)})`);
+            B.line(`call void @scr_throw_ref(ptr ${v.name}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${traceArg(this.shapeHost, t)})`);
         }
     }
     /** JS truthiness of a value (falsy: false, 0, -0, NaN, "", nullish
@@ -2052,7 +2202,7 @@ class LlEmitter {
     truthy(v) {
         const B = this.B;
         if (v.type.kind === "union") {
-            // The ARM value's ToBoolean: an inline tag switch (the C emitter's
+            // The ARM value's ToBoolean: an inline tag switch (the runtime ABI’s
             // per-union interned helper, emitted at the use site instead).
             const def = this.unionsById.get(v.type.unionId);
             if (!def)
@@ -2062,7 +2212,7 @@ class LlEmitter {
             const join = B.newLabel("ut.j");
             this.unionTagSwitch(v.name, def, (arm) => {
                 let valueName = "false";
-                if (arm.kind === "f64") {
+                if (arm.kind === "f64" || arm.kind === "procStream") {
                     valueName = B.tmp();
                     this.declare(`declare double @scr_union_get_f64(ptr)`);
                     B.line(`${valueName} = call double @scr_union_get_f64(ptr ${v.name})`);
@@ -2075,7 +2225,7 @@ class LlEmitter {
                 else if (arm.kind === "string") {
                     valueName = this.unionPeek(v.name);
                 }
-                else if (arm.kind === "bigint") {
+                else if (arm.kind === "bigint" || arm.kind === "dyn" || arm.kind === "jsval") {
                     valueName = this.unionPeek(v.name);
                 }
                 const truthy = this.truthyOf(arm.kind, valueName, true);
@@ -2096,15 +2246,10 @@ class LlEmitter {
         switch (kind) {
             case "undefinedT":
             case "nullT":
-                if (!unionArm)
-                    throw new LlvmUnsupportedError(`truthy:${kind}`);
                 return "false";
             case "bool":
                 return valueName;
-            case "f64":
-            case "procStream": {
-                if (unionArm && kind === "procStream")
-                    throw new LlvmUnsupportedError(`truthy:union:${kind}`);
+            case "f64": {
                 const truthy = B.tmp();
                 B.line(`${truthy} = fcmp one double ${valueName}, ${f64Lit(0)}`);
                 return truthy;
@@ -2125,6 +2270,9 @@ class LlEmitter {
                 return truthy;
             }
             case "date":
+            // Process streams use a numeric descriptor internally, including zero
+            // for stdin. They remain JavaScript objects in boolean contexts.
+            case "procStream":
                 return "true";
             case "array":
             case "record":
@@ -2148,7 +2296,17 @@ class LlEmitter {
             case "generator":
             case "fsWatcher":
             case "cryptoHash":
-            case "cryptoHmac": {
+            case "cryptoHmac":
+            case "netSocket":
+            case "netServer":
+            case "httpReq":
+            case "httpRes":
+            case "httpClientReq":
+            case "http2Session":
+            case "http2Stream":
+            case "dgramSocket":
+            case "secureCtx":
+            case "testCtx": {
                 if (unionArm)
                     return "true";
                 const truthy = B.tmp();
@@ -2156,16 +2314,12 @@ class LlEmitter {
                 return truthy;
             }
             case "dyn": {
-                if (unionArm)
-                    throw new LlvmUnsupportedError(`truthy:union:${kind}`);
                 this.declare(`declare zeroext i1 @scr_dyn_truthy(ptr)`);
                 const truthy = B.tmp();
                 B.line(`${truthy} = call zeroext i1 @scr_dyn_truthy(ptr ${valueName})`);
                 return truthy;
             }
             case "jsval": {
-                if (unionArm)
-                    throw new LlvmUnsupportedError(`truthy:union:${kind}`);
                 this.declare(`declare i32 @scr_jsval_truthy(ptr)`);
                 const raw = B.tmp();
                 const truthy = B.tmp();
@@ -2197,17 +2351,48 @@ class LlEmitter {
     }
     /** Emits `switch` over a union's tag with one block per arm; each arm
      * body must TERMINATE its block (the callers branch to a join). The
-     * default block is the C emitter's invalid-tag abort. */
-    unionTagSwitch(uName, def, arm) {
+     * default block is the runtime ABI’s invalid-tag abort. Shared field
+     * reads can group equivalent storage prefixes and emit one representative. */
+    unionTagSwitch(uName, def, arm, fieldGroups) {
         const B = this.B;
         const tag = this.unionTag(uName);
         const bad = B.newLabel("u.bad");
-        const labels = def.arms.map(() => B.newLabel("u.a"));
-        B.terminate(`switch i32 ${tag}, label %${bad} [ ${def.arms.map((_, i) => `i32 ${i}, label %${labels[i]}`).join(" ")} ]`);
-        def.arms.forEach((a, i) => {
-            B.startBlock(labels[i]);
-            arm(a, i);
-        });
+        const labels = [];
+        if (fieldGroups) {
+            for (const group of fieldGroups) {
+                const label = B.newLabel("u.a");
+                for (const member of group) {
+                    if (member === undefined)
+                        throw new InternalCompilerError("llvm emitter bug: missing union field tag");
+                    labels[member] = label;
+                }
+            }
+        }
+        else {
+            for (let i = 0; i < def.arms.length; i++)
+                labels.push(B.newLabel("u.a"));
+        }
+        if (fieldGroups?.length === 1) {
+            const valid = B.tmp();
+            B.line(`${valid} = icmp ult i32 ${tag}, ${def.arms.length}`);
+            B.condBr(valid, labels[0], bad);
+        }
+        else {
+            B.terminate(`switch i32 ${tag}, label %${bad} [ ${def.arms.map((_, i) => `i32 ${i}, label %${labels[i]}`).join(" ")} ]`);
+        }
+        if (fieldGroups) {
+            for (const group of fieldGroups) {
+                const representative = group[0];
+                B.startBlock(labels[representative]);
+                arm(def.arms[representative], representative);
+            }
+        }
+        else {
+            def.arms.forEach((a, i) => {
+                B.startBlock(labels[i]);
+                arm(a, i);
+            });
+        }
         B.startBlock(bad);
         this.needsBadTag = true;
         B.line(`call void @sc_bad_tag()`);
@@ -2248,9 +2433,9 @@ class LlEmitter {
             B.line(`${t} = call ptr @scr_union_new_bool(i32 ${tag}, i1 ${v.name})`);
             return t;
         }
-        const rc = vAdapters(this, v.type);
+        const rc = vAdapters(this.shapeHost, v.type);
         this.declare(`declare ptr @scr_union_new_ref(i32, ptr, ptr, ptr, ptr)`);
-        B.line(`${t} = call ptr @scr_union_new_ref(i32 ${tag}, ptr ${v.name}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${traceArg(this, v.type)})`);
+        B.line(`${t} = call ptr @scr_union_new_ref(i32 ${tag}, ptr ${v.name}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${traceArg(this.shapeHost, v.type)})`);
         return t;
     }
     // ── class plumbing ──────────────────────────────────────────────────────
@@ -2263,7 +2448,7 @@ class LlEmitter {
     /** The field-slot pointer of a class member: rc at 0, the vtable word at
      * 1 on hierarchy members, then the flattened field list. Runtime error
      * classes GEP through %ScrError (their structs live in the runtime; the
-     * def's [name, message, %code] order matches the layout). */
+     * def's [name, message, %code, %cause] order matches the layout). */
     classFieldPtr(objName, className, field) {
         const meta = this.classMetaOf(className);
         const { index, type } = classFieldIndex(meta, field);
@@ -2302,6 +2487,37 @@ class LlEmitter {
             throw new InternalCompilerError(`llvm emitter bug: unknown record shape ${shapeId}`);
         return shape;
     }
+    /** Record prefixes with the same LLVM storage types put a field at the
+     * same offset on every target. Share one field-read block per matching
+     * prefix; class variants retain their own concrete layout dispatch. */
+    unionFieldGroups(def, field) {
+        const key = `${def.id}\0${field}`;
+        const cached = this.unionFieldReadGroups.get(key);
+        if (cached !== undefined)
+            return cached;
+        const groups = new Map();
+        for (let tag = 0; tag < def.arms.length; tag++) {
+            const arm = def.arms[tag];
+            let layout = `variant:${tag}`;
+            if (arm.kind === "record") {
+                const shape = this.recordShape(arm.shapeId);
+                const index = shape.fields.findIndex((entry) => entry.name === field);
+                if (index < 0)
+                    throw new InternalCompilerError(`llvm emitter bug: missing union field ${field}`);
+                layout = "record:";
+                for (let i = 0; i <= index; i++)
+                    layout += `${llFieldType(shape.fields[i].type)};`;
+            }
+            const group = groups.get(layout);
+            if (group)
+                group.push(tag);
+            else
+                groups.set(layout, [tag]);
+        }
+        const result = [...groups.values()];
+        this.unionFieldReadGroups.set(key, result);
+        return result;
+    }
     /** The field-slot pointer of a record member (rc header at index 0). */
     recordFieldPtr(objName, shapeId, field) {
         const shape = this.recordShape(shapeId);
@@ -2426,7 +2642,7 @@ class LlEmitter {
         const B = this.B;
         const acc = boxAccess(t);
         const cell = B.tmp();
-        B.line(`${cell} = ${arrNewCall(this, t, "1")} ; TDZ cell`);
+        B.line(`${cell} = ${arrNewCall(this.shapeHost, t, "1")} ; TDZ cell`);
         this.arrPush(cell, acc === "bool" ? "bool" : "f64", value);
         this.declare(`declare void @scr_box_set_ref(ptr, ptr)`);
         B.line(`call void @scr_box_set_ref(ptr ${box}, ptr ${cell})`);
@@ -2435,7 +2651,7 @@ class LlEmitter {
      * the temporal dead zone — throw Node's exact catchable ReferenceError
      * (exprs.ts's varRef guard). Scalars then peek the one-element
      * array cell; ref kinds read the box normally (+1). */
-    tdzBoxRead(box, t, name) {
+    checkTdz(box, name) {
         const B = this.B;
         const slotp = B.tmp();
         const slotv = B.tmp();
@@ -2443,6 +2659,22 @@ class LlEmitter {
         B.line(`${slotp} = getelementptr inbounds %ScrBox, ptr ${box}, i64 0, i32 5`);
         B.line(`${slotv} = load i64, ptr ${slotp}`);
         B.line(`${empty} = icmp eq i64 ${slotv}, 0`);
+        this.throwIfUninitialized(empty, name);
+        return slotv;
+    }
+    checkGlobalTdz(id) {
+        const name = this.tdzGlobals.get(id);
+        if (name === undefined)
+            return;
+        const B = this.B;
+        const value = B.tmp();
+        const empty = B.tmp();
+        B.line(`${value} = load ptr, ptr @${mangleGlobal(id)}`);
+        B.line(`${empty} = icmp eq ptr ${value}, null`);
+        this.throwIfUninitialized(empty, name);
+    }
+    throwIfUninitialized(empty, name) {
+        const B = this.B;
         const lt = B.newLabel("tdz.t");
         const lk = B.newLabel("tdz.k");
         B.condBr(empty, lt, lk);
@@ -2455,6 +2687,10 @@ class LlEmitter {
         B.line(`call void @scr_throw_error_named(ptr ${errName}, ptr ${msg})`);
         this.emitUnwind();
         B.startBlock(lk);
+    }
+    tdzBoxRead(box, t, name) {
+        const slotv = this.checkTdz(box, name);
+        const B = this.B;
         const acc = boxAccess(t);
         if (acc === "ref")
             return this.boxGet(box, t);
@@ -2468,12 +2704,34 @@ class LlEmitter {
         B.line(`${v} = call ${accTy} @scr_arr_get_${acc}(ptr ${cell}, double ${f64Lit(0)})`);
         return v;
     }
+    /** Declaration stores initialize an empty TDZ box. Later stores check
+     * it after the RHS and update scalar cells in place. References move in. */
+    writeBindingBox(box, local, value, initializes = false, borrowed = false) {
+        if (local.tdz) {
+            const first = initializes || !local.mutable;
+            const slotv = first ? null : this.checkTdz(box, local.name);
+            const acc = boxAccess(local.type);
+            if (acc !== "ref") {
+                if (first)
+                    this.tdzScalarInit(box, local.type, value);
+                else {
+                    const cell = this.B.tmp();
+                    this.B.line(`${cell} = inttoptr i64 ${slotv} to ptr`);
+                    const ty = acc === "bool" ? "i1" : "double";
+                    this.declare(`declare void @scr_arr_set_${acc}(ptr, double, ${acc === "bool" ? "i1 zeroext" : ty})`);
+                    this.B.line(`call void @scr_arr_set_${acc}(ptr ${cell}, double ${f64Lit(0)}, ${ty} ${value})`);
+                }
+                return;
+            }
+        }
+        this.boxSet(box, local.type, borrowed && isRefCounted(local.type) ? this.retainValue(value, local.type) : value);
+    }
     // ── functions ───────────────────────────────────────────────────────────
     /** The LLVM symbol a direct call or closure enters a function through:
      * async bodies are entered via their emitted spawn wrapper (which runs
      * the fiber eagerly to its first suspension and returns the promise);
      * generator bodies via theirs (which only ALLOCATES the suspended
-     * fiber and returns the generator object) — CEmitter.callTargetC. */
+     * fiber and returns the generator object). */
     callTarget(fnName) {
         const fn = this.fnByName.get(fnName);
         if (fn?.generator !== undefined)
@@ -2537,7 +2795,7 @@ class LlEmitter {
                     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})`);
+                    this.B.line(`call void @scr_gen_out_ref(ptr ${gen}, ptr ${v.name}, ptr ${vAdapters(this.shapeHost, ret).release})`);
                     return;
             }
         }
@@ -2562,10 +2820,14 @@ class LlEmitter {
                 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;
+            case "dyn":
+                this.declare(`declare void @scr_promise_resolve_dyn(ptr, ptr)`);
+                this.B.line(`call void @scr_promise_resolve_dyn(ptr ${pr}, ptr ${v.name}) ; moves in`);
+                break;
             default: {
-                const rc = vAdapters(this, ret);
+                const rc = vAdapters(this.shapeHost, 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)})`);
+                this.B.line(`call void @scr_promise_fulfill_ref(ptr ${pr}, ptr ${v.name}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${traceArg(this.shapeHost, ret)})`);
             }
         }
     }
@@ -2576,9 +2838,10 @@ class LlEmitter {
         B.debugLocation = this.debug?.location(fn.loc, this.debugScope) ?? null;
         this.frames = [];
         this.scopes = [];
+        this.unwindCleanups.clear();
         this.jumpTargets = [];
         this.currentLocals = new Map(fn.locals.map((l) => [l.id, l]));
-        this.captureIds = new Set((fn.captures ?? []).map((c) => c.localId));
+        this.captureIds = new Set([...(fn.captures ?? []), ...(fn.classCaptures ?? [])].map((c) => c.localId));
         this.integerLoopBindings.clear();
         this.integerRanges = analyzeIntegerRanges(fn);
         this.chainSlots.clear();
@@ -2595,7 +2858,7 @@ class LlEmitter {
             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 void @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)`);
@@ -2651,6 +2914,22 @@ class LlEmitter {
             B.line(`${box} = load ptr, ptr ${p}`);
             B.line(`store ptr ${box}, ptr %${mangleLocal(c.localId)} ; captured ${c.name}`);
         });
+        (fn.classCaptures ?? []).forEach((c) => {
+            const self = fn.params[0];
+            if (self.type.kind !== "object")
+                throw new InternalCompilerError("class captures require an instance receiver");
+            const classSlot = B.tmp();
+            const classValue = B.tmp();
+            const caps = B.tmp();
+            const slot = B.tmp();
+            const box = B.tmp();
+            B.line(`${classSlot} = getelementptr inbounds %${mangleClassStruct(self.type.className)}, ptr %p_${mangleLocal(self.localId)}, i64 0, i32 ${classEnvironmentIndex(this.classMeta.get(self.type.className))}`);
+            B.line(`${classValue} = load ptr, ptr ${classSlot}`);
+            B.line(`${caps} = getelementptr inbounds %ScrClassObj, ptr ${classValue}, i64 1`);
+            B.line(`${slot} = getelementptr inbounds ptr, ptr ${caps}, ${this.sizeType} ${c.slot}`);
+            B.line(`${box} = load ptr, ptr ${slot}`);
+            B.line(`store ptr ${box}, ptr %${mangleLocal(c.localId)} ; class capture ${c.name}`);
+        });
         // Params spill into their slots; the function scope owns refcounted
         // params (callees own their params — callers passed +1). Boxed params
         // allocate the shared binding and move the raw value in.
@@ -2660,7 +2939,7 @@ class LlEmitter {
             const slot = `%${mangleLocal(p.localId)}`;
             if (local.boxed) {
                 const box = B.tmp();
-                B.line(`${box} = ${boxNewCall(this, p.type)} ; ${p.name} (boxed param)`);
+                B.line(`${box} = ${boxNewCall(this.shapeHost, p.type)} ; ${p.name} (boxed param)`);
                 this.boxSet(box, p.type, `%p_${mangleLocal(p.localId)}`);
                 B.line(`store ptr ${box}, ptr ${slot}`);
                 fnScope.push({ slot, type: p.type, boxed: true });
@@ -2671,6 +2950,16 @@ class LlEmitter {
                 fnScope.push({ slot, type: p.type });
         }
         this.scopes.push(fnScope);
+        // Stackful native fibers retain these frames while suspended. The
+        // active exception context owns the chain, so concurrent fibers isolate it.
+        if (this.stackTraces && !this.wasi && fn.sourceName !== undefined) {
+            this.declare(`declare void @scr_stack_enter(ptr, ptr)`);
+            this.declare(`declare void @scr_stack_leave(ptr)`);
+            B.entryAllocas.push(`%source_frame = alloca { ptr, ptr }`);
+            const frame = `    at ${fn.sourceName} (${fn.loc.file})`;
+            B.line(`call void @scr_stack_enter(ptr %source_frame, ptr ${this.cstr(frame)})`);
+            B.returnEpilogue = `call void @scr_stack_leave(ptr %source_frame)`;
+        }
         this.emitStmts(fn.body);
         // Implicit exit of a void function: release the function scope unless
         // the body already terminated its final block (return, or a throw
@@ -2710,8 +2999,7 @@ class LlEmitter {
             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)`);
+            B.line(`call void @llvm.coro.end(ptr ${coro.handle}, i1 false, token none)`);
             const ret = this.llType(fn.returnType);
             if (ret === "void")
                 B.terminate(`ret void`);
@@ -2722,6 +3010,14 @@ class LlEmitter {
             else
                 B.terminate(`ret ptr null`);
         }
+        // Shared blocks have multiple source locations. Keep the location on
+        // each incoming exception check instead of assigning one to the cleanup.
+        B.debugLocation = null;
+        for (const cleanup of this.unwindCleanups.values()) {
+            B.startBlock(cleanup.label);
+            this.releaseScope(cleanup.entries);
+            B.terminate(cleanup.terminator);
+        }
         if (this.logArgSlots > 0) {
             B.entryAllocas.push(`%logargs = alloca [${this.logArgSlots} x %ScrLogArg]`);
         }
@@ -2738,15 +3034,15 @@ class LlEmitter {
     emitStmts(stmts) {
         for (const s of stmts) {
             // Statements after a terminator are unreachable (dead code after
-            // return/break/continue) — the C emitter emits them as dead C; here
-            // they are skipped so no dropped SSA definition can leak forward.
+            // return/break/continue). Skip them so no dropped SSA definition
+            // can leak forward.
             if (this.B.isTerminated())
                 return;
             this.emitStmt(s);
         }
     }
     /** Emits a block in its own lexical scope (refcounted locals released at
-     * end) — CEmitter.emitBlock without the braces. `setup` runs after the
+     * end). `setup` runs after the
      * scope opens, before the statements — the catch-binding hook: it may
      * emit prelude lines and register entries the scope owns (released on
      * every exit, jumps and unwinds included). */
@@ -2785,7 +3081,7 @@ class LlEmitter {
                     // bit pattern to spend on it (stmts.ts's varDecl).
                     const boxNew = b.local.tdz === true && boxAccess(b.type) !== "ref"
                         ? (this.declare(`declare ptr @scr_box_new(i32)`), `call ptr @scr_box_new(i32 3)`)
-                        : boxNewCall(this, b.type);
+                        : boxNewCall(this.shapeHost, b.type);
                     const box = B.tmp();
                     B.line(`${box} = ${boxNew} ; let ${b.local.name} (boxed)`);
                     B.line(`store ptr ${box}, ptr ${b.slot}`);
@@ -2830,17 +3126,13 @@ class LlEmitter {
                 }
                 const b = this.binding(s.localId);
                 const v = this.emitExpr(s.value);
+                if (b.kind === "global" && !s.initializes)
+                    this.checkGlobalTdz(s.localId);
                 if (b.kind === "boxed") {
+                    this.writeBindingBox(this.loadBox(b.slot), b.local, v.name, s.initializes);
+                    // The RHS remains frame-owned until a possible TDZ throw passes.
                     if (isRefCounted(v.type))
-                        this.moveTemp(v); // set_ref releases the old value
-                    // A scalar TDZ box (forward-captured const): the initializing
-                    // write mints the one-element array cell — set_ref moves it in
-                    // (and the empty-slot sentinel ends here).
-                    if (b.local.tdz === true && boxAccess(b.type) !== "ref") {
-                        this.tdzScalarInit(this.loadBox(b.slot), b.type, v.name);
-                        break;
-                    }
-                    this.boxSet(this.loadBox(b.slot), b.type, v.name);
+                        this.moveTemp(v);
                     break;
                 }
                 this.moveTemp(v);
@@ -2899,8 +3191,8 @@ class LlEmitter {
             case "bytesSet": {
                 // Typed-array element write: same evaluation order as arraySet;
                 // the value is a scalar (the kind-specific inline path coerces
-                // JS-exactly), so no ownership moves. Any invalid index traps — no
-                // append. IrBytesElem is static, so never rediscover it through the
+                // JS-exactly), so no ownership moves. Invalid writes are ignored.
+                // IrBytesElem is static, so never rediscover it through the
                 // generic runtime switch in a hot loop.
                 const arr = this.emitStableReceiver(s.arr, [s.index, s.value]);
                 const integerIndex = this.emitIntegerLoopIndex(s.index);
@@ -2933,6 +3225,17 @@ class LlEmitter {
                 else {
                     this.storeField(ptr, type, v.name);
                 }
+                if (s.kind === "fieldSet" && s.field === "name" && this.classMeta.get(s.className)?.root.def.name === "%Error") {
+                    const present = this.classFieldPtr(obj.name, s.className, "%namePresent").ptr;
+                    const enumerable = this.classFieldPtr(obj.name, s.className, "%nameEnumerable").ptr;
+                    const wasPresent = B.tmp(), wasEnumerable = B.tmp(), isPresent = B.tmp(), nextEnumerable = B.tmp();
+                    B.line(`${wasPresent} = load i8, ptr ${present}`);
+                    B.line(`${wasEnumerable} = load i8, ptr ${enumerable}`);
+                    B.line(`${isPresent} = icmp ne i8 ${wasPresent}, 0`);
+                    B.line(`${nextEnumerable} = select i1 ${isPresent}, i8 ${wasEnumerable}, i8 1`);
+                    B.line(`store i8 1, ptr ${present}`);
+                    B.line(`store i8 ${nextEnumerable}, ptr ${enumerable}`);
+                }
                 break;
             }
             case "recordKeyDelete": {
@@ -3130,7 +3433,7 @@ class LlEmitter {
                     kind: "loop",
                     brkLabel: le,
                     contLabel: lc,
-                    ...(s.labels !== undefined && { labels: s.labels }),
+                    labels: s.labels,
                     frameDepth: this.frames.length,
                     scopeDepth: this.scopes.length,
                     finallyDepth: this.finallyStack.length,
@@ -3152,7 +3455,7 @@ class LlEmitter {
                     kind: "loop",
                     brkLabel: le,
                     contLabel: lc,
-                    ...(s.labels !== undefined && { labels: s.labels }),
+                    labels: s.labels,
                     frameDepth: this.frames.length,
                     scopeDepth: this.scopes.length,
                     finallyDepth: this.finallyStack.length,
@@ -3178,7 +3481,12 @@ class LlEmitter {
                     this.integerLoopBindings.set(integerLoop.localId, integerSlot);
                 }
                 else if (s.init) {
-                    this.emitStmt(s.init);
+                    // A multi-declarator head shares the loop's scope. Emitting its
+                    // IR block as an ordinary block would release captured/ref locals
+                    // before the first condition.
+                    const initializers = s.init.kind === "block" ? s.init.body : [s.init];
+                    for (const initializer of initializers)
+                        this.emitStmt(initializer);
                 }
                 const lc = B.newLabel("loop.c");
                 const lb = B.newLabel("loop.b");
@@ -3186,11 +3494,29 @@ class LlEmitter {
                 // JS `for (let i ...)`: each iteration gets a FRESH binding holding
                 // a copy of the previous one (closures made in iteration k keep
                 // seeing iteration k's value) — only observable, and only emitted,
-                // when the init variable is captured (boxed). The freshening (and
-                // the update) live in the continue-target block.
-                const initLocal = s.init?.kind === "varDecl" ? this.currentLocals.get(s.init.localId) : undefined;
-                const freshens = initLocal?.boxed === true;
-                const lu = s.update || freshens ? B.newLabel("loop.u") : lc;
+                // when a let variable is captured (boxed). Freshen before the first
+                // condition and again in the continue-target block before updating.
+                const initializers = s.init?.kind === "block" ? s.init.body : s.init ? [s.init] : [];
+                const capturedLets = initializers.flatMap((init) => {
+                    const local = init.kind === "varDecl" ? this.currentLocals.get(init.localId) : undefined;
+                    return local?.boxed && local.mutable ? [local] : [];
+                });
+                const freshenBindings = () => {
+                    for (const local of capturedLets) {
+                        const slot = `%${mangleLocal(local.id)}`;
+                        const fresh = B.tmp();
+                        const old = B.tmp();
+                        B.line(`${fresh} = ${boxNewCall(this.shapeHost, local.type)} ; per-iteration ${local.name}`);
+                        B.line(`${old} = load ptr, ptr ${slot}`);
+                        const val = this.boxGet(old, local.type);
+                        this.boxSet(fresh, local.type, val);
+                        this.declare(`declare void @scr_box_release(ptr)`);
+                        B.line(`call void @scr_box_release(ptr ${old})`);
+                        B.line(`store ptr ${fresh}, ptr ${slot}`);
+                    }
+                };
+                const lu = s.update || capturedLets.length > 0 ? B.newLabel("loop.u") : lc;
+                freshenBindings();
                 B.br(lc);
                 B.startBlock(lc);
                 if (integerLoop && integerSlot) {
@@ -3214,7 +3540,7 @@ class LlEmitter {
                     kind: "loop",
                     brkLabel: le,
                     contLabel: lu,
-                    ...(s.labels !== undefined && { labels: s.labels }),
+                    labels: s.labels,
                     frameDepth: this.frames.length,
                     scopeDepth: this.scopes.length,
                     finallyDepth: this.finallyStack.length,
@@ -3224,20 +3550,7 @@ class LlEmitter {
                 B.br(lu);
                 if (lu !== lc) {
                     B.startBlock(lu);
-                    if (freshens && initLocal) {
-                        const slot = `%${mangleLocal(initLocal.id)}`;
-                        const fresh = B.tmp();
-                        const old = B.tmp();
-                        B.line(`${fresh} = ${boxNewCall(this, initLocal.type)} ; per-iteration ${initLocal.name}`);
-                        B.line(`${old} = load ptr, ptr ${slot}`);
-                        const val = this.boxGet(old, initLocal.type); // ref: +1 out
-                        this.boxSet(fresh, initLocal.type, val); // takes ownership
-                        this.declare(`declare void @scr_box_release(ptr)`);
-                        B.line(`call void @scr_box_release(ptr ${old})`);
-                        B.line(`store ptr ${fresh}, ptr ${slot}`);
-                        // The wrapper scope's entry releases whatever the slot points
-                        // to at loop exit — now the freshest binding. Nothing to fix.
-                    }
+                    freshenBindings();
                     if (integerLoop && integerSlot) {
                         const old = B.tmp();
                         const next = B.tmp();
@@ -3286,7 +3599,7 @@ class LlEmitter {
                     kind: "loop",
                     brkLabel: le,
                     contLabel: lu,
-                    ...(s.labels !== undefined && { labels: s.labels }),
+                    labels: s.labels,
                     frameDepth: this.frames.length,
                     scopeDepth: this.scopes.length,
                     finallyDepth: this.finallyStack.length,
@@ -3307,7 +3620,7 @@ class LlEmitter {
                     // fresh const binding. The box takes ownership of a ref element's
                     // +1 and is released with the iteration's scope.
                     const box = B.tmp();
-                    B.line(`${box} = ${boxNewCall(this, elem)} ; per-iteration ${localInfo.name}`);
+                    B.line(`${box} = ${boxNewCall(this.shapeHost, elem)} ; per-iteration ${localInfo.name}`);
                     this.boxSet(box, elem, cur);
                     B.line(`store ptr ${box}, ptr ${slot}`);
                     this.scopes[this.scopes.length - 1].push({ slot, type: elem, boxed: true });
@@ -3380,10 +3693,7 @@ class LlEmitter {
                 // tryStack it sees truncated to its region (its releases already
                 // ran; a throw inside a copy propagates OUT of the completing
                 // try, past its own catch), then the function-level releases and
-                // the actual ret. The C emitter routes this through per-region
-                // finally copies behind gotos with the value parked in sc_pret;
-                // the inline copies here are the same code at the same depths,
-                // with the parked value's ownership riding a synthetic slot-based
+                // the actual ret. The parked value owns a synthetic slot-backed
                 // scope entry during each copy so a throwing finally releases it.
                 let v = null;
                 if (s.value !== null) {
@@ -3450,10 +3760,9 @@ class LlEmitter {
             case "rethrow": {
                 // Re-raise the saved snapshot (payload retained — the binding
                 // local releases with its scope) and unwind like `throw`.
-                const c = B.tmp();
-                B.line(`${c} = load ptr, ptr %${mangleLocal(s.localId)}`);
+                const c = this.emitExpr({ kind: "varRef", localId: s.localId, type: CAUGHT, loc: s.loc });
                 this.declare(`declare void @scr_rethrow(ptr)`);
-                B.line(`call void @scr_rethrow(ptr ${c})`);
+                B.line(`call void @scr_rethrow(ptr ${c.name})`);
                 this.emitUnwind();
                 break;
             }
@@ -3571,8 +3880,17 @@ class LlEmitter {
                 this.emitBlock(s.catchBody, (scope) => {
                     const c = B.tmp();
                     B.line(`${c} = call ptr @scr_exc_take() ; catch binding`);
-                    B.line(`store ptr ${c}, ptr ${slot}`);
-                    scope.push({ slot, type: CAUGHT });
+                    if (this.currentLocals.get(s.catchLocalId)?.boxed) {
+                        const box = B.tmp();
+                        B.line(`${box} = ${boxNewCall(this.shapeHost, CAUGHT)} ; captured exception`);
+                        this.boxSet(box, CAUGHT, c);
+                        B.line(`store ptr ${box}, ptr ${slot}`);
+                        scope.push({ slot, type: CAUGHT, boxed: true });
+                    }
+                    else {
+                        B.line(`store ptr ${c}, ptr ${slot}`);
+                        scope.push({ slot, type: CAUGHT });
+                    }
                 });
             }
             else {
@@ -3638,7 +3956,7 @@ class LlEmitter {
     }
     /** JS-exact switch: lazily evaluated, arbitrary-expression case tests in
      * source order, bodies falling through in source order until a break —
-     * CEmitter.emitSwitch's goto chain, block-flavored. All case bodies
+     * A chain of conditional branches. All case bodies
      * share ONE scope; because dispatch can jump PAST a varDecl into a later
      * case, refcounted/boxed case-body locals are NULL-reset up front and
      * the scope-exit releases rely on NULL tolerance. */
@@ -3696,7 +4014,7 @@ class LlEmitter {
             kind: "switch",
             brkLabel: end,
             contLabel: null,
-            ...(s.labels !== undefined && { labels: s.labels }),
+            labels: s.labels,
             frameDepth: this.frames.length,
             scopeDepth: this.scopes.length,
             finallyDepth: this.finallyStack.length,
@@ -3721,7 +4039,7 @@ class LlEmitter {
     /** Evaluates a condition (IR conds are bool-typed) and releases its
      * temps BEFORE the branch — safe because the result is a scalar i1, and
      * required in loop-condition blocks (their temps must not survive into
-     * later blocks across the back edge). CEmitter.emitCondition. */
+     * later blocks across the back edge). */
     emitCondition(cond) {
         const v = this.emitExpr(cond);
         const frame = this.currentFrame();
@@ -3732,7 +4050,7 @@ class LlEmitter {
     /** Evaluates `expr` in its own statement frame inside an already-open
      * branch and moves the result into `slot`: the chosen value's ownership
      * transfers, every other temp the arm allocated releases inside the
-     * branch. The shared core of ternary/logical. CEmitter.emitBranchInto. */
+     * branch. The shared core of ternary/logical. */
     emitBranchInto(slot, expr) {
         this.frames.push([]);
         const v = this.emitExpr(expr);
@@ -3741,24 +4059,28 @@ class LlEmitter {
         this.releaseFrame(this.frames.pop());
     }
     // ── expressions ─────────────────────────────────────────────────────────
-    /** One audited escape hatch for the type-only boundary used by the
-     * extracted expression modules. LlEmitter remains the sole owner of the
-     * mutable emission state; the context exposes only the operations those
-     * modules require. */
-    expressionContext() {
-        return this;
-    }
     emitLiteralExpr(e) {
-        return emitLiteralExpr(this.expressionContext(), e);
+        return emitLiteralExpr(this, e);
     }
     emitOperatorExpr(e) {
-        return emitOperatorExpr(this.expressionContext(), e);
+        if (e.kind === "seqExpr") {
+            // Saved operands can feed later call arguments. Transfer ownership
+            // to this expression's frame so they survive those reads and still
+            // die on the path that created them, including inside lazy branches.
+            this.scopes.push([]);
+            const result = emitOperatorExpr(this, e);
+            for (const local of this.scopes.pop()) {
+                this.currentFrame().push({ name: local.slot, type: local.type, slot: true, ...(local.boxed ? { boxed: true } : {}) });
+            }
+            return result;
+        }
+        return emitOperatorExpr(this, e);
     }
     emitControlExpr(e) {
-        return emitControlExpr(this.expressionContext(), e);
+        return emitControlExpr(this, e);
     }
     emitStringExpr(e) {
-        return emitStringExpr(this.expressionContext(), e);
+        return emitStringExpr(this, e);
     }
     /**
      * Lower canonical `target = target + suffix` after evaluating the old
@@ -3802,251 +4124,273 @@ class LlEmitter {
         return result;
     }
     emitContainerExpr(e) {
-        return emitContainerExpr(this.expressionContext(), e);
+        return emitContainerExpr(this, e);
     }
     emitCallExpr(e) {
-        return emitCallExpr(this.expressionContext(), e);
+        return emitCallExpr(this, e);
     }
     emitRecordExpr(e) {
-        return emitRecordExpr(this.expressionContext(), e);
+        return emitRecordExpr(this, e);
     }
     emitDynamicExpr(e) {
-        return emitDynamicExpr(this.expressionContext(), e);
+        return emitDynamicExpr(this, e);
     }
     emitIntrinsicExpr(e) {
-        return emitIntrinsicExpr(this.expressionContext(), e);
+        return emitIntrinsicExpr(this, e);
     }
     emitSerializationExpr(e) {
-        return emitSerializationExpr(this.expressionContext(), e);
+        return emitSerializationExpr(this, e);
     }
     emitAsyncExpr(e) {
-        return emitAsyncExpr(this.expressionContext(), e);
+        return emitAsyncExpr(this, e);
     }
     emitJsInteropExpr(e) {
-        return emitJsInteropExpr(this.expressionContext(), e);
+        return emitJsInteropExpr(this, e);
+    }
+    /** Read a receiver whose value is consumed immediately by a field or tag
+     * load. No user code may run between this read and its consumer. Locals
+     * and their projections already have an owner; other expressions keep
+     * their ordinary statement-frame ownership. The caller must retain any
+     * reference result before evaluating another expression. */
+    emitReadReceiver(e) {
+        if (!isRefCounted(e.type))
+            return this.emitExpr(e);
+        if (e.kind === "varRef") {
+            const binding = this.binding(e.localId);
+            // Capture boxes can carry TDZ and caught-value conversion semantics.
+            if (binding.kind === "boxed")
+                return this.emitExpr(e);
+            if (binding.kind === "global")
+                this.checkGlobalTdz(e.localId);
+            const value = this.B.tmp();
+            this.B.line(`${value} = load ptr, ptr ${binding.slot}`);
+            return { name: value, type: e.type };
+        }
+        if (e.kind === "unionNarrow") {
+            const union = this.emitReadReceiver(e.value);
+            return { name: this.unionPeek(union.name), type: e.type };
+        }
+        if (e.kind === "recordGet" || e.kind === "fieldGet") {
+            const receiver = this.emitReadReceiver(e.obj);
+            const { ptr, type } = e.kind === "recordGet"
+                ? this.recordFieldPtr(receiver.name, e.shapeId, e.field)
+                : this.classFieldPtr(receiver.name, e.className, e.field);
+            return { name: this.loadField(ptr, type), type: e.type };
+        }
+        return this.emitExpr(e);
     }
     emitExpr(e) {
-        return emitExpr(this.expressionContext(), e);
+        return emitExpr(this, e);
     }
     emitJsMarshal(e) {
-        return emitJsMarshal(this.expressionContext(), e);
+        return emitJsMarshal(this, e);
     }
     emitJsOp(e) {
-        return emitJsOp(this.expressionContext(), e);
+        return emitJsOp(this, e);
     }
     emitJsExit(e) {
-        return emitJsExit(this.expressionContext(), e);
+        return emitJsExit(this, e);
     }
     islandAdapter(arity, retKind) {
-        return islandAdapter(this.expressionContext(), arity, retKind);
+        return islandAdapter(this, arity, retKind);
     }
     islandTypedAdapter(fn) {
-        return islandTypedAdapter(this.expressionContext(), fn);
+        return islandTypedAdapter(this, fn);
     }
     dynKind(d) {
-        return dynKind(this.expressionContext(), d);
+        return dynKind(this, d);
     }
     raceAdapterFor(from, to) {
-        return raceAdapterFor(this.expressionContext(), from, to);
+        return raceAdapterFor(this, from, to);
     }
     genResultThunkFor(genT, recT) {
-        return genResultThunkFor(this.expressionContext(), genT, recT);
+        return genResultThunkFor(this, genT, recT);
     }
     childExitThunkFor(param) {
-        return childExitThunkFor(this.expressionContext(), param);
+        return childExitThunkFor(this, param);
     }
     execFileThunkFor(cbT) {
-        return execFileThunkFor(this.expressionContext(), cbT);
+        return execFileThunkFor(this, cbT);
     }
     ipcMessageThunkFor(cbT) {
-        return ipcMessageThunkFor(this.expressionContext(), cbT);
+        return ipcMessageThunkFor(this, cbT);
     }
     ipcSendThunkFor(cbT) {
-        return ipcSendThunkFor(this.expressionContext(), cbT);
+        return ipcSendThunkFor(this, cbT);
     }
     childExitSignalThunkFor(codeParam, sigParam) {
-        return childExitSignalThunkFor(this.expressionContext(), codeParam, sigParam);
+        return childExitSignalThunkFor(this, codeParam, sigParam);
     }
     childDataThunkFor(param) {
-        return childDataThunkFor(this.expressionContext(), param);
+        return childDataThunkFor(this, param);
     }
     emitterFixedAdapter(cbT) {
-        return emitterFixedAdapter(this.expressionContext(), cbT);
+        return emitterFixedAdapter(this, cbT);
     }
     wrapEmitterListener(target, adapterFn) {
-        return wrapEmitterListener(this.expressionContext(), target, adapterFn);
+        return wrapEmitterListener(this, target, adapterFn);
     }
     unwrapNullableClosure(u, funcTag) {
-        return unwrapNullableClosure(this.expressionContext(), u, funcTag);
+        return unwrapNullableClosure(this, u, funcTag);
     }
     closeBindThunkFor(cbUnion, retServer) {
-        return closeBindThunkFor(this.expressionContext(), cbUnion, retServer);
+        return closeBindThunkFor(this, cbUnion, retServer);
     }
     closeOverrideWrapFor(cbUnion, retServer) {
-        return closeOverrideWrapFor(this.expressionContext(), cbUnion, retServer);
+        return closeOverrideWrapFor(this, cbUnion, retServer);
     }
     streamDataAdapter(cbT) {
-        return streamDataAdapter(this.expressionContext(), cbT);
+        return streamDataAdapter(this, cbT);
     }
     streamDoneFnFor(kind, doneT) {
-        return streamDoneFnFor(this.expressionContext(), kind, doneT);
+        return streamDoneFnFor(this, kind, doneT);
     }
     fsRenameThunkFor(cbT) {
-        return fsRenameThunkFor(this.expressionContext(), cbT);
+        return fsRenameThunkFor(this, cbT);
     }
     cryptoBytesThunkFor(cbT) {
-        return cryptoBytesThunkFor(this.expressionContext(), cbT);
+        return cryptoBytesThunkFor(this, cbT);
     }
     zlibBytesThunkFor(cbT) {
-        return zlibBytesThunkFor(this.expressionContext(), cbT);
+        return zlibBytesThunkFor(this, cbT);
     }
     streamCbThunkFor(kind, cbT) {
-        return streamCbThunkFor(this.expressionContext(), kind, cbT);
+        return streamCbThunkFor(this, kind, cbT);
     }
     resolveThunkFor(inner) {
-        return resolveThunkFor(this.expressionContext(), inner);
+        return resolveThunkFor(this, inner);
     }
     tagInSet(uName, tags) {
-        return tagInSet(this.expressionContext(), uName, tags);
+        return tagInSet(this, uName, tags);
     }
     arrPush(arr, acc, value) {
-        return arrPush(this.expressionContext(), arr, acc, value);
+        return arrPush(this, arr, acc, value);
     }
     emitArrayCopyLoop(dst, src, acc) {
-        return emitArrayCopyLoop(this.expressionContext(), dst, src, acc);
+        return emitArrayCopyLoop(this, dst, src, acc);
     }
     emitStrIntrinsic(e) {
-        return emitStrIntrinsic(this.expressionContext(), e);
+        return emitStrIntrinsic(this, e);
     }
     emitArrIntrinsic(e) {
-        return emitArrIntrinsic(this.expressionContext(), e);
+        return emitArrIntrinsic(this, e);
     }
     wrapNullable(raw, present, valueType, valueTag, resultType, absentTag) {
-        return wrapNullable(this.expressionContext(), raw, present, valueType, valueTag, resultType, absentTag);
+        return wrapNullable(this, raw, present, valueType, valueTag, resultType, absentTag);
     }
     emitMapNew(e) {
-        return emitMapNew(this.expressionContext(), e);
+        return emitMapNew(this, e);
     }
     mapSet(m, kAcc, vAcc, key, value) {
-        return mapSet(this.expressionContext(), m, kAcc, vAcc, key, value);
+        return mapSet(this, m, kAcc, vAcc, key, value);
     }
     emitMapLikeIntrinsic(e) {
-        return emitMapLikeIntrinsic(this.expressionContext(), e);
+        return emitMapLikeIntrinsic(this, e);
     }
     emitSetNew(e) {
-        return emitSetNew(this.expressionContext(), e);
+        return emitSetNew(this, e);
     }
     emitStableReceiver(receiver, following) {
-        return emitStableReceiver(this.expressionContext(), receiver, following);
+        return emitStableReceiver(this, receiver, following);
     }
     emitIntegerLoopIndex(expr) {
-        return emitIntegerLoopIndex(this.expressionContext(), expr);
+        return emitIntegerLoopIndex(this, expr);
     }
     emitBytesIndex(receiver, index, integerIndex = false) {
-        return emitBytesIndex(this.expressionContext(), receiver, index, integerIndex);
+        return emitBytesIndex(this, receiver, index, integerIndex);
     }
     emitBytesData(receiver) {
-        return emitBytesData(this.expressionContext(), receiver);
+        return emitBytesData(this, receiver);
     }
     emitBytesLength(elem, receiver, bytes) {
-        return emitBytesLength(this.expressionContext(), elem, receiver, bytes);
+        return emitBytesLength(this, elem, receiver, bytes);
     }
     emitBytesGet(elem, receiver, index, integerIndex = false) {
-        return emitBytesGet(this.expressionContext(), elem, receiver, index, integerIndex);
+        return emitBytesGet(this, elem, receiver, index, integerIndex);
     }
     emitToUint32(value, expr) {
-        return emitToUint32(this.expressionContext(), value, expr);
+        return emitToUint32(this, value, expr);
     }
     emitBytesSet(elem, receiver, index, value, integerIndex = false) {
-        return emitBytesSet(this.expressionContext(), elem, receiver, index, value, integerIndex);
+        return emitBytesSet(this, elem, receiver, index, value, integerIndex);
     }
     emitBytesIntrinsic(e) {
-        return emitBytesIntrinsic(this.expressionContext(), e);
+        return emitBytesIntrinsic(this, e);
     }
     emitRegexIntrinsic(e) {
-        return emitRegexIntrinsic(this.expressionContext(), e);
+        return emitRegexIntrinsic(this, e);
     }
     emitRecordKeyGet(e) {
-        return emitRecordKeyGet(this.expressionContext(), e);
+        return emitRecordKeyGet(this, e);
     }
     keyedRecordReadInto(slot, join, objName, keyName, shapeId, resultType, overflowOnly, loc) {
-        return keyedRecordReadInto(this.expressionContext(), slot, join, objName, keyName, shapeId, resultType, overflowOnly, loc);
+        return keyedRecordReadInto(this, slot, join, objName, keyName, shapeId, resultType, overflowOnly, loc);
     }
     dynPromiseAdapter(inner) {
-        return dynPromiseAdapter(this.expressionContext(), inner);
+        return dynPromiseAdapter(this, inner);
     }
     streamTypedRefCommitAdapter(t, snapshot) {
-        return streamTypedRefCommitAdapter(this.expressionContext(), t, snapshot);
+        return streamTypedRefCommitAdapter(this, t, snapshot);
     }
     liveDynRefAdapter(t) {
-        const key = typeKey(t);
-        const existing = this.liveDynRefAdapters.get(key);
-        if (existing)
-            return existing;
         if (!streamTypedRefEligible(t) && !isDynTypedRefType(t)) {
-            throw new InternalCompilerError(`llvm emitter bug: live dyn ref of ${key}`);
+            throw new InternalCompilerError(`llvm emitter bug: live dyn ref of ${typeKey(t)}`);
         }
-        const prefix = `sc_ldr_${this.liveDynRefAdapters.size}`;
-        const adapter = streamTypedRefMaterializeAdapter(this.expressionContext(), t, { prefix, adapters: new Map() }, `${prefix}_materialize`);
-        this.liveDynRefAdapters.set(key, adapter);
-        return adapter;
+        return streamTypedRefMaterializeAdapter(this, t);
     }
     liveDynUnionRefAdapter(t) {
-        return liveDynUnionRefAdapter(this.expressionContext(), t);
-    }
-    streamTypedRefBoxValue(B, t, value, ctx) {
-        return streamTypedRefBoxValue(this.expressionContext(), B, t, value, ctx);
+        return liveDynUnionRefAdapter(this, t);
     }
-    streamTypedRefMaterializeAdapter(t, ctx, preferredSnapshot) {
-        return streamTypedRefMaterializeAdapter(this.expressionContext(), t, ctx, preferredSnapshot);
+    streamTypedRefBoxValue(B, t, value) {
+        return streamTypedRefBoxValue(this, B, t, value);
     }
     streamFromArrayAdapter(t) {
-        return streamFromArrayAdapter(this.expressionContext(), t);
+        return streamFromArrayAdapter(this, t);
     }
     emitWebLibCall(e) {
-        return emitWebLibCall(this.expressionContext(), e);
+        return emitWebLibCall(this, e);
     }
     emitDynamicLibCall(e) {
-        return emitDynamicLibCall(this.expressionContext(), e);
+        return emitDynamicLibCall(this, e);
     }
     emitFilesystemLibCall(e) {
-        return emitFilesystemLibCall(this.expressionContext(), e);
+        return emitFilesystemLibCall(this, e);
     }
     emitPathUrlLibCall(e) {
-        return emitPathUrlLibCall(this.expressionContext(), e);
+        return emitPathUrlLibCall(this, e);
     }
     emitPrimitiveLibCall(e) {
-        return emitPrimitiveLibCall(this.expressionContext(), e);
+        return emitPrimitiveLibCall(this, e);
     }
     emitChildProcessLibCall(e) {
-        return emitChildProcessLibCall(this.expressionContext(), e);
+        return emitChildProcessLibCall(this, e);
     }
     emitAsyncContextLibCall(e) {
-        return emitAsyncContextLibCall(this.expressionContext(), e);
+        return emitAsyncContextLibCall(this, e);
     }
     emitProcessLibCall(e) {
-        return emitProcessLibCall(this.expressionContext(), e);
+        return emitProcessLibCall(this, e);
     }
     emitErrorsEventsLibCall(e) {
-        return emitErrorsEventsLibCall(this.expressionContext(), e);
+        return emitErrorsEventsLibCall(this, e);
     }
     emitStreamLibCall(e) {
-        return emitStreamLibCall(this.expressionContext(), e);
+        return emitStreamLibCall(this, e);
     }
     emitNetworkHttpLibCall(e) {
-        return emitNetworkHttpLibCall(this.expressionContext(), e);
+        return emitNetworkHttpLibCall(this, e);
     }
     emitAssertInspectLibCall(e) {
-        return emitAssertInspectLibCall(this.expressionContext(), e);
+        return emitAssertInspectLibCall(this, e);
     }
     emitIoLibCall(e) {
-        return emitIoLibCall(this.expressionContext(), e);
+        return emitIoLibCall(this, e);
     }
     emitGenericLibCall(e) {
-        return emitGenericLibCall(this.expressionContext(), e);
+        return emitGenericLibCall(this, e);
     }
     emitLibCall(e) {
-        return emitLibCall(this.expressionContext(), e);
+        return emitLibCall(this, e);
     }
 }
 //# sourceMappingURL=emitter.js.map