@scriptc/compiler 0.2.5 → 0.2.6

package/dist/backend/llvm/emitter.js

@@ -21,13 +21,16 @@ import { InternalCompilerError } from "../../errors.js";
 import { deflateRawSync } from "node:zlib";
 import { endsWithJump, matchStringSelfConcat, streamTypedRefEligible } from "../../ir/analysis.js";
 import { emitLibraryIdentityLines } from "../library-identity-markers.js";
-import { CAUGHT, ffiCallbackType, isDynTypedRefType, isFfiContextParam, isRefCounted, isUnitType, 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, 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,12 +44,17 @@ 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 { emitLocalArrayRead, emitBorrowedArrayRead, findLocalArrayReads, findCallArrayReads, OptionalArrayReads, } from "./local-array-reads.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 { StackCallbacks } from "./stack-callbacks.js";
+import { findLoopArrayBorrows } from "./loop-array-borrows.js";
+import { findConstantCallbacks } from "./constant-callbacks.js";
+import { findScalarStringSlices, emitStringSliceSnapshot, } from "./string-slices.js";
+import { StackCaptures } from "./stack-captures.js";
 import { f64Lit, ffiNativeTypeLl, ffiNativeParamLl, ffiNativeReturnLl, llvmCommentText, } from "./common.js";
 import { ffiExtendsNarrowIntegers } from "../targets.js";
 import { emitLiteralExpr, emitOperatorExpr, emitStringExpr, emitContainerExpr, emitRecordExpr, } from "./expr-primitives.js";
@@ -67,7 +75,7 @@ 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";
@@ -100,11 +108,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 +128,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();
@@ -206,6 +221,10 @@ export class LlEmitter {
     callArrayReads = new Map();
     mapReadLifetimes = { locals: new Map(), arguments: new Map() };
     callLifetimes;
+    constantCallbacks;
+    currentConstantCallbacks = new Map();
+    stackCallbacks;
+    stackCaptures;
     borrowedParameters = new Set();
     stableCallBindings = new Set();
     /** Manifest-bound native imports, used by ffiCall emission. */
@@ -288,6 +307,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 +318,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`
@@ -359,7 +384,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}`))
@@ -371,6 +399,9 @@ export class LlEmitter {
         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.constantCallbacks = findConstantCallbacks(mod, this.callLifetimes);
+        this.stackCallbacks = new StackCallbacks(this.fnByName);
+        this.stackCaptures = new StackCaptures(this.fnByName, this.callLifetimes, this.stackCallbacks);
         for (const r of mod.records ?? [])
             this.recordsById.set(r.id, r);
         const traced = computeTraced(mod);
@@ -396,8 +427,9 @@ export class LlEmitter {
             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 +539,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))
@@ -953,7 +985,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 +1113,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 = [
@@ -1121,11 +1156,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,8 +1183,8 @@ 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_v7()`] : []), ...(this.runtimeAbiMarker && this.mod.lib === undefined
             ? [`declare void @${RUNTIME_ABI_MARKER}()`]
             : []));
         for (const d of this.decls)
@@ -1306,7 +1341,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)
@@ -1343,7 +1378,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_v7()`] : []), `  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).
@@ -1456,6 +1491,9 @@ export class LlEmitter {
         // 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());
@@ -1723,7 +1761,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)} }`, ``);
         }
         return out;
     }
@@ -2206,6 +2244,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;
@@ -2269,6 +2321,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
@@ -2973,6 +3053,17 @@ export class LlEmitter {
         this.unwindCleanups.clear();
         this.jumpTargets = [];
         this.currentLocals = new Map(fn.locals.map((l) => [l.id, l]));
+        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);
+        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]));
@@ -2986,11 +3077,22 @@ 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);
@@ -3129,6 +3231,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 +3383,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 +3439,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 +3488,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)) {
@@ -3694,11 +3828,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 +3853,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 +3889,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 +4004,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 +4089,49 @@ 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(), len = 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}`);
+                    cur = i;
+                }
                 B.condBr(inBounds, lb, le);
                 B.startBlock(lb);
                 this.jumpTargets.push({
@@ -3956,11 +4149,22 @@ 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 accTy = acc === "f64" ? "double" : acc === "bool" ? "i1" : "ptr";
+                    const getter = borrowedElement ? "scr_arr_borrow_ref" : `scr_arr_get_${acc}`;
+                    this.declare(`declare ${acc === "bool" ? "zeroext i1" : accTy} @${getter}(ptr, double)`);
+                    const value = B.tmp();
+                    B.line(`${value} = call ${accTy} @${getter}(ptr ${arr.name}, double ${cur})`);
+                    cur = value;
+                }
+                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 +4177,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 +4190,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;
@@ -4517,10 +4724,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();
@@ -4576,8 +4793,14 @@ export class LlEmitter {
     }
     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 +4816,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);
     }