@scriptc/compiler 0.2.5 → 0.2.7

package/dist/backend/llvm/emitter.js

@@ -1,4 +1,5 @@
 import { emitLlvmLayouts } from "./layouts.js";
+import { inlineAllocSupported } from "./alloc.js";
 import { llvmBytes as llBytes } from "../literals.js";
 import { InternalCompilerError } from "../../errors.js";
 /** Lower typed IR to LLVM, using the runtime's C ABI.
@@ -19,15 +20,18 @@ import { InternalCompilerError } from "../../errors.js";
  * compressed source tables that the runtime inflates on demand.
  */
 import { deflateRawSync } from "node:zlib";
-import { endsWithJump, matchStringSelfConcat, streamTypedRefEligible } from "../../ir/analysis.js";
+import { endsWithJump, matchStringSelfConcat, streamTypedRefEligible, undefinedArmTag, } from "../../ir/analysis.js";
 import { emitLibraryIdentityLines } from "../library-identity-markers.js";
-import { CAUGHT, ffiCallbackType, isDynTypedRefType, isFfiContextParam, isRefCounted, isUnitType, POINTER_KINDS, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, typeKey, VOID, } from "../../ir/ir.js";
+import { CAUGHT, ffiCallbackType, isDynTypedRefType, isFfiContextParam, isRefCounted, isUnitType, POINTER_KINDS, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, typeEquals, typeKey, STRING, VOID, } from "../../ir/ir.js";
 import { moduleRuntimeFeatures, moduleEmbedsBuiltin, moduleEmbedsCompressedNpm, NPM_COMPRESS_MIN, } from "../../ir/runtime-features.js";
 import { matchIntegerArrayForLoop, matchIntegerBytesForLoop, matchIntegerCountedForLoop, } from "../../ir/integer-loops.js";
 import { emitCountedLoopLimit } from "./counted-loops.js";
 import { emitLiteralSwitch } from "./switch-dispatch.js";
 import { findBytesBounds } from "./bytes-bounds.js";
+import { emitByteWindowGuard, findInitializedByteLoopBindings, matchByteWindow, } from "./byte-windows.js";
+import { canDeferSplitPiece, emitSplitSpanNext, materializeSplitPiece, emitSplitCursor, emitSplitNext, emitSplitScratch, emitSplitSnapshot, findPrivateSplitLocals, loadSplitSnapshot, storeSplitSnapshot, stringSplit, } from "./split-loops.js";
 import { scalarizeNumericRecords } from "../../ir/scalar-records.js";
+import { specializeNumericCalls } from "../../ir/numeric-call-specialization.js";
 import { everyStmtList } from "../../ir/traverse.js";
 import { analyzeIntegerRanges } from "../../ir/integer-ranges.js";
 import { findIntegerViews } from "./integer-views.js";
@@ -41,13 +45,21 @@ import { analyzeCallLifetimes } from "./call-lifetimes.js";
 import { canStackUnion, emitStackUnion, findLocalStackUnions } from "./stack-unions.js";
 import { allocateLocalUnion, findLocalUnionStorage, storeLocalUnion, } from "./local-union-storage.js";
 import { BlockBuilder } from "./blocks.js";
-import { emitLocalArrayRead, findLocalArrayReads, findCallArrayReads, OptionalArrayReads, } from "./local-array-reads.js";
+import { NullableRefFields } from "./nullable-fields.js";
+import { emitLocalArrayRead, emitProjectedArrayRead, emitBorrowedArrayRead, findLocalArrayReads, findCallArrayReads, OptionalArrayReads, } from "./local-array-reads.js";
+import { emitDenseArrayGet, emitDenseArraySet } from "./dense-array-access.js";
 import { emitStackMapRead, findMapReadLifetimes, matchMapRead, } from "./map-read-lifetimes.js";
 import { emitBorrowedFieldSequence } from "./borrowed-receivers.js";
 import { emitBorrowedInput } from "./borrowed-inputs.js";
 import { ReferenceEffects } from "./reference-effects.js";
 import { LlvmDebugInfo } from "./debug-info.js";
-import { f64Lit, ffiNativeTypeLl, ffiNativeParamLl, ffiNativeReturnLl, llvmCommentText, } from "./common.js";
+import { StackCallbacks } from "./stack-callbacks.js";
+import { findLoopArrayBorrows } from "./loop-array-borrows.js";
+import { AmbientReceiverReaders, findConstantCallbacks } from "./constant-callbacks.js";
+import { findScalarStringSlices, emitStringSliceSnapshot, } from "./string-slices.js";
+import { LazyCaptures } from "./lazy-captures.js";
+import { StackCaptures } from "./stack-captures.js";
+import { ABSENT_FIELD_PAYLOAD, emitFieldAbsentTest, 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";
@@ -67,11 +79,12 @@ 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, classEnvironmentIndex, classFieldIndex, classStructSym, } from "./classes.js";
+import { buildClassGraph, classMembershipIntervals, emitClassMembershipHelper, 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, FN_ATTRS, llFieldType, releaseSym, retainSym, traceArg, typedRefConstructor, vAdapters, } from "./shapes.js";
+import { literalCapWord } from "./string-key-hash.js";
+import { arrNewCall, boxAccess, boxNewCall, boxReleaseSym, computeTraced, elemAccess, emitInlineRcHelpers, FN_ATTRS, inlineRcDecls, llFieldType, releaseSym, retainSym, traceArg, typedRefConstructor, vAdapters, } from "./shapes.js";
 export { LlvmUnsupportedError } from "./unsupported.js";
 function ffiCallbackDummyLl(callback) {
     switch (callback.returns) {
@@ -100,11 +113,15 @@ function ffiCallbackDummyLl(callback) {
 }
 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();
+    return new LlEmitter(options.debugSources === undefined
+        ? scalarizeNumericRecords(specializeNumericCalls(mod, mangleFunction))
+        : mod, options).emit();
 }
 /** Keep large translation units below the host's single-string limit. */
 export function emitLlvmModuleSource(mod, options = {}) {
-    const parts = new LlEmitter(options.debugSources === undefined ? scalarizeNumericRecords(mod) : mod, options).emitParts();
+    const parts = new LlEmitter(options.debugSources === undefined
+        ? scalarizeNumericRecords(specializeNumericCalls(mod, mangleFunction))
+        : mod, options).emitParts();
     const length = parts.reduce((total, part) => total + part.length, Math.max(0, parts.length - 1));
     if (length <= 256 * 1024 * 1024)
         return parts.join("\n");
@@ -116,6 +133,9 @@ function llStrBytes(text) {
 export class LlEmitter {
     mod;
     localArrayReads = new Map();
+    loopArrayBorrows = new Set();
+    scalarStringSlices = new Map();
+    stringSlices = new Map();
     localStackUnions = new Map();
     localUnionStorageProofs = new Map();
     localUnionStorage = new Map();
@@ -167,6 +187,8 @@ export class LlEmitter {
      * immortal (rc == SIZE_MAX) static per (union, unit tag).
      * RC entry points and the collector skip immortals. */
     unitInstances = new Map();
+    /** unionId → symbol of the union's immortal ABSENT field-slot instance. */
+    absentInstances = new Map();
     immortalValues = new Set();
     /** Regex literal templates: "<flags>/<pattern>" → { symbol, interned
      * source/flags literal refs } — one immortal ScrRegex template per distinct
@@ -200,13 +222,31 @@ export class LlEmitter {
     needsBadTag = false;
     needsBadKey = false;
     needsRetainBox = false;
+    /** Inline RC fast-path helpers requested by call sites (shapes.ts); null
+     * when inline RC is off. */
+    rcHelpers;
     fnByName = new Map();
+    /** Emitted LLVM text of every IR function body, by function name: the
+     * fiberless-async analysis scans it for suspension entry points. */
+    fnDefText = new Map();
     referenceEffects;
     optionalArrayReads;
     callArrayReads = new Map();
     mapReadLifetimes = { locals: new Map(), arguments: new Map() };
     callLifetimes;
+    constantCallbacks;
+    currentConstantCallbacks = new Map();
+    stackCallbacks;
+    receiverReaders;
+    stackCaptures;
+    lazyCaptures;
+    /** Unchanged captured parameters of the current function: each maps to
+     * the slot caching its box, NULL until the first closure needs it. */
+    lazyCaptureBoxes = new Map();
+    lazyStackBoxes = new Map();
     borrowedParameters = new Set();
+    /** Parameters proven projection-only: callers may pass stack boxes. */
+    projectedParameters = new Set();
     stableCallBindings = new Set();
     /** Manifest-bound native imports, used by ffiCall emission. */
     ffiByName = new Map();
@@ -246,6 +286,7 @@ export class LlEmitter {
     liveDynUnionRefAdapters = new Map();
     dynPromiseAdapters = new Map();
     unionsById = new Map();
+    nullableFields;
     recordsById = new Map();
     recordCloneShapes = new Set();
     tracedShapes;
@@ -288,6 +329,10 @@ export class LlEmitter {
      * for blocks and switches. */
     jumpTargets = [];
     currentLocals = new Map();
+    privateSplitLocals = new Map();
+    splitSpans = new Map();
+    storedSplits = new Map();
+    streamingSplitsEnabled = false;
     initializerBindings;
     numericLocals = new Map();
     captureIds = new Set();
@@ -295,6 +340,8 @@ export class LlEmitter {
     integerLoopBindings = new Map();
     countedLoopsEnabled = false;
     integerRanges = new Map();
+    byteWindowsEnabled = true;
+    byteWindowEntries = new Map();
     bytesBounds = new Set();
     integerViews = new Map();
     /** Enclosing try-with-FINALLY regions, innermost last: a `return`
@@ -345,6 +392,7 @@ export class LlEmitter {
         this.wasi = options.wasi === true;
         this.emitLibraryIdentity = options.emitLibraryIdentity !== false;
         this.runtimeAbiMarker = options.runtimeAbiMarker === true;
+        this.rcHelpers = options.inlineRc === true ? new Set() : null;
         // 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.
@@ -359,7 +407,10 @@ export class LlEmitter {
         }
         const mt = computeMayThrow(mod);
         this.mayThrow = mt.fns;
-        this.indirectMayThrow = mt.indirect;
+        if (mod.workers)
+            for (const fn of mod.functions)
+                this.mayThrow.add(fn.name);
+        this.indirectMayThrow = mt.indirect || mod.workers === true;
         for (const cls of mod.classes ?? []) {
             for (const m of cls.methods ?? []) {
                 if (this.mayThrow.has(`%${cls.name}.${m}`))
@@ -368,9 +419,15 @@ export class LlEmitter {
         }
         for (const u of mod.unions ?? [])
             this.unionsById.set(u.id, u);
+        this.nullableFields = new NullableRefFields(mod.classes ?? [], this.unionsById);
         this.optionalArrayReads = new OptionalArrayReads(this.fnByName, this.unionsById);
         this.referenceEffects = new ReferenceEffects(this.fnByName, (call) => this.optionalArrayReads.get(call) !== null);
-        this.callLifetimes = analyzeCallLifetimes(this.fnByName);
+        this.callLifetimes = analyzeCallLifetimes(this.fnByName, (className, field) => this.nullableFields.get(className, field) !== null);
+        this.constantCallbacks = findConstantCallbacks(mod, this.callLifetimes);
+        this.stackCallbacks = new StackCallbacks(this.fnByName);
+        this.receiverReaders = new AmbientReceiverReaders(this.fnByName);
+        this.stackCaptures = new StackCaptures(this.fnByName, this.callLifetimes, this.stackCallbacks);
+        this.lazyCaptures = new LazyCaptures(this.fnByName);
         for (const r of mod.records ?? [])
             this.recordsById.set(r.id, r);
         const traced = computeTraced(mod);
@@ -383,6 +440,17 @@ export class LlEmitter {
             tracedUnions: this.tracedUnions,
             recordsById: this.recordsById,
             recordCloneShapes: this.recordCloneShapes,
+            objectAudit: options.objectAudit !== false,
+            inlineAlloc: inlineAllocSupported({
+                pointerBits: options.pointerBits,
+                wasi: options.wasi,
+                targetTriple: options.targetTriple,
+                // Worker programs (SCR_WORKERS) make scr_cyc_live and
+                // scr_weak_dispose_hook thread-local and compile the allocator out,
+                // exactly like thread-instanced libraries.
+                threadInstances: mod.lib?.threadInstances === true || mod.workers === true,
+            }),
+            rcHelpers: this.rcHelpers,
             unionsById: this.unionsById,
             declare: (decl) => this.declare(decl),
             needOom: () => this.needOom(),
@@ -390,14 +458,16 @@ export class LlEmitter {
             internLiteral: (text) => this.internLiteral(text),
             cstr: (text) => this.cstr(text),
             unitInstanceRef: (unionId, tag) => this.unitInstanceRef(unionId, tag),
+            absentInstanceRef: (unionId) => this.absentInstanceRef(unionId),
             liveDynRefAdapter: (type) => this.liveDynRefAdapter(type),
             liveDynUnionRefAdapter: (type) => this.liveDynUnionRefAdapter(type),
             dynPromiseAdapter: (type) => this.dynPromiseAdapter(type),
             isErrorClass: (name) => this.classMeta.get(name)?.root.def.name === "%Error",
             classSubtypes: (name) => {
                 const target = this.classMetaOf(name);
+                const intervals = classMembershipIntervals(this.classMeta, target.def.name);
                 return [...this.classMeta.values()]
-                    .filter((meta) => target.pre <= meta.pre && meta.pre <= target.post)
+                    .filter((meta) => intervals.some((range) => range.pre <= meta.pre && meta.pre <= range.post))
                     .map((meta) => meta.def.name);
             },
         };
@@ -507,7 +577,7 @@ export class LlEmitter {
             if (adapter.global !== null)
                 globals.push(`@${adapter.global} = internal thread_local global ptr null`);
             if (adapter.table !== null) {
-                globals.push(`@${adapter.table} = internal global %ScrFfiTable zeroinitializer`);
+                globals.push(`@${adapter.table} = internal ${this.mod.workers ? "thread_local " : ""}global %ScrFfiTable zeroinitializer`);
             }
             const params = cb.params.flatMap((param, i) => {
                 if (isFfiContextParam(param))
@@ -765,8 +835,11 @@ export class LlEmitter {
         // Function bodies first (the literal/unit/fn-value tables fill as they
         // 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));
+        for (const fn of this.mod.functions) {
+            const def = this.emitFunction(fn);
+            fnDefs.push(def);
+            this.fnDefText.set(fn.name, def);
+        }
         const errorViews = [];
         for (const property of ["name", "message"])
             if (this.mod.functions.some((fn) => fn.name === `%error.${property}.read`)) {
@@ -785,7 +858,7 @@ export class LlEmitter {
             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 layouts = emitLlvmLayouts(this.shapeHost, this.mod, this.classMeta, this.classObjs, this.fnByName, (t) => this.llType(t), this.nullableFields);
         const shapes = layouts.records;
         const classShapes = layouts.classes;
         const classObjDefs = layouts.classObjects;
@@ -953,7 +1026,7 @@ export class LlEmitter {
         // 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);
+        const inlineExitListeners = usesEvents && (this.mod.workers || hasRefGlobals || this.ffiHasRetainedCallback);
         this.declare(`declare i32 @scr_exit_code_hint_get()`);
         if (inlineExitListeners) {
             this.declare(`declare void @scr_run_exit_listeners(double)`);
@@ -1081,7 +1154,10 @@ export class LlEmitter {
         }
         // Helpers assemble BEFORE the declaration table flushes (they add
         // write/abort declarations).
-        const helpers = this.helperDefs();
+        const helpers = [
+            ...this.helperDefs(),
+            ...emitClassMembershipHelper(this.classMeta, this.sizeType),
+        ];
         if (this.constantNumericTables.size > 0)
             this.declare(`declare double @scr_arr_get_number(ptr, double)`);
         const out = [
@@ -1097,13 +1173,19 @@ export 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, i32 }`,
+            `%ScrClosure = type { ${this.sizeType}, ptr, ${this.sizeType}, ptr, i32, i32, ptr }`,
             `%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, double, ptr }`,
+            `%ScrRegex = type { ${this.sizeType}, ptr, ptr, ptr, double, ptr, 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}, ptr }`,
+            // The ScrMap prefix { rc, key_kind, val_kind, val_retain, val_release,
+            // val_trace, key_retain, key_release, key_trace } — the inline RC
+            // fast paths test the two trace slots (shapes.ts).
+            ...(this.rcHelpers === null
+                ? []
+                : [`%ScrMapRc = type { ${this.sizeType}, i32, i32, ptr, ptr, ptr, ptr, ptr, 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.
@@ -1121,11 +1203,11 @@ export class LlEmitter {
             // scr_runtime.h's natural alignment: kind at 8, f64 at 16, b at 24,
             // payload at 32).
             `%ScrCaught = type { ${this.sizeType}, i32, double, i8, ptr, ptr, ptr, ptr }`,
-            // ScrBytes { rc, len, elem(i32+pad), data, backing }. Indexed
+            // ScrBytes { rc, len, elem(i32+pad), data, backing, brands, shared }. Indexed
             // typed-array access GEPs through this directly: the IR type already
             // fixes elem, so the hot path needs neither a runtime kind load nor
             // the generic scr_bytes_get/set call.
-            `%ScrBytes = type { ${this.sizeType}, ${this.sizeType}, i32, ptr, ptr, i8 }`,
+            `%ScrBytes = type { ${this.sizeType}, ${this.sizeType}, i32, ptr, ptr, i8, i8, i8, ptr }`,
             // 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 }`,
@@ -1148,13 +1230,14 @@ export class LlEmitter {
         // objects compiled with -DSCR_THREAD_INSTANCES. Immutable interned
         // data (string literals, unit arms, template arrays, vtables) stays
         // shared.
-        const tl = this.mod.lib?.threadInstances === true ? "thread_local " : "";
-        out.push(``, `@scr_error_vts = external ${tl}global [${RUNTIME_ERROR_CLASSES.size} x %ScrVt]`, `declare void @scr_init()`, `declare void @scr_lib_init(i32, ptr)`, ...(this.runtimeAbiMarker && this.mod.lib === undefined
+        const tl = this.mod.workers === true || this.mod.lib?.threadInstances === true ? "thread_local " : "";
+        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.mod.workers ? [`declare void @scr_runtime_workers_v8()`] : []), ...(this.runtimeAbiMarker && this.mod.lib === undefined
             ? [`declare void @${RUNTIME_ABI_MARKER}()`]
             : []));
         for (const d of this.decls)
             out.push(d);
         out.push(``);
+        const flushedDecls = new Set(this.decls);
         for (const table of this.constantNumericTables.values()) {
             const n = table.values.length;
             out.push(`@${table.symbol} = private constant [${n} x double] [${table.values.map((v) => `double ${f64Lit(v)}`).join(", ")}]`, `define internal double @${table.symbol}_get(ptr %a, double %i) alwaysinline #0 {`, `entry:`, `  %initialized = icmp ne ptr %a, null`, `  %nonnegative = fcmp oge double %i, ${f64Lit(0)}`, `  %below = fcmp olt double %i, ${f64Lit(n)}`, `  %range = and i1 %nonnegative, %below`, `  %safe = and i1 %initialized, %range`, `  br i1 %safe, label %convert, label %fallback`, `convert:`, 
@@ -1165,8 +1248,11 @@ export class LlEmitter {
         for (const [text, lit] of this.literals) {
             // Immortal interned ScrStr: { rc = SIZE_MAX, len, cap = len, bytes\0 } —
             // the runtime ABI’s static table, retain/release skip rc == SIZE_MAX.
+            // 64-bit (little-endian) targets split the capacity word: the high
+            // half carries the precomputed Map key hash (SCR_STR_HASH_CACHE).
+            const capWord = this.sizeType === "i64" ? literalCapWord(Buffer.from(text, "utf8")) : String(lit.len);
             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)}" }`);
+                `{ ${this.sizeType} -1, ${this.sizeType} ${lit.len}, ${this.sizeType} ${capWord}, [${lit.len + 1} x i8] c"${llStrBytes(text)}" }`);
         }
         if (this.literals.size > 0)
             out.push(``);
@@ -1179,11 +1265,23 @@ export class LlEmitter {
         }
         if (this.unitInstances.size > 0)
             out.push(``);
+        for (const [unionId, sym] of this.absentInstances) {
+            // One immortal ABSENT field-slot instance per undefined-armed union:
+            // the undefined arm's tag with payload 1 (ordinary unit instances
+            // carry 0). Every tag reader sees undefined; recordHas and the
+            // field reads compare tag and payload, never the address, so the
+            // per-object copies of separately compiled units agree.
+            const tag = undefinedArmTag({ kind: "union", unionId }, this.unionsById);
+            out.push(`@${sym} = internal global %ScrUnion { ${this.sizeType} -1, i32 ${tag}, ptr null, ptr null, ptr null, i64 ${ABSENT_FIELD_PAYLOAD} } ; ${unionId} absent field`);
+        }
+        if (this.absentInstances.size > 0)
+            out.push(``);
         for (const [key, re] of this.regexInstances) {
             // 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, double 0.0, ptr null } ; ${key.replace(/\n/g, "\\n")}`);
+            // the interned source/flags strings. The bc and native-matcher slots
+            // start 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, double 0.0, ptr null, ptr null } ; ${key.replace(/\n/g, "\\n")}`);
         }
         if (this.regexInstances.size > 0)
             out.push(``);
@@ -1306,7 +1404,7 @@ export class LlEmitter {
             // The runtime stream vtables' intervals (streamVtStampLines) — the
             // emitter story: instanceof and dynamic teardown dispatch through
             // them.
-            out.push(`@${iv.vt} = external global %ScrVt`);
+            out.push(`@${iv.vt} = external ${tl}global %ScrVt`);
             stamps.push(`  store ${this.sizeType} ${iv.pre}, ptr getelementptr inbounds (%ScrVt, ptr @${iv.vt}, i64 0, i32 0)`, `  store ${this.sizeType} ${iv.post}, ptr getelementptr inbounds (%ScrVt, ptr @${iv.vt}, i64 0, i32 1) ; ${iv.lib}`);
         }
         if (this.streamIntervals.length > 0)
@@ -1332,6 +1430,7 @@ export class LlEmitter {
             // symbols specified by the library IR instead.
             for (const line of this.emitLibDefs(globals, globalReleaseLines, stamps))
                 out.push(line);
+            out.push(...this.inlineRcTail(flushedDecls));
             out.push(`attributes #0 = { sanitize_address }`);
             if (this.wasi)
                 out.push(`attributes #1 = { sanitize_address presplitcoroutine }`);
@@ -1343,7 +1442,7 @@ export class LlEmitter {
                 out.push(this.debug.render());
             return out;
         }
-        out.push(`define i32 @${this.wasi ? "__main_argc_argv" : "main"}(i32 %argc, ptr %argv) ${FN_ATTRS} {`, `entry:`, ...(this.runtimeAbiMarker ? [`  call void @${RUNTIME_ABI_MARKER}()`] : []), `  call void @scr_init()`, ...stamps, 
+        out.push(`define i32 @${this.mod.workers ? "sc_context_entry" : this.wasi ? "__main_argc_argv" : "main"}(i32 %argc, ptr %argv) ${FN_ATTRS} {`, `entry:`, ...(this.runtimeAbiMarker ? [`  call void @${RUNTIME_ABI_MARKER}()`] : []), ...(this.mod.workers ? [`  call void @scr_runtime_workers_v8()`] : []), `  call void @scr_init()`, ...stamps, 
         // Event-surface programs (signal/exit listeners) fill the loop's
         // nullable event hooks before %main — scr_events.c links only when
         // this line is emitted (native/executable.ts gates on the same predicate).
@@ -1451,11 +1550,14 @@ export class LlEmitter {
             ? [`  %test_exit = call i32 @scr_test_exit_code()`, `  ret i32 %test_exit`]
             : usesIsland
                 ? [`  %island_exit = call i32 @scr_island_exit_code()`, `  ret i32 %island_exit`]
-                : [`  %native_exit = call i32 @scr_exit_code_hint_get()`, `  ret i32 %native_exit`]), `}`, ``, 
+                : [`  %native_exit = call i32 @scr_exit_code_hint_get()`, `  ret i32 %native_exit`]), `}`, ``, ...this.inlineRcTail(flushedDecls), 
         // sanitize_address is inert under the plain pipeline; the sanitized
         // lane's -fsanitize=address link activates instrumentation over the
         // emitted functions too (the runtime TUs get theirs from clang).
         `attributes #0 = { sanitize_address }`, ...(this.wasi ? [`attributes #1 = { sanitize_address presplitcoroutine }`] : []), ...(hasNoInlineRecordClone ? [`attributes #2 = { noinline sanitize_address }`] : []), ``);
+        if (this.mod.workers) {
+            out.push(`declare void @scr_context_cleanup()`, `declare i32 @scr_worker_argc()`, `declare ptr @scr_worker_argv()`, `define i32 @sc_worker_entry(i32 %root) ${FN_ATTRS} {`, `entry:`, `  %argc = call i32 @scr_worker_argc()`, `  %argv = call ptr @scr_worker_argv()`, `  %result = call i32 @sc_context_entry(i32 %argc, ptr %argv)`, `  ret i32 %result`, `}`, `define i32 @main(i32 %argc, ptr %argv) ${FN_ATTRS} {`, `entry:`, `  %result = call i32 @sc_context_entry(i32 %argc, ptr %argv)`, `  call void @scr_context_cleanup()`, `  ret i32 %result`, `}`);
+        }
         out.push(...this.fieldAliasMetadata());
         if (this.debug !== null)
             out.push(this.debug.render());
@@ -1705,10 +1807,62 @@ export class LlEmitter {
             // emitted once with internal linkage, like the record retains.
             defs.push(`define internal ptr @sc_retain_box(ptr %b) ${FN_ATTRS} {`, `entry:`, `  %rc = load ${this.sizeType}, ptr %b`, `  %imm = icmp eq ${this.sizeType} %rc, -1`, `  br i1 %imm, label %done, label %inc`, `inc:`, `  %n = add ${this.sizeType} %rc, 1`, `  store ${this.sizeType} %n, ptr %b`, `  %colorp = getelementptr i8, ptr %b, ${this.sizeType} -${this.cycleColorOffset}`, `  store i32 0, ptr %colorp ; mark live`, `  br label %done`, `done:`, `  ret ptr %b`, `}`, ``);
         }
+        // String comparisons enter through small internal wrappers that LLVM
+        // inlines at each site: interned literals and shared values compare by
+        // identity, and equality rejects different byte lengths, before any
+        // runtime call (scr_str_eq/scr_str_cmp keep the complete semantics).
+        if (this.decls.has(`declare zeroext i1 @scr_str_eq(ptr, ptr)`)) {
+            defs.push(`define internal zeroext i1 @sc_str_eq(ptr %a, ptr %b) ${FN_ATTRS} {`, `entry:`, `  %same = icmp eq ptr %a, %b`, `  br i1 %same, label %yes, label %lengths`, `lengths:`, `  %alen.p = getelementptr inbounds %ScrStr, ptr %a, i32 0, i32 1`, `  %blen.p = getelementptr inbounds %ScrStr, ptr %b, i32 0, i32 1`, `  %alen = load ${this.sizeType}, ptr %alen.p`, `  %blen = load ${this.sizeType}, ptr %blen.p`, `  %samelen = icmp eq ${this.sizeType} %alen, %blen`, `  br i1 %samelen, label %bytes, label %no`, `bytes:`, `  %eq = call zeroext i1 @scr_str_eq(ptr %a, ptr %b)`, `  ret i1 %eq`, `yes:`, `  ret i1 true`, `no:`, `  ret i1 false`, `}`, ``);
+        }
+        // Ordering also decides inline when the first bytes differ: byte order
+        // is the plain comparison's order, and the UTF-16 order whenever both
+        // bytes are ASCII. Callers only test the sign of the result.
+        for (const fn of ["scr_str_cmp", "scr_str_cmp_u16"]) {
+            if (!this.decls.has(`declare i32 @${fn}(ptr, ptr)`))
+                continue;
+            this.declare("declare i64 @llvm.bswap.i64(i64)");
+            const utf16 = fn === "scr_str_cmp_u16";
+            defs.push(`define internal i32 @${fn.replace(/^scr_/, "sc_")}(ptr %a, ptr %b) ${FN_ATTRS} {`, `entry:`, `  %same = icmp eq ptr %a, %b`, `  br i1 %same, label %equal, label %lengths`, `lengths:`, `  %alen.p = getelementptr inbounds %ScrStr, ptr %a, i32 0, i32 1`, `  %blen.p = getelementptr inbounds %ScrStr, ptr %b, i32 0, i32 1`, `  %alen = load ${this.sizeType}, ptr %alen.p`, `  %blen = load ${this.sizeType}, ptr %blen.p`, `  %aempty = icmp eq ${this.sizeType} %alen, 0`, `  %bempty = icmp eq ${this.sizeType} %blen, 0`, `  %empty = or i1 %aempty, %bempty`, `  br i1 %empty, label %order, label %words`, 
+            // Both at least 8 bytes: the first differing byte of one word pair.
+            // Byte-swapped little-endian words compare in byte order.
+            `words:`, `  %along = icmp uge ${this.sizeType} %alen, 8`, `  %blong = icmp uge ${this.sizeType} %blen, 8`, `  %long = and i1 %along, %blong`, `  br i1 %long, label %word, label %first`, `word:`, `  %awp = getelementptr inbounds %ScrStr, ptr %a, i32 1`, `  %bwp = getelementptr inbounds %ScrStr, ptr %b, i32 1`, `  %aw = load i64, ptr %awp, align 1`, `  %bw = load i64, ptr %bwp, align 1`, `  %wdiffer = icmp ne i64 %aw, %bw`, `  br i1 %wdiffer, label %wdiff, label %wsame`, `wdiff:`, ...(utf16
+                ? [
+                    `  %wbits = or i64 %aw, %bw`,
+                    `  %whigh = and i64 %wbits, -9187201950435737472`,
+                    `  %wascii = icmp eq i64 %whigh, 0`,
+                    `  br i1 %wascii, label %wordorder, label %order`,
+                ]
+                : [`  br label %wordorder`]), `wordorder:`, `  %asw = call i64 @llvm.bswap.i64(i64 %aw)`, `  %bsw = call i64 @llvm.bswap.i64(i64 %bw)`, `  %wbelow = icmp ult i64 %asw, %bsw`, `  %wsign = select i1 %wbelow, i32 -1, i32 1`, `  ret i32 %wsign`, 
+            // Equal first words and one length of at most 16 bytes: the word
+            // ending at that length covers the rest, and any difference lies
+            // past the equal first word.
+            `wsame:`, `  %samelen = icmp eq ${this.sizeType} %alen, %blen`, `  %short = icmp ule ${this.sizeType} %alen, 16`, `  %tailable = and i1 %samelen, %short`, `  br i1 %tailable, label %tail, label %order`, `tail:`, `  %toff = sub ${this.sizeType} %alen, 8`, `  %atp = getelementptr inbounds i8, ptr %awp, ${this.sizeType} %toff`, `  %btp = getelementptr inbounds i8, ptr %bwp, ${this.sizeType} %toff`, `  %at = load i64, ptr %atp, align 1`, `  %bt = load i64, ptr %btp, align 1`, `  %tdiffer = icmp ne i64 %at, %bt`, `  br i1 %tdiffer, label %tdiff, label %equal`, `tdiff:`, ...(utf16
+                ? [
+                    `  %tbits = or i64 %at, %bt`,
+                    `  %thigh = and i64 %tbits, -9187201950435737472`,
+                    `  %tascii = icmp eq i64 %thigh, 0`,
+                    `  br i1 %tascii, label %tailorder, label %order`,
+                ]
+                : [`  br label %tailorder`]), `tailorder:`, `  %ats = call i64 @llvm.bswap.i64(i64 %at)`, `  %bts = call i64 @llvm.bswap.i64(i64 %bt)`, `  %tbelow = icmp ult i64 %ats, %bts`, `  %tsign = select i1 %tbelow, i32 -1, i32 1`, `  ret i32 %tsign`, `first:`, `  %adata = getelementptr inbounds %ScrStr, ptr %a, i32 1`, `  %bdata = getelementptr inbounds %ScrStr, ptr %b, i32 1`, `  %x = load i8, ptr %adata`, `  %y = load i8, ptr %bdata`, `  %differ = icmp ne i8 %x, %y`, ...(utf16
+                ? [
+                    `  %bits = or i8 %x, %y`,
+                    `  %ascii = icmp sge i8 %bits, 0`,
+                    `  %decide = and i1 %differ, %ascii`,
+                ]
+                : [`  %decide = and i1 %differ, true`]), `  br i1 %decide, label %byte, label %order`, `byte:`, `  %below = icmp ult i8 %x, %y`, `  %sign = select i1 %below, i32 -1, i32 1`, `  ret i32 %sign`, `order:`, `  %c = call i32 @${fn}(ptr %a, ptr %b)`, `  ret i32 %c`, `equal:`, `  ret i32 0`, `}`, ``);
+        }
         // The declarations these helpers added must land in the extern block,
         // which already flushed — append here instead (LLVM is order-free).
         return defs.length > 0 ? [...defs] : defs;
     }
+    /** The inline RC helpers every call site requested, emitted last so
+     * requests from main/library epilogues are included. Slow-path
+     * declarations a late request added after the extern block flushed land
+     * here too. */
+    inlineRcTail(flushedDecls) {
+        const late = inlineRcDecls(this.shapeHost).filter((d) => !flushedDecls.has(d));
+        return [...late, ...emitInlineRcHelpers(this.shapeHost)];
+    }
     /** Env-signature wrappers + interned immortal closures for declared
      * 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. */
@@ -1723,7 +1877,7 @@ export 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, i32 ${(fn.generator ? 1 : 0) + (fn.async ? 2 : 0) + (fn.ownsPrototype ? 4 : 0)} }`, ``);
+            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 ${this.mod.workers === true || this.mod.lib?.threadInstances === true ? "thread_local " : ""}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)}, i32 0, ptr null }`, ``);
         }
         return out;
     }
@@ -1777,6 +1931,154 @@ export class LlEmitter {
         });
         return { definitions, pack, lifted, fieldTys, ret, tr, spawnParams, argPackLines };
     }
+    /** Settles `promise` from a clean async body result `%r` (moved in). */
+    asyncFulfillLines(ret, promise) {
+        switch (ret.kind) {
+            case "void":
+                this.declare(`declare void @scr_promise_fulfill_void(ptr)`);
+                return [`  call void @scr_promise_fulfill_void(ptr ${promise})`];
+            case "f64":
+            case "date":
+                this.declare(`declare void @scr_promise_fulfill_f64(ptr, double)`);
+                return [`  call void @scr_promise_fulfill_f64(ptr ${promise}, double %r)`];
+            case "bool":
+                this.declare(`declare void @scr_promise_fulfill_bool(ptr, i1 zeroext)`);
+                return [`  call void @scr_promise_fulfill_bool(ptr ${promise}, i1 %r)`];
+            case "string":
+                this.declare(`declare void @scr_promise_fulfill_str(ptr, ptr)`);
+                return [`  call void @scr_promise_fulfill_str(ptr ${promise}, ptr %r) ; moves in`];
+            case "dyn":
+                this.declare(`declare void @scr_promise_resolve_dyn(ptr, ptr)`);
+                return [`  call void @scr_promise_resolve_dyn(ptr ${promise}, ptr %r) ; moves in`];
+            default: {
+                const v = vAdapters(this.shapeHost, ret);
+                this.declare(`declare void @scr_promise_fulfill_ref(ptr, ptr, ptr, ptr, ptr)`);
+                return [
+                    `  call void @scr_promise_fulfill_ref(ptr ${promise}, ptr %r, ptr ${v.retain}, ptr ${v.release}, ptr ${traceArg(this.shapeHost, ret)})`,
+                ];
+            }
+        }
+    }
+    /** Async functions whose calls can skip the fiber (scr_async_inline_*).
+     * A body qualifies only when nothing it runs can park its execution
+     * context: its emitted text, and the text of every module function it
+     * mentions (transitively), contains no suspension entry point. Such a
+     * body always completes before the call returns, which is exactly the
+     * behavior of a fiber that never suspends. Excluded conservatively:
+     * wasm32 (its coroutine lowering owns async bodies), programs embedding
+     * the dynamic engine, module-evaluation bodies (their promise caches),
+     * `dyn` results (resolution may adopt a thenable), and every program
+     * that uses node:test subtests — `t.test()` runs a subtest inline and
+     * awaits it on the CURRENT fiber even from synchronous code. Worker
+     * programs keep fibers too: their fiber epilogue owns context
+     * termination (a stopping worker rejects and observes the promise), which
+     * the fiberless wrapper does not reproduce. A missed suspension still
+     * cannot reorder silently: the runtime traps when a context parks while a
+     * fiberless body is on its stack. */
+    fiberlessAsyncFunctions() {
+        const eligible = new Set();
+        if (this.wasi || this.mod.workers === true)
+            return eligible;
+        const embedded = this.mod.embedded;
+        if (embedded !== undefined && embedded.modules.length > 0)
+            return eligible;
+        const suspends = /@scr_(?:await_|module_await\b|promise_await_settled\b|test_sub\b|gen_yield_|async_gen_|fiber_)/;
+        for (const decl of this.decls)
+            if (/@scr_test_sub\b/.test(decl))
+                return eligible;
+        for (const text of this.fnDefText.values())
+            if (/@scr_test_sub\b/.test(text))
+                return eligible;
+        const byMangled = new Map();
+        for (const fn of this.mod.functions) {
+            byMangled.set(mangleFunction(fn.name), fn.name);
+            byMangled.set(mangleBorrowedFunction(fn.name), fn.name);
+        }
+        // Reverse mention edges, then propagate "may park" to every mentioner.
+        const mentionedBy = new Map();
+        const parks = new Set();
+        const work = [];
+        for (const [name, text] of this.fnDefText) {
+            if (suspends.test(text)) {
+                parks.add(name);
+                work.push(name);
+            }
+            for (const match of text.matchAll(/@(sc_b?f_[A-Za-z0-9_]+)/g)) {
+                const callee = byMangled.get(match[1]);
+                if (callee === undefined || callee === name)
+                    continue;
+                let callers = mentionedBy.get(callee);
+                if (callers === undefined)
+                    mentionedBy.set(callee, (callers = new Set()));
+                callers.add(name);
+            }
+        }
+        while (work.length > 0) {
+            const callers = mentionedBy.get(work.pop());
+            if (callers === undefined)
+                continue;
+            for (const caller of callers) {
+                if (parks.has(caller))
+                    continue;
+                parks.add(caller);
+                work.push(caller);
+            }
+        }
+        for (const fn of this.mod.functions) {
+            if (fn.async !== true || fn.generator !== undefined)
+                continue;
+            if (fn.asyncCacheGlobal !== undefined || fn.asyncCycleCacheGlobal !== undefined)
+                continue;
+            if (fn.returnType.kind === "dyn" || parks.has(fn.name))
+                continue;
+            if (!this.fnDefText.has(fn.name))
+                continue;
+            eligible.add(fn.name);
+        }
+        return eligible;
+    }
+    /** The spawn wrapper of a fiberless async function: runs the body on the
+     * caller's stack between scr_async_inline_enter/leave and settles the
+     * fresh promise from its outcome — the fiber trampoline's epilogue,
+     * without the fiber. */
+    emitFiberlessAsyncSpawn(fn, spawnParams) {
+        const ret = fn.returnType;
+        const retTy = this.llType(ret);
+        const lifted = fn.captures !== undefined;
+        this.declare(`declare void @scr_async_inline_enter(ptr)`);
+        this.declare(`declare ptr @scr_async_inline_leave(ptr)`);
+        this.declare(`declare void @scr_promise_reject_pending(ptr)`);
+        this.declare(`declare zeroext i1 @scr_exc_pending()`);
+        if (lifted) {
+            this.declare(`declare ptr @scr_closure_retain_v(ptr)`);
+            this.declare(`declare void @scr_closure_release(ptr)`);
+        }
+        const bodyCall = `call ${retTy} @${mangleFunction(fn.name)}(${spawnParams.join(", ")})`;
+        const out = [
+            `define internal ptr @${mangleAsyncSpawn(fn.name)}(${spawnParams.join(", ")}) ${FN_ATTRS} { ; fiberless ${fn.name}`,
+            `entry:`,
+            `  %frame = alloca { ptr, ptr }`,
+            // The fiber path holds +1 on a lifted environment for the body's
+            // duration (packed, released by the trampoline); keep that lifetime.
+            ...(lifted ? [`  %env = call ptr @scr_closure_retain_v(ptr %a0)`] : []),
+            `  call void @scr_async_inline_enter(ptr %frame)`,
+            retTy === "void" ? `  ${bodyCall}` : `  %r = ${bodyCall}`,
+            ...(lifted ? [`  call void @scr_closure_release(ptr %a0)`] : []),
+            `  %pend = call zeroext i1 @scr_exc_pending()`,
+            `  %p = call ptr @scr_async_inline_leave(ptr %frame)`,
+            `  br i1 %pend, label %thrown, label %clean`,
+            `clean:`,
+            ...this.asyncFulfillLines(ret, "%p"),
+            `  ret ptr %p`,
+            `thrown:`,
+        ];
+        if (ret.kind !== "void" && isRefCounted(ret)) {
+            // An escaping throw means %r is the never-read dummy (NULL).
+            out.push(`  call void ${releaseSym(this.shapeHost, ret)}(ptr %r)`);
+        }
+        out.push(`  call void @scr_promise_reject_pending(ptr %p)`, `  ret ptr %p`, `}`, ``);
+        return out;
+    }
     /** Per-async-function machinery — async.ts's scaffolding, .ll
      * flavored: an argument-pack struct type, a fiber trampoline (unpacks,
      * frees the pack, runs the ordinary compiled body, settles the
@@ -1791,9 +2093,20 @@ export class LlEmitter {
             this.declare(`declare void @llvm.coro.destroy(ptr)`);
             out.push(`define void @scr_wasi_coro_resume(ptr %handle) ${FN_ATTRS} {`, `entry:`, `  call void @llvm.coro.resume(ptr %handle)`, `  ret void`, `}`, `define void @scr_wasi_coro_destroy(ptr %handle) ${FN_ATTRS} {`, `entry:`, `  call void @llvm.coro.destroy(ptr %handle)`, `  ret void`, `}`, ``);
         }
+        const fiberless = this.fiberlessAsyncFunctions();
         for (const fn of this.mod.functions) {
             if (fn.async !== true || fn.generator !== undefined)
                 continue;
+            if (fiberless.has(fn.name)) {
+                const fieldTys = [
+                    ...(fn.captures !== undefined ? ["ptr"] : []),
+                    ...fn.params.map((p) => this.llType(p.type)),
+                ];
+                const params = fieldTys.map((ty, i) => `${ty} %a${i}`);
+                for (const line of this.emitFiberlessAsyncSpawn(fn, params))
+                    out.push(line);
+                continue;
+            }
             const { definitions, ret, tr, spawnParams, argPackLines } = this.emitArgPackAndTrampolinePrologue(fn);
             for (const line of definitions)
                 out.push(line);
@@ -1811,34 +2124,8 @@ export class LlEmitter {
                     this.declare(`declare void @scr_closure_release(ptr)`);
                 }
                 tr.push(`  %pend = call zeroext i1 @scr_exc_pending()`, `  br i1 %pend, label %thrown, label %clean`, `clean:`, `  %pr = call ptr @scr_fiber_promise(ptr %self)`);
-                switch (ret.kind) {
-                    case "void":
-                        this.declare(`declare void @scr_promise_fulfill_void(ptr)`);
-                        tr.push(`  call void @scr_promise_fulfill_void(ptr %pr)`);
-                        break;
-                    case "f64":
-                    case "date":
-                        this.declare(`declare void @scr_promise_fulfill_f64(ptr, double)`);
-                        tr.push(`  call void @scr_promise_fulfill_f64(ptr %pr, double %r)`);
-                        break;
-                    case "bool":
-                        this.declare(`declare void @scr_promise_fulfill_bool(ptr, i1 zeroext)`);
-                        tr.push(`  call void @scr_promise_fulfill_bool(ptr %pr, i1 %r)`);
-                        break;
-                    case "string":
-                        this.declare(`declare void @scr_promise_fulfill_str(ptr, ptr)`);
-                        tr.push(`  call void @scr_promise_fulfill_str(ptr %pr, ptr %r) ; moves in`);
-                        break;
-                    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.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.shapeHost, ret)})`);
-                    }
-                }
+                for (const line of this.asyncFulfillLines(ret, "%pr"))
+                    tr.push(line);
                 tr.push(`  ret void`, `thrown:`);
                 if (ret.kind !== "void" && isRefCounted(ret)) {
                     // An escaping throw means %r is the never-read dummy (NULL).
@@ -2077,6 +2364,40 @@ export class LlEmitter {
         this.immortalValues.add(name);
         return name;
     }
+    /** The immortal ABSENT state of an undefined-armed record field slot
+     * (IR fieldAbsent). */
+    absentInstanceRef(unionId) {
+        if (undefinedArmTag({ kind: "union", unionId }, this.unionsById) < 0) {
+            throw new InternalCompilerError(`llvm emitter bug: absent state of ${unionId} without undefined`);
+        }
+        let sym = this.absentInstances.get(unionId);
+        if (!sym) {
+            sym = `sc_absent_${this.absentInstances.size}`;
+            this.absentInstances.set(unionId, sym);
+        }
+        const name = `@${sym}`;
+        this.immortalValues.add(name);
+        return name;
+    }
+    /** i1: a union value loaded from a field slot is the ABSENT state — the
+     * undefined arm's tag with the absent payload marker. */
+    fieldAbsentTest(value, unionId) {
+        return emitFieldAbsentTest(this.B, value, undefinedArmTag({ kind: "union", unionId }, this.unionsById));
+    }
+    /** Loads a record field slot as a VALUE: an undefined-armed union slot
+     * holding the ABSENT state surfaces as the ordinary undefined arm, so
+     * absence never travels beyond its slot (a later `{ f: r.f }` is an
+     * explicit, present property). */
+    loadRecordField(ptr, t) {
+        const v = this.loadField(ptr, t);
+        if (t.kind !== "union" || undefinedArmTag(t, this.unionsById) < 0)
+            return v;
+        const absent = this.fieldAbsentTest(v, t.unionId);
+        const unit = this.unitInstanceRef(t.unionId, undefinedArmTag(t, this.unionsById));
+        const out = this.B.tmp();
+        this.B.line(`${out} = select i1 ${absent}, ptr ${unit}, ptr ${v}`);
+        return out;
+    }
     declare(decl) {
         this.decls.add(decl);
     }
@@ -2136,8 +2457,7 @@ export class LlEmitter {
                 const t = this.B.tmp();
                 this.B.line(`${t} = load ptr, ptr ${v.name}`);
                 if (v.boxed) {
-                    this.declare(`declare void @scr_box_release(ptr)`);
-                    this.B.line(`call void @scr_box_release(ptr ${t})`);
+                    this.B.line(`call void ${boxReleaseSym(this.shapeHost)}(ptr ${t})`);
                 }
                 else {
                     this.releaseValue(t, v.type);
@@ -2153,8 +2473,7 @@ export class LlEmitter {
             const t = this.B.tmp();
             this.B.line(`${t} = load ptr, ptr ${e.slot}`);
             if (e.boxed) {
-                this.declare(`declare void @scr_box_release(ptr)`);
-                this.B.line(`call void @scr_box_release(ptr ${t})`);
+                this.B.line(`call void ${boxReleaseSym(this.shapeHost)}(ptr ${t})`);
             }
             else {
                 this.releaseValue(t, e.type); // runtime releases are NULL-tolerant
@@ -2206,6 +2525,20 @@ export class LlEmitter {
      * using the result). Callers own the surrounding pending branch; a
      * `throw` unwinds unconditionally. */
     emitUnwind() {
+        if (this.mod.workers && this.tryStack.length > 0) {
+            this.declare(`declare zeroext i1 @scr_context_stopping()`);
+            const stopped = this.B.tmp();
+            this.B.line(`${stopped} = call zeroext i1 @scr_context_stopping()`);
+            const stop = this.B.newLabel("context.stop");
+            const ordinary = this.B.newLabel("context.throw");
+            this.B.condBr(stopped, stop, ordinary);
+            this.B.startBlock(stop);
+            const handlers = this.tryStack;
+            this.tryStack = [];
+            this.emitUnwind();
+            this.tryStack = handlers;
+            this.B.startBlock(ordinary);
+        }
         const target = this.tryStack[this.tryStack.length - 1];
         const frameDepth = target?.frameDepth ?? 0;
         const scopeDepth = target?.scopeDepth ?? 0;
@@ -2220,13 +2553,13 @@ export class LlEmitter {
             terminator = `br label %${this.currentWasiCoro.finalLabel}`;
         }
         else {
-            const t = this.currentReturnType;
+            const t = this.llType(this.currentReturnType);
             terminator =
-                t.kind === "void"
+                t === "void"
                     ? "ret void"
-                    : t.kind === "f64" || t.kind === "date"
+                    : t === "double"
                         ? `ret double ${f64Lit(0)}`
-                        : t.kind === "bool"
+                        : t === "i1"
                             ? "ret i1 false"
                             : "ret ptr null";
         }
@@ -2269,6 +2602,34 @@ export class LlEmitter {
         this.emitUnwind();
         B.startBlock(lk);
     }
+    workerLoopBudget() {
+        if (!this.mod.workers)
+            return null;
+        const slot = this.B.slot();
+        this.B.entryAllocas.push(`${slot} = alloca i32 ; worker cancellation budget`);
+        this.B.line(`store i32 0, ptr ${slot}`);
+        return slot;
+    }
+    emitWorkerLoopCheck(slot) {
+        if (slot === null)
+            return;
+        const B = this.B;
+        const budget = B.tmp(), due = B.tmp(), remaining = B.tmp();
+        const poll = B.newLabel("worker.poll"), next = B.newLabel("worker.next");
+        B.line(`${budget} = load i32, ptr ${slot}`);
+        B.line(`${remaining} = sub i32 ${budget}, 1`);
+        B.line(`store i32 ${remaining}, ptr ${slot}`);
+        B.line(`${due} = icmp eq i32 ${budget}, 0`);
+        B.condBr(due, poll, next);
+        B.startBlock(poll);
+        B.line(`store i32 63, ptr ${slot}`);
+        // Calls and throwing operations retain their own checks. Amortize the
+        // extra cancellation poll across bounded loop batches so scalar work
+        // does not cross the runtime ABI on every iteration.
+        this.emitPendingCheck();
+        B.br(next);
+        B.startBlock(next);
+    }
     /** Moves an already-evaluated value into the runtime's exception cell —
      * the `throw` statement's kind dispatch (stmts.ts's), shared with
      * every synthetic thrower. Ownership of a refcounted payload must have
@@ -2344,14 +2705,10 @@ export class LlEmitter {
             this.unionTagSwitch(v.name, def, (arm) => {
                 let valueName = "false";
                 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})`);
+                    valueName = this.unionGetF64(v.name);
                 }
                 else if (arm.kind === "bool") {
-                    valueName = B.tmp();
-                    this.declare(`declare zeroext i1 @scr_union_get_bool(ptr)`);
-                    B.line(`${valueName} = call zeroext i1 @scr_union_get_bool(ptr ${v.name})`);
+                    valueName = this.unionGetBool(v.name);
                 }
                 else if (arm.kind === "string") {
                     valueName = this.unionPeek(v.name);
@@ -2530,24 +2887,34 @@ export class LlEmitter {
         B.terminate(`unreachable`);
     }
     /** The +1 extraction of a union's single narrowed arm (unionNarrow /
-     * the nullish-family reads): scalars via the runtime getters, ref arms
+     * the nullish-family reads): scalars via inline payload loads, ref arms
      * a retained peek. */
     unionExtract(uName, arm) {
-        const B = this.B;
-        if (arm.kind === "f64" || arm.kind === "procStream") {
-            const t = B.tmp();
-            this.declare(`declare double @scr_union_get_f64(ptr)`);
-            B.line(`${t} = call double @scr_union_get_f64(ptr ${uName})`);
-            return t;
-        }
-        if (arm.kind === "bool") {
-            const t = B.tmp();
-            this.declare(`declare zeroext i1 @scr_union_get_bool(ptr)`);
-            B.line(`${t} = call zeroext i1 @scr_union_get_bool(ptr ${uName})`);
-            return t;
-        }
+        if (arm.kind === "f64" || arm.kind === "procStream")
+            return this.unionGetF64(uName);
+        if (arm.kind === "bool")
+            return this.unionGetBool(uName);
         return this.retainValue(this.unionPeek(uName), arm);
     }
+    /** A scalar f64 arm's payload (scr_union_get_f64 inlined). Inline loads
+     * keep stack boxes free of escaping calls, so LLVM can scalarize them. */
+    unionGetF64(uName) {
+        const p = this.B.tmp();
+        const t = this.B.tmp();
+        this.B.line(`${p} = getelementptr inbounds %ScrUnion, ptr ${uName}, i64 0, i32 5`);
+        this.B.line(`${t} = load double, ptr ${p}`);
+        return t;
+    }
+    /** A bool arm's payload (scr_union_get_bool inlined: nonzero slot). */
+    unionGetBool(uName) {
+        const p = this.B.tmp();
+        const bits = this.B.tmp();
+        const t = this.B.tmp();
+        this.B.line(`${p} = getelementptr inbounds %ScrUnion, ptr ${uName}, i64 0, i32 5`);
+        this.B.line(`${bits} = load i64, ptr ${p}`);
+        this.B.line(`${t} = icmp ne i64 ${bits}, 0`);
+        return t;
+    }
     /** Constructs a union box around an OWNED (+1, already moved) value —
      * the scr_union_new_* dispatch of unionWrap and the wrap-into-join
      * sites (shift). */
@@ -2726,17 +3093,26 @@ export class LlEmitter {
         this.B.line(`${b} = load ptr, ptr ${slot}`);
         return b;
     }
+    /** The payload slot of a capture box (ScrBox.slot, field 5). */
+    boxSlot(box) {
+        const slot = this.B.tmp();
+        this.B.line(`${slot} = getelementptr inbounds %ScrBox, ptr ${box}, i32 0, i32 5`);
+        return slot;
+    }
     boxGet(box, t) {
         const B = this.B;
         const acc = boxAccess(t);
         const r = B.tmp();
+        // Scalar payloads are read in place (scr_box_get_f64/bool are a
+        // memcpy and a nonzero test of the same slot), so LLVM can keep a
+        // captured number in a register across a loop of calls.
         if (acc === "f64") {
-            this.declare(`declare double @scr_box_get_f64(ptr)`);
-            B.line(`${r} = call double @scr_box_get_f64(ptr ${box})`);
+            B.line(`${r} = load double, ptr ${this.boxSlot(box)}`);
         }
         else if (acc === "bool") {
-            this.declare(`declare zeroext i1 @scr_box_get_bool(ptr)`);
-            B.line(`${r} = call zeroext i1 @scr_box_get_bool(ptr ${box})`);
+            const raw = B.tmp();
+            B.line(`${raw} = load i64, ptr ${this.boxSlot(box)}`);
+            B.line(`${r} = icmp ne i64 ${raw}, 0`);
         }
         else {
             this.declare(`declare ptr @scr_box_get_ref(ptr)`);
@@ -2749,18 +3125,45 @@ export class LlEmitter {
         const B = this.B;
         const acc = boxAccess(t);
         if (acc === "f64") {
-            this.declare(`declare void @scr_box_set_f64(ptr, double)`);
-            B.line(`call void @scr_box_set_f64(ptr ${box}, double ${value})`);
+            B.line(`store double ${value}, ptr ${this.boxSlot(box)}`);
         }
         else if (acc === "bool") {
-            this.declare(`declare void @scr_box_set_bool(ptr, i1 zeroext)`);
-            B.line(`call void @scr_box_set_bool(ptr ${box}, i1 ${value})`);
+            const raw = B.tmp();
+            B.line(`${raw} = zext i1 ${value} to i64`);
+            B.line(`store i64 ${raw}, ptr ${this.boxSlot(box)}`);
         }
         else {
             this.declare(`declare void @scr_box_set_ref(ptr, ptr)`);
             B.line(`call void @scr_box_set_ref(ptr ${box}, ptr ${value})`);
         }
     }
+    /** The box a new environment captures for `localId` (borrowed). An
+     * unchanged parameter gets one box on first capture, holding its own
+     * reference to the value; the function scope releases the cached box. */
+    captureBox(localId) {
+        const cache = this.lazyCaptureBoxes.get(localId);
+        if (cache === undefined)
+            return this.loadBox(`%${mangleLocal(localId)}`);
+        const B = this.B;
+        const type = this.currentLocals.get(localId).type;
+        const current = this.loadBox(cache);
+        const missing = B.tmp();
+        B.line(`${missing} = icmp eq ptr ${current}, null`);
+        const create = B.newLabel("lazy.box"), join = B.newLabel("lazy.box.j");
+        B.condBr(missing, create, join);
+        B.startBlock(create);
+        const stack = this.lazyStackBoxes.get(localId);
+        const box = stack ?? B.tmp();
+        if (!stack)
+            B.line(`${box} = ${boxNewCall(this.shapeHost, type)}`);
+        const value = B.tmp();
+        B.line(`${value} = load ${this.llType(type)}, ptr %${mangleLocal(localId)}`);
+        this.boxSet(box, type, isRefCounted(type) ? this.retainValue(value, type) : value);
+        B.line(`store ptr ${box}, ptr ${cache}`);
+        B.br(join);
+        B.startBlock(join);
+        return this.loadBox(cache);
+    }
     retainBox(box) {
         this.needsRetainBox = true;
         const t = this.B.tmp();
@@ -2805,6 +3208,12 @@ export class LlEmitter {
         B.line(`${empty} = icmp eq ptr ${value}, null`);
         this.throwIfUninitialized(empty, name);
     }
+    /** Throws the TDZ ReferenceError for `name` unless the i1 `flag` is set. */
+    checkInitializedFlag(flag, name) {
+        const empty = this.B.tmp();
+        this.B.line(`${empty} = xor i1 ${flag}, true`);
+        this.throwIfUninitialized(empty, name);
+    }
     throwIfUninitialized(empty, name) {
         const B = this.B;
         const lt = B.newLabel("tdz.t");
@@ -2973,10 +3382,36 @@ export class LlEmitter {
         this.unwindCleanups.clear();
         this.jumpTargets = [];
         this.currentLocals = new Map(fn.locals.map((l) => [l.id, l]));
+        this.lazyCaptureBoxes.clear();
+        this.lazyStackBoxes.clear();
+        // An unchanged captured parameter keeps its value in a plain slot; the
+        // binding is boxed only for closures (captureBox).
+        const lazyParameters = this.lazyCaptures.parameters(fn);
+        for (const id of lazyParameters) {
+            const { boxed: _boxed, ...plain } = this.currentLocals.get(id);
+            this.currentLocals.set(id, plain);
+            this.lazyCaptureBoxes.set(id, "");
+        }
+        this.currentConstantCallbacks =
+            this.debug === null ? (this.constantCallbacks.get(fn.name) ?? new Map()) : new Map();
+        // Preserve concrete source bindings for debugger inspection. Suspended
+        // functions keep the established array lifetime across continuations.
+        this.streamingSplitsEnabled = this.debug === null && !fn.async && !fn.generator;
+        this.stackCallbacks.reset(this.streamingSplitsEnabled);
+        this.stackCaptures.reset(fn, this.streamingSplitsEnabled, lazyParameters);
+        this.privateSplitLocals = this.streamingSplitsEnabled ? findPrivateSplitLocals(fn) : new Map();
+        this.storedSplits.clear();
+        this.splitSpans.clear();
+        this.stringSlices.clear();
         const initializerBindings = this.initializerBindings.get(fn.name) ?? [];
         const numericFn = withInitializerBindings(fn, initializerBindings);
         this.numericLocals = new Map(numericFn.locals.map((l) => [l.id, l]));
         this.borrowedParameters.clear();
+        this.projectedParameters.clear();
+        const projectedParameterIndexes = this.callLifetimes.parameters.get(fn.name);
+        if (projectedParameterIndexes)
+            for (const index of projectedParameterIndexes)
+                this.projectedParameters.add(fn.params[index].localId);
         this.stableCallBindings = this.callLifetimes.bindings.get(fn.name) ?? new Set();
         const borrowedParameterIndexes = this.callLifetimes.borrowed.get(fn.name);
         if (borrowedParameterIndexes) {
@@ -2986,14 +3421,25 @@ export class LlEmitter {
         this.captureIds = new Set([...(fn.captures ?? []), ...(fn.classCaptures ?? [])].map((c) => c.localId));
         this.integerLoopBindings.clear();
         this.countedLoopsEnabled = this.debug === null && !fn.async && !fn.generator;
+        this.byteWindowsEnabled = this.countedLoopsEnabled;
+        this.byteWindowEntries =
+            this.byteWindowsEnabled && numericFn.locals.some((l) => l.type.kind === "bytes")
+                ? findInitializedByteLoopBindings(fn)
+                : new Map();
         this.integerViews.clear();
         this.fieldPointerTags.clear();
         this.integerArrayBindings.clear();
-        this.localArrayReads = findLocalArrayReads(fn, this.fnByName, this.unionsById, this.referenceEffects.functions, this.callLifetimes, this.optionalArrayReads);
+        this.loopArrayBorrows =
+            this.debug === null
+                ? findLoopArrayBorrows(fn, this.callLifetimes, this.referenceEffects, this.optionalArrayReads)
+                : new Set();
+        this.localArrayReads = findLocalArrayReads(fn, this.fnByName, this.unionsById, this.referenceEffects.functions, this.callLifetimes, this.optionalArrayReads, this.loopArrayBorrows);
         this.callArrayReads = findCallArrayReads(fn, this.optionalArrayReads, this.referenceEffects.functions, this.callLifetimes);
+        this.scalarStringSlices =
+            this.debug === null ? findScalarStringSlices(fn, this.callLifetimes) : new Map();
         this.mapReadLifetimes = findMapReadLifetimes(fn, this.unionsById, this.callLifetimes);
         this.localStackUnions = findLocalStackUnions(fn, this.callLifetimes, this.unionsById);
-        this.localUnionStorageProofs = findLocalUnionStorage(fn, this.callLifetimes, this.unionsById);
+        this.localUnionStorageProofs = findLocalUnionStorage(fn, this.callLifetimes, this.unionsById, (e) => this.nullableFieldGet(e) !== null);
         this.localUnionStorage = new Map();
         this.integerRanges = analyzeIntegerRanges(numericFn);
         this.bytesBounds = findBytesBounds(numericFn, this.integerRanges);
@@ -3052,7 +3498,7 @@ export class LlEmitter {
             B.line(`${value} = load double, ptr @${mangleGlobal(global.id)}`);
             this.storeIntegerView(global.id, { name: value, type: global.type });
         }
-        for (const local of fn.locals) {
+        for (const local of this.currentLocals.values()) {
             // Boxed locals' slots hold their capture BOX (a ptr); captured
             // (env-borrowed) locals bind the incoming box below. A caught-typed
             // local is a catch binding: its slot holds the ScrCaught snapshot
@@ -3101,6 +3547,21 @@ export class LlEmitter {
         // params (callees own their params — callers passed +1). Boxed params
         // allocate the shared binding and move the raw value in.
         const fnScope = [];
+        for (const id of this.lazyCaptureBoxes.keys()) {
+            const cache = B.slot();
+            B.entryAllocas.push(`${cache} = alloca ptr ; lazy box ${this.currentLocals.get(id).name}`);
+            B.line(`store ptr null, ptr ${cache}`);
+            fnScope.push({ slot: cache, type: this.currentLocals.get(id).type, boxed: true });
+            this.lazyCaptureBoxes.set(id, cache);
+            // Environments that finish during the call can share an immortal
+            // frame box. Its payload owner is released with the function scope.
+            const stack = this.stackCaptures.emit(this, id, this.currentLocals.get(id).type);
+            if (stack) {
+                this.lazyStackBoxes.set(id, stack.box);
+                if (stack.owner)
+                    fnScope.push(stack.owner);
+            }
+        }
         const borrowed = this.callLifetimes.borrowed.get(fn.name);
         for (const [index, p] of fn.params.entries()) {
             const local = this.currentLocals.get(p.localId);
@@ -3129,6 +3590,8 @@ export class LlEmitter {
             B.line(`call void @scr_stack_enter(ptr %source_frame, ptr ${this.cstr(frame)})`);
             B.returnEpilogue = `call void @scr_stack_leave(ptr %source_frame)`;
         }
+        if (this.mod.workers)
+            this.emitPendingCheck();
         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
@@ -3279,6 +3742,20 @@ export class LlEmitter {
         switch (s.kind) {
             case "varDecl": {
                 const b = this.binding(s.localId);
+                const slice = this.scalarStringSlices.get(s.localId);
+                if (slice) {
+                    const snapshot = emitStringSliceSnapshot(this, slice);
+                    this.stringSlices.set(s.localId, snapshot);
+                    this.scopes[this.scopes.length - 1].push({ slot: snapshot.source, type: STRING });
+                    break;
+                }
+                const split = this.privateSplitLocals.get(s.localId);
+                if (split) {
+                    const snapshot = storeSplitSnapshot(this, emitSplitSnapshot(this, split));
+                    this.storedSplits.set(s.localId, snapshot);
+                    this.scopes[this.scopes.length - 1].push({ slot: snapshot.sourceSlot, type: STRING }, { slot: snapshot.separatorSlot, type: STRING });
+                    break;
+                }
                 const localUnion = this.localStackUnions.get(s.localId);
                 if (localUnion) {
                     const union = emitStackUnion(this, localUnion);
@@ -3321,6 +3798,19 @@ export class LlEmitter {
                     break;
                 }
                 if (b.kind === "boxed") {
+                    const stack = this.stackCaptures.emit(this, s.localId, b.type);
+                    if (stack) {
+                        B.line(`store ptr ${stack.box}, ptr ${b.slot}`);
+                        if (stack.owner)
+                            this.scopes[this.scopes.length - 1].push(stack.owner);
+                        if (s.init) {
+                            const value = this.emitExpr(s.init);
+                            if (isRefCounted(value.type))
+                                this.moveTemp(value);
+                            this.boxSet(stack.box, b.type, value.name);
+                        }
+                        break;
+                    }
                     // Box FIRST, then evaluate the initializer: a named function
                     // expression's closure captures this box during init evaluation.
                     // A SCALAR TDZ box rides an ARR-kind box: the value lives in a
@@ -3357,13 +3847,16 @@ export class LlEmitter {
                     }
                     break;
                 }
-                // A lexical const alias cannot outlive its unchanged local owner.
+                if (this.loopArrayBorrows.has(s) && s.init.kind === "arrayGet") {
+                    emitBorrowedArrayRead(this, s.init, b.slot);
+                    break;
+                }
+                // A stable lexical alias cannot outlive its unchanged local owner.
                 // Whole-value uses still retain their own copies, so returning or
                 // storing the alias preserves the ordinary heap representation.
                 // Boxed captures, reassigned sources and projections need ownership.
                 if (b.kind === "local" &&
                     b.local &&
-                    !b.local.mutable &&
                     isRefCounted(b.type) &&
                     this.stableCallBindings.has(s.localId) &&
                     this.canBorrowCallArgument(s.init)) {
@@ -3428,9 +3921,7 @@ export class LlEmitter {
                 const acc = elemAccess(s.arr.type.elem);
                 if (acc === "ref")
                     this.moveTemp(v);
-                const argTy = acc === "f64" ? "double" : acc === "bool" ? "i1" : "ptr";
-                this.declare(`declare void @scr_arr_set_${acc}(ptr, double, ${argTy === "i1" ? "i1 zeroext" : argTy})`);
-                B.line(`call void @scr_arr_set_${acc}(ptr ${arr.name}, double ${idx.name}, ${argTy} ${v.name})`);
+                emitDenseArraySet(this, arr.name, idx, s.index, acc, s.arr.type.elem, v.name);
                 break;
             }
             case "arraySetLength": {
@@ -3478,6 +3969,12 @@ export class LlEmitter {
                 // release — a release can trigger a cycle collection, which must
                 // never see a heap edge whose count was already given up).
                 // Classes and records share the struct layout, so one emission.
+                const nullable = s.kind === "fieldSet" ? this.nullableFields.get(s.className, s.field) : null;
+                if (nullable && s.kind === "fieldSet") {
+                    const obj = this.emitExpr(s.obj);
+                    this.emitNullableFieldStore(obj.name, s.className, s.field, nullable, s.value);
+                    break;
+                }
                 const obj = isRefCounted(s.value.type)
                     ? this.emitExpr(s.obj)
                     : this.emitStableReceiver(s.obj, [s.value]);
@@ -3561,7 +4058,7 @@ export class LlEmitter {
                     for (const f of shape.fields) {
                         const lit = this.internLiteral(f.name);
                         const hit = B.tmp();
-                        B.line(`${hit} = call zeroext i1 @scr_str_eq(ptr ${key.name}, ptr ${lit}) ; ${llvmCommentText(f.name)}`);
+                        B.line(`${hit} = call zeroext i1 @sc_str_eq(ptr ${key.name}, ptr ${lit}) ; ${llvmCommentText(f.name)}`);
                         const lh = B.newLabel("rks.h");
                         const ln = B.newLabel("rks.n");
                         B.condBr(hit, lh, ln);
@@ -3617,7 +4114,7 @@ export class LlEmitter {
                     // typeEquals(f.type, iv) — the frontend fences everything else.
                     const lit = this.internLiteral(f.name);
                     const hit = B.tmp();
-                    B.line(`${hit} = call zeroext i1 @scr_str_eq(ptr ${key.name}, ptr ${lit}) ; ${llvmCommentText(f.name)}`);
+                    B.line(`${hit} = call zeroext i1 @sc_str_eq(ptr ${key.name}, ptr ${lit}) ; ${llvmCommentText(f.name)}`);
                     const lh = B.newLabel("rks.h");
                     const ln = B.newLabel("rks.n");
                     B.condBr(hit, lh, ln);
@@ -3694,11 +4191,13 @@ export class LlEmitter {
                 break;
             }
             case "while": {
+                const workerBudget = this.workerLoopBudget();
                 const lc = B.newLabel("loop.c");
                 const lb = B.newLabel("loop.b");
                 const le = B.newLabel("loop.e");
                 B.br(lc);
                 B.startBlock(lc);
+                this.emitWorkerLoopCheck(workerBudget);
                 B.condBr(this.emitCondition(s.cond), lb, le);
                 B.startBlock(lb);
                 this.jumpTargets.push({
@@ -3717,12 +4216,14 @@ export class LlEmitter {
                 break;
             }
             case "doWhile": {
+                const workerBudget = this.workerLoopBudget();
                 // Body first (runs at least once); continue jumps to the CONDITION.
                 const lb = B.newLabel("loop.b");
                 const lc = B.newLabel("loop.c");
                 const le = B.newLabel("loop.e");
                 B.br(lb);
                 B.startBlock(lb);
+                this.emitWorkerLoopCheck(workerBudget);
                 this.jumpTargets.push({
                     kind: "loop",
                     brkLabel: le,
@@ -3751,6 +4252,33 @@ export class LlEmitter {
                 const countedLoop = !integerLoop && this.countedLoopsEnabled
                     ? matchIntegerCountedForLoop(s, this.numericLocals, this.integerRanges)
                     : null;
+                const window = countedLoop && this.byteWindowsEnabled
+                    ? matchByteWindow(s, countedLoop, this.numericLocals, this.captureIds, this.integerRanges, this.byteWindowEntries.get(s) ?? new Set())
+                    : null;
+                if (window) {
+                    const valid = emitByteWindowGuard(this, window);
+                    const fast = B.newLabel("bytes.window.fast"), slow = B.newLabel("bytes.window.slow"), done = B.newLabel("bytes.window.done");
+                    B.condBr(valid, fast, slow);
+                    const originalRanges = this.integerRanges, originalBounds = this.bytesBounds;
+                    this.byteWindowsEnabled = false;
+                    try {
+                        B.startBlock(slow);
+                        this.emitStmt(s);
+                        B.br(done);
+                        B.startBlock(fast);
+                        this.integerRanges = window.ranges;
+                        this.bytesBounds = new Set([...originalBounds, ...window.bounds]);
+                        this.emitStmt(s);
+                        B.br(done);
+                    }
+                    finally {
+                        this.integerRanges = originalRanges;
+                        this.bytesBounds = originalBounds;
+                        this.byteWindowsEnabled = true;
+                    }
+                    B.startBlock(done);
+                    break;
+                }
                 let countedJoin = null;
                 if (countedLoop?.guarded) {
                     const bound = this.emitExpr(countedLoop.limit);
@@ -3839,8 +4367,10 @@ export class LlEmitter {
                 };
                 const lu = s.update || capturedLets.length > 0 ? B.newLabel("loop.u") : lc;
                 freshenBindings();
+                const workerBudget = this.workerLoopBudget();
                 B.br(lc);
                 B.startBlock(lc);
+                this.emitWorkerLoopCheck(workerBudget);
                 if (integerLoop && integerSlot) {
                     const receiver = this.emitStableReceiver(integerLoop.limitReceiver, []);
                     const lenPtr = B.tmp();
@@ -3922,23 +4452,52 @@ export class LlEmitter {
                 if (s.iterable.type.kind !== "array")
                     throw new LlvmUnsupportedError(`forOf:${s.iterable.type.kind}`, s.loc);
                 const elem = s.iterable.type.elem;
-                const arr = this.emitExpr(s.iterable);
-                const idxSlot = B.slot();
-                B.entryAllocas.push(`${idxSlot} = alloca double`);
-                B.line(`store double ${f64Lit(0)}, ptr ${idxSlot}`);
+                const stored = s.iterable.kind === "varRef" ? this.storedSplits.get(s.iterable.localId) : undefined;
+                const direct = this.streamingSplitsEnabled ? stringSplit(s.iterable) : null;
+                const snapshot = stored
+                    ? loadSplitSnapshot(this, stored)
+                    : direct
+                        ? emitSplitSnapshot(this, direct)
+                        : null;
+                const arr = snapshot ? null : this.emitExpr(s.iterable);
+                const cursor = snapshot ? emitSplitCursor(this, snapshot) : null;
+                const scratch = snapshot ? emitSplitScratch(this) : null;
+                const deferred = snapshot && canDeferSplitPiece(s, this.currentLocals.get(s.localId));
+                const spanLength = deferred ? B.slot() : null;
+                if (spanLength)
+                    B.entryAllocas.push(`${spanLength} = alloca ${this.sizeType}`);
+                const idxSlot = snapshot ? null : B.slot();
+                if (idxSlot) {
+                    B.entryAllocas.push(`${idxSlot} = alloca double`);
+                    B.line(`store double ${f64Lit(0)}, ptr ${idxSlot}`);
+                }
                 const lc = B.newLabel("fof.c");
                 const lb = B.newLabel("fof.b");
                 const lu = B.newLabel("fof.u");
                 const le = B.newLabel("fof.e");
+                const workerBudget = this.workerLoopBudget();
                 B.br(lc);
                 B.startBlock(lc);
-                const i = B.tmp();
-                const len = B.tmp();
+                this.emitWorkerLoopCheck(workerBudget);
                 const inBounds = B.tmp();
-                this.declare(`declare double @scr_arr_len(ptr)`);
-                B.line(`${i} = load double, ptr ${idxSlot}`);
-                B.line(`${len} = call double @scr_arr_len(ptr ${arr.name})`);
-                B.line(`${inBounds} = fcmp olt double ${i}, ${len}`);
+                let cur;
+                if (snapshot && cursor && scratch) {
+                    cur = spanLength
+                        ? emitSplitSpanNext(this, snapshot, cursor, spanLength)
+                        : emitSplitNext(this, snapshot, cursor, scratch);
+                    B.line(`${inBounds} = icmp ne ptr ${cur}, null`);
+                }
+                else {
+                    const i = B.tmp(), lenPtr = B.tmp(), rawLen = B.tmp(), len = B.tmp();
+                    B.line(`${i} = load double, ptr ${idxSlot}`);
+                    // The inline form of scr_arr_len, like the `length` intrinsic.
+                    B.line(`${lenPtr} = getelementptr inbounds %ScrArr, ptr ${arr.name}, i32 0, i32 1`);
+                    this.markMemoryPointer(lenPtr, "array:header");
+                    B.line(`${rawLen} = load ${this.sizeType}, ptr ${lenPtr}${this.fieldAliasAttachment(lenPtr)}`);
+                    B.line(`${len} = uitofp ${this.sizeType} ${rawLen} to double`);
+                    B.line(`${inBounds} = fcmp olt double ${i}, ${len}`);
+                    cur = i;
+                }
                 B.condBr(inBounds, lb, le);
                 B.startBlock(lb);
                 this.jumpTargets.push({
@@ -3956,11 +4515,18 @@ export class LlEmitter {
                 this.scopes.push([]);
                 const localInfo = this.currentLocals.get(s.localId);
                 const slot = `%${mangleLocal(s.localId)}`;
-                const acc = elemAccess(elem);
-                const accTy = acc === "f64" ? "double" : acc === "bool" ? "i1" : "ptr";
-                this.declare(`declare ${acc === "bool" ? "zeroext i1" : accTy} @scr_arr_get_${acc}(ptr, double)`);
-                const cur = B.tmp();
-                B.line(`${cur} = call ${accTy} @scr_arr_get_${acc}(ptr ${arr.name}, double ${i})`);
+                const borrowedElement = !snapshot && this.loopArrayBorrows.has(s);
+                if (!snapshot) {
+                    const acc = elemAccess(elem);
+                    const getter = borrowedElement ? "scr_arr_borrow_ref" : `scr_arr_get_${acc}`;
+                    cur = emitDenseArrayGet(this, arr.name, { name: cur, type: { kind: "f64" } }, undefined, acc, elem, getter, !borrowedElement);
+                }
+                if (spanLength) {
+                    const length = B.tmp();
+                    B.line(`${length} = load ${this.sizeType}, ptr ${spanLength}`);
+                    this.splitSpans.set(s.localId, { bytes: cur, length, scratch: scratch });
+                    cur = "null";
+                }
                 if (localInfo?.boxed) {
                     // Captured loop variable: a fresh box per iteration, matching the
                     // fresh const binding. The box takes ownership of a ref element's
@@ -3973,10 +4539,12 @@ export class LlEmitter {
                 }
                 else {
                     B.line(`store ${this.llType(elem)} ${cur}, ptr ${slot}`);
-                    if (isRefCounted(elem))
+                    if (isRefCounted(elem) && !borrowedElement)
                         this.scopes[this.scopes.length - 1].push({ slot, type: elem });
                 }
                 this.emitStmts(s.body);
+                if (spanLength)
+                    this.splitSpans.delete(s.localId);
                 const endedWithJump = endsWithJump(s.body);
                 const scope = this.scopes.pop();
                 if (!endedWithJump)
@@ -3984,11 +4552,12 @@ export class LlEmitter {
                 this.jumpTargets.pop();
                 B.br(lu);
                 B.startBlock(lu);
-                const i2 = B.tmp();
-                const i3 = B.tmp();
-                B.line(`${i2} = load double, ptr ${idxSlot}`);
-                B.line(`${i3} = fadd double ${i2}, ${f64Lit(1)}`);
-                B.line(`store double ${i3}, ptr ${idxSlot}`);
+                if (idxSlot) {
+                    const i2 = B.tmp(), i3 = B.tmp();
+                    B.line(`${i2} = load double, ptr ${idxSlot}`);
+                    B.line(`${i3} = fadd double ${i2}, ${f64Lit(1)}`);
+                    B.line(`store double ${i3}, ptr ${idxSlot}`);
+                }
                 B.br(lc);
                 B.startBlock(le);
                 break;
@@ -4346,7 +4915,7 @@ export class LlEmitter {
                 const hit = B.tmp();
                 if (c.test.type.kind === "string") {
                     this.declare(`declare zeroext i1 @scr_str_eq(ptr, ptr)`);
-                    B.line(`${hit} = call zeroext i1 @scr_str_eq(ptr ${disc.name}, ptr ${t.name})`);
+                    B.line(`${hit} = call zeroext i1 @sc_str_eq(ptr ${disc.name}, ptr ${t.name})`);
                 }
                 else if (c.test.type.kind === "bool") {
                     B.line(`${hit} = icmp eq i1 ${disc.name}, ${t.name}`);
@@ -4517,10 +5086,20 @@ export class LlEmitter {
         if (e.kind === "strLit")
             return { name: this.internLiteral(e.value), type: e.type };
         if (e.kind === "varRef") {
+            this.materializeSplitLocal(e.localId);
             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 === "boxed") {
+                // A projection consumes this pointer before any user code runs.
+                // Keep TDZ checks and caught-value conversion on the owned path.
+                if (!this.canBorrowReceiver(e))
+                    return this.emitExpr(e);
+                const box = this.loadBox(binding.slot);
+                const payload = this.B.tmp();
+                const value = this.B.tmp();
+                this.B.line(`${payload} = getelementptr inbounds %ScrBox, ptr ${box}, i32 0, i32 5`);
+                this.B.line(`${value} = load ptr, ptr ${payload}`);
+                return { name: value, type: e.type };
+            }
             if (binding.kind === "global")
                 this.checkGlobalTdz(e.localId);
             const value = this.B.tmp();
@@ -4534,17 +5113,26 @@ export class LlEmitter {
                 this.ownSlot(result.owner.slot, result.owner.type);
             return result.value;
         }
+        const arrayRead = this.optionalArrayReads.get(e);
+        if (arrayRead)
+            return emitProjectedArrayRead(this, arrayRead);
         if (canStackUnion(e, this.unionsById))
             return emitStackUnion(this, e).value;
         if (e.kind === "unionNarrow") {
-            const union = this.emitReadReceiver(e.value);
+            const union = this.emitUnionProjection(e.value);
             return { name: this.unionPeek(union.name), type: e.type };
         }
+        // A nullable-pointer field has no box to borrow. Projections use
+        // emitUnionProjection; other borrowers get an owned heap box.
+        if (this.nullableFieldGet(e))
+            return this.emitExpr(e);
         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);
+            if (e.kind === "recordGet") {
+                const { ptr, type } = this.recordFieldPtr(receiver.name, e.shapeId, e.field);
+                return { name: this.loadRecordField(ptr, type), type: e.type };
+            }
+            const { ptr, type } = this.classFieldPtr(receiver.name, e.className, e.field);
             return { name: this.loadField(ptr, type), type: e.type };
         }
         if (e.kind === "ternary" && this.canBorrowReceiver(e.then) && this.canBorrowReceiver(e.else_)) {
@@ -4574,10 +5162,163 @@ export class LlEmitter {
         }
         return this.emitExpr(e);
     }
+    /** A private stack union source with an independently owned payload. */
+    canStackReceiver(e) {
+        return this.isStackUnionSource(e);
+    }
+    /** True for union sources that emitReadReceiver can produce as a private
+     * stack box with an independently owned payload (no heap union). */
+    isStackUnionSource(e) {
+        if (e.type.kind !== "union")
+            return false;
+        return (canStackUnion(e, this.unionsById) ||
+            matchMapRead(e, this.unionsById) !== null ||
+            this.optionalArrayReads.get(e) !== null);
+    }
+    /** The nullable-pointer representation behind a union-typed class field
+     * read, or null for every other expression. */
+    nullableFieldGet(e) {
+        if (e.kind !== "fieldGet" || e.type.kind !== "union")
+            return null;
+        return this.nullableFields.get(e.className, e.field);
+    }
+    /** A union operand consumed only by a projection (tag test, payload
+     * extraction, arm compare, truthiness). A nullable-pointer field read
+     * becomes a private stack box whose payload is borrowed from the field:
+     * the consumer must finish before any later expression can store to the
+     * field, and must never retain, release, or store the box. Every other
+     * operand takes the ordinary borrowed-receiver path. */
+    emitUnionProjection(e) {
+        const nullable = this.nullableFieldGet(e);
+        if (!nullable || e.kind !== "fieldGet")
+            return this.emitReadReceiver(e);
+        const B = this.B;
+        const receiver = this.emitReadReceiver(e.obj);
+        const { ptr } = this.classFieldPtr(receiver.name, e.className, e.field);
+        const p = B.tmp();
+        B.line(`${p} = load ptr, ptr ${ptr}${this.fieldAliasAttachment(ptr)}`);
+        return { name: this.stackNullableBox(p, nullable), type: e.type };
+    }
+    /** A private stack box over a nullable-pointer field read whose payload
+     * is retained into the current frame: an independent owner, so the box
+     * may outlive later stores to the field (call arguments, local copies).
+     * The box itself must still never reach an RC entry point. */
+    emitOwnedNullableStack(e) {
+        const nullable = this.nullableFieldGet(e);
+        if (!nullable || e.kind !== "fieldGet")
+            throw new InternalCompilerError("llvm emitter bug: owned nullable stack of non-field");
+        const receiver = this.emitReadReceiver(e.obj);
+        const { ptr } = this.classFieldPtr(receiver.name, e.className, e.field);
+        const p = this.B.tmp();
+        this.B.line(`${p} = load ptr, ptr ${ptr}${this.fieldAliasAttachment(ptr)}`);
+        const owner = this.own({ name: this.retainValue(p, nullable.arm), type: nullable.arm });
+        return { box: this.stackNullableBox(owner.name, nullable), owner };
+    }
+    /** A private stack box over a borrowed nullable pointer. */
+    stackNullableBox(p, nullable) {
+        const B = this.B;
+        const box = B.slot();
+        B.entryAllocas.push(`${box} = alloca %ScrUnion`);
+        const isNull = B.tmp(), tag = B.tmp(), tagPtr = B.tmp(), slot = B.tmp();
+        B.line(`${isNull} = icmp eq ptr ${p}, null`);
+        B.line(`${tag} = select i1 ${isNull}, i32 ${nullable.unitTag}, i32 ${nullable.refTag}`);
+        B.line(`${tagPtr} = getelementptr inbounds %ScrUnion, ptr ${box}, i64 0, i32 1`);
+        B.line(`store i32 ${tag}, ptr ${tagPtr}`);
+        B.line(`${slot} = getelementptr inbounds %ScrUnion, ptr ${box}, i64 0, i32 5`);
+        B.line(`store i64 0, ptr ${slot}`);
+        B.line(`store ptr ${p}, ptr ${slot}`);
+        return box;
+    }
+    /** The owned (+1) union value of a nullable-pointer slot: the unit arm's
+     * immortal instance, or a fresh heap box around a retained instance. */
+    nullableToOwnedUnion(p, nullable) {
+        const B = this.B;
+        const slot = B.slot();
+        B.entryAllocas.push(`${slot} = alloca ptr`);
+        const isNull = B.tmp();
+        const unit = B.newLabel("nf.u"), ref = B.newLabel("nf.r"), join = B.newLabel("nf.j");
+        B.line(`${isNull} = icmp eq ptr ${p}, null`);
+        B.condBr(isNull, unit, ref);
+        B.startBlock(unit);
+        B.line(`store ptr ${this.unitInstanceRef(nullable.unionId, nullable.unitTag)}, ptr ${slot}`);
+        B.br(join);
+        B.startBlock(ref);
+        const owned = this.retainValue(p, nullable.arm);
+        const box = this.unionNewOwned(nullable.refTag, { name: owned, type: nullable.arm });
+        B.line(`store ptr ${box}, ptr ${slot}`);
+        B.br(join);
+        B.startBlock(join);
+        const t = B.tmp();
+        B.line(`${t} = load ptr, ptr ${slot}`);
+        return t;
+    }
+    /** The owned (+1) instance pointer (NULL for the unit arm) of a union
+     * box, which stays owned by its existing owner. */
+    unionToNullable(u, nullable) {
+        const B = this.B;
+        const tag = this.unionTag(u);
+        const isRef = B.tmp(), sel = B.tmp();
+        B.line(`${isRef} = icmp eq i32 ${tag}, ${nullable.refTag}`);
+        const payload = this.unionPeek(u);
+        B.line(`${sel} = select i1 ${isRef}, ptr ${payload}, ptr null`);
+        return this.retainValue(sel, nullable.arm);
+    }
+    /** `obj.f = value` for a nullable-pointer field: the new instance pointer
+     * is produced without a union box where the value is a wrap, and as a
+     * retained payload of a borrowed box otherwise. Unlink-then-release like
+     * every field store. */
+    emitNullableFieldStore(obj, className, field, nullable, value) {
+        const B = this.B;
+        let next;
+        if (value.kind === "unionWrap" &&
+            value.unionId === nullable.unionId &&
+            (value.tag === nullable.refTag
+                ? typeEquals(value.value.type, nullable.arm)
+                : value.tag === nullable.unitTag)) {
+            if (value.tag === nullable.refTag) {
+                const inner = this.emitExpr(value.value);
+                this.moveTemp(inner);
+                next = inner.name;
+            }
+            else {
+                // Unit payloads carry nothing; a void payload runs for effects.
+                if (!isUnitType(value.value.type))
+                    this.emitExpr(value.value);
+                next = "null";
+            }
+        }
+        else if (value.kind === "varRef" && !this.canBorrowReceiver(value)) {
+            next = this.unionToNullable(this.emitExpr(value).name, nullable);
+        }
+        else {
+            next = this.unionToNullable(this.emitUnionProjection(value).name, nullable);
+        }
+        const { ptr } = this.classFieldPtr(obj, className, field);
+        const old = B.tmp();
+        B.line(`${old} = load ptr, ptr ${ptr}`);
+        B.line(`store ptr ${next}, ptr ${ptr}${this.fieldAliasAttachment(ptr)}`);
+        this.releaseValue(old, nullable.arm);
+    }
+    /** A union binding whose slot may hold a private stack box: stack locals
+     * and projection-only parameters (callers may pass stack boxes). Such a
+     * box must only be projected: never retained, released, or stored. */
+    isStackUnionLocal(localId) {
+        return (this.projectedParameters.has(localId) ||
+            this.localStackUnions.has(localId) ||
+            this.localUnionStorage.has(localId) ||
+            this.localArrayReads.has(localId) ||
+            this.mapReadLifetimes.locals.has(localId));
+    }
     canBorrowReceiver(e) {
         switch (e.kind) {
-            case "varRef":
-                return this.binding(e.localId).kind !== "boxed";
+            case "varRef": {
+                const binding = this.binding(e.localId);
+                return (binding.kind !== "boxed" ||
+                    (!binding.local.tdz &&
+                        binding.type.kind === e.type.kind &&
+                        e.type.kind !== "caught" &&
+                        isRefCounted(e.type)));
+            }
             case "unionNarrow":
                 return this.canBorrowReceiver(e.value);
             case "fieldGet":
@@ -4593,6 +5334,11 @@ export class LlEmitter {
                 return false;
         }
     }
+    materializeSplitLocal(localId) {
+        const span = this.splitSpans.get(localId);
+        if (span)
+            materializeSplitPiece(this, localId, span);
+    }
     emitExpr(e) {
         return emitExpr(this, e);
     }