@scriptc/compiler 0.2.3 → 0.2.5

package/dist/backend/llvm/emitter.js

@@ -21,43 +21,52 @@ 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, moduleRuntimeFeatures, moduleEmbedsBuiltin, moduleEmbedsCompressedNpm, NPM_COMPRESS_MIN, POINTER_KINDS, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, typeKey, VOID } from "../../ir/ir.js";
-import { matchIntegerArrayForLoop, matchIntegerBytesForLoop } from "../../ir/integer-loops.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 { 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 { scalarizeNumericRecords } from "../../ir/scalar-records.js";
 import { everyStmtList } from "../../ir/traverse.js";
 import { analyzeIntegerRanges } from "../../ir/integer-ranges.js";
+import { findIntegerViews } from "./integer-views.js";
+import { findInitializerBindings, withInitializerBindings } from "../../ir/initializer-bindings.js";
 import { findConstantNumericTables } from "../../ir/constant-tables.js";
-import { allocateFfiCallbackAdapters, hasForeignFfiCallback, hasRetainedFfiCallback } from "../ffi-callbacks.js";
+import { allocateFfiCallbackAdapters, hasForeignFfiCallback, hasRetainedFfiCallback, } from "../ffi-callbacks.js";
 import { RUNTIME_ABI_MARKER } from "../runtime-abi.js";
 import { computeMayThrow } from "../may-throw.js";
-import { mangleArgPack, mangleAsyncSpawn, mangleBorrowedFunction, mangleClassObj, mangleClassStruct, mangleFnClosure, mangleFunction, mangleGenDrop, mangleGenSpawn, mangleGlobal, mangleLocal, mangleRecordStruct, mangleTrampoline, mangleWrapper, mangleVtInstance } from "../mangle.js";
+import { mangleArgPack, mangleAsyncSpawn, mangleBorrowedFunction, mangleClassObj, mangleClassStruct, mangleFnClosure, mangleFunction, mangleGenDrop, mangleGenSpawn, mangleGlobal, mangleLocal, mangleRecordStruct, mangleTrampoline, mangleWrapper, mangleVtInstance, } from "../mangle.js";
 import { analyzeCallLifetimes } from "./call-lifetimes.js";
-import { emitStackUnion, findLocalStackUnions } from "./stack-unions.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, findArrayPreservingFunctions, findLocalArrayReads, findCallArrayReads, OptionalArrayReads } from "./local-array-reads.js";
-import { emitStackMapRead, findMapReadLifetimes } from "./map-read-lifetimes.js";
+import { emitLocalArrayRead, 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 { f64Lit, ffiNativeTypeLl, ffiNativeParamLl, ffiNativeReturnLl, llvmCommentText } from "./common.js";
+import { f64Lit, ffiNativeTypeLl, ffiNativeParamLl, ffiNativeReturnLl, llvmCommentText, } from "./common.js";
 import { ffiExtendsNarrowIntegers } from "../targets.js";
-import { emitLiteralExpr, emitOperatorExpr, emitStringExpr, emitContainerExpr, emitRecordExpr } from "./expr-primitives.js";
+import { emitLiteralExpr, emitOperatorExpr, emitStringExpr, emitContainerExpr, emitRecordExpr, } from "./expr-primitives.js";
 import { emitControlExpr } from "./expr-control.js";
 import { emitCallExpr } from "./expr-calls.js";
 import { emitDynamicExpr } from "./expr-dynamic.js";
 import { emitIntrinsicExpr, emitSerializationExpr, emitAsyncExpr } from "./expr-async.js";
 import { emitJsInteropExpr, emitExpr } from "./expr-dispatch.js";
-import { emitJsMarshal, emitJsOp, emitJsExit, islandAdapter, islandTypedAdapter } from "./expr-island.js";
-import { dynKind, raceAdapterFor, genResultThunkFor, childExitThunkFor, childExitSignalThunkFor, childDataThunkFor, execFileThunkFor, ipcMessageThunkFor, ipcSendThunkFor, emitterFixedAdapter, wrapEmitterListener, unwrapNullableClosure, closeBindThunkFor, closeOverrideWrapFor } from "./expr-callbacks.js";
-import { streamDataAdapter, streamDoneFnFor, cryptoBytesThunkFor, fsRenameThunkFor, streamCbThunkFor, zlibBytesThunkFor } from "./expr-stream-callbacks.js";
-import { emitStableReceiver, resolveThunkFor, tagInSet, arrPush, emitArrayCopyLoop, emitStrIntrinsic, emitArrIntrinsic, wrapNullable, emitMapNew, mapSet, emitMapLikeIntrinsic, emitSetNew } from "./expr-containers.js";
-import { emitIntegerLoopIndex, emitBytesIndex, emitBytesData, emitBytesLength, emitBytesGet, emitToUint32, emitBytesSet, emitBytesIntrinsic } from "./expr-bytes.js";
+import { emitJsMarshal, emitJsOp, emitJsExit, islandAdapter, islandTypedAdapter, } from "./expr-island.js";
+import { dynKind, raceAdapterFor, genResultThunkFor, childExitThunkFor, childExitSignalThunkFor, childDataThunkFor, execFileThunkFor, ipcMessageThunkFor, ipcSendThunkFor, emitterFixedAdapter, wrapEmitterListener, unwrapNullableClosure, closeBindThunkFor, closeOverrideWrapFor, } from "./expr-callbacks.js";
+import { streamDataAdapter, streamDoneFnFor, cryptoBytesThunkFor, fsRenameThunkFor, streamCbThunkFor, zlibBytesThunkFor, } from "./expr-stream-callbacks.js";
+import { emitStableReceiver, resolveThunkFor, tagInSet, arrPush, emitArrayCopyLoop, emitStrIntrinsic, emitArrIntrinsic, wrapNullable, emitMapNew, mapSet, emitMapLikeIntrinsic, emitSetNew, } from "./expr-containers.js";
+import { emitIntegerLoopIndex, emitBytesIndex, emitBytesData, emitBytesLength, emitBytesGet, emitToUint32, emitBytesSet, emitBytesIntrinsic, } from "./expr-bytes.js";
 import { emitRegexIntrinsic, emitRecordKeyGet, keyedRecordReadInto } from "./expr-records.js";
-import { dynPromiseAdapter, streamTypedRefCommitAdapter, liveDynUnionRefAdapter, streamTypedRefBoxValue, streamTypedRefMaterializeAdapter, streamFromArrayAdapter } from "./expr-stream-bridges.js";
-import { emitWebLibCall, emitDynamicLibCall, emitFilesystemLibCall, emitPathUrlLibCall, emitPrimitiveLibCall } from "./lib-filesystem.js";
-import { emitChildProcessLibCall, emitAsyncContextLibCall, emitProcessLibCall, emitErrorsEventsLibCall } from "./lib-process.js";
+import { dynPromiseAdapter, streamTypedRefCommitAdapter, liveDynUnionRefAdapter, streamTypedRefBoxValue, streamTypedRefMaterializeAdapter, streamFromArrayAdapter, } from "./expr-stream-bridges.js";
+import { emitWebLibCall, emitDynamicLibCall, emitFilesystemLibCall, emitPathUrlLibCall, emitPrimitiveLibCall, } from "./lib-filesystem.js";
+import { emitChildProcessLibCall, emitAsyncContextLibCall, emitProcessLibCall, emitErrorsEventsLibCall, } from "./lib-process.js";
 import { emitStreamLibCall } from "./lib-stream.js";
 import { emitNetworkHttpLibCall } from "./lib-network.js";
-import { emitAssertInspectLibCall, emitIoLibCall, emitGenericLibCall, emitLibCall } from "./lib-dispatch.js";
+import { emitAssertInspectLibCall, emitIoLibCall, emitGenericLibCall, emitLibCall, } from "./lib-dispatch.js";
 import { buildClassGraph, classEnvironmentIndex, classFieldIndex, classStructSym, } from "./classes.js";
 import { LlDyn } from "./dyn.js";
 import { LlvmUnsupportedError } from "./unsupported.js";
@@ -99,7 +108,7 @@ export function emitLlvmModuleSource(mod, options = {}) {
     const length = parts.reduce((total, part) => total + part.length, Math.max(0, parts.length - 1));
     if (length <= 256 * 1024 * 1024)
         return parts.join("\n");
-    return parts.flatMap((part, index) => index === 0 ? [part] : ["\n", part]);
+    return parts.flatMap((part, index) => (index === 0 ? [part] : ["\n", part]));
 }
 function llStrBytes(text) {
     return llBytes(Buffer.from(text, "utf8"));
@@ -108,6 +117,8 @@ export class LlEmitter {
     mod;
     localArrayReads = new Map();
     localStackUnions = new Map();
+    localUnionStorageProofs = new Map();
+    localUnionStorage = new Map();
     integerArrayBindings = new Set();
     fieldAliasTags = new Map();
     fieldPointerTags = new Map();
@@ -156,6 +167,7 @@ export class LlEmitter {
      * immortal (rc == SIZE_MAX) static per (union, unit tag).
      * RC entry points and the collector skip immortals. */
     unitInstances = new Map();
+    immortalValues = new Set();
     /** Regex literal templates: "<flags>/<pattern>" → { symbol, interned
      * source/flags literal refs } — one immortal ScrRegex template per distinct
      * (pattern, flags) pair; the bytecode slot starts null and the runtime
@@ -189,12 +201,13 @@ export class LlEmitter {
     needsBadKey = false;
     needsRetainBox = false;
     fnByName = new Map();
-    arrayPreservingFunctions;
+    referenceEffects;
     optionalArrayReads;
     callArrayReads = new Map();
     mapReadLifetimes = { locals: new Map(), arguments: new Map() };
     callLifetimes;
     borrowedParameters = new Set();
+    stableCallBindings = new Set();
     /** Manifest-bound native imports, used by ffiCall emission. */
     ffiByName = new Map();
     /** C-ABI callback trampolines and (for raw/no-userdata callbacks) their
@@ -275,10 +288,15 @@ export class LlEmitter {
      * for blocks and switches. */
     jumpTargets = [];
     currentLocals = new Map();
+    initializerBindings;
+    numericLocals = new Map();
     captureIds = new Set();
-    /** Active canonical byte-loop induction bindings: local id → size_t slot. */
+    /** Active induction bindings retain their width independently of size_t. */
     integerLoopBindings = new Map();
+    countedLoopsEnabled = false;
     integerRanges = new Map();
+    bytesBounds = new Set();
+    integerViews = new Map();
     /** Enclosing try-with-FINALLY regions, innermost last: a `return`
      * inside one runs every crossed finally (innermost first) before the
      * actual ret — the runtime ABI’s pending-return path, with the finally
@@ -312,12 +330,18 @@ export class LlEmitter {
     constructor(mod, options) {
         this.mod = mod;
         this.stackTraces = mod.functions.some((fn) => !everyStmtList(fn.body, {
-            stmt: () => true, expr: (expr) => !(expr.kind === "libCall" && expr.fn === "error.stack"),
+            stmt: () => true,
+            expr: (expr) => !(expr.kind === "libCall" && expr.fn === "error.stack"),
         }));
-        this.debug = options.debugSources === undefined ? null : new LlvmDebugInfo(mod.sourceFile, options.debugSources, options.pointerBits, mod.unions);
+        this.debug =
+            options.debugSources === undefined
+                ? null
+                : new LlvmDebugInfo(mod.sourceFile, options.debugSources, options.pointerBits, mod.unions);
         this.constantNumericTables = findConstantNumericTables(mod);
+        this.initializerBindings = findInitializerBindings(mod);
         this.sizeType = options.pointerBits === 32 ? "i32" : "i64";
-        this.ffiExtendNarrowIntegers = options.wasi === true || ffiExtendsNarrowIntegers(options.targetTriple);
+        this.ffiExtendNarrowIntegers =
+            options.wasi === true || ffiExtendsNarrowIntegers(options.targetTriple);
         this.wasi = options.wasi === true;
         this.emitLibraryIdentity = options.emitLibraryIdentity !== false;
         this.runtimeAbiMarker = options.runtimeAbiMarker === true;
@@ -345,7 +369,7 @@ export class LlEmitter {
         for (const u of mod.unions ?? [])
             this.unionsById.set(u.id, u);
         this.optionalArrayReads = new OptionalArrayReads(this.fnByName, this.unionsById);
-        this.arrayPreservingFunctions = findArrayPreservingFunctions(this.fnByName, this.unionsById, this.optionalArrayReads);
+        this.referenceEffects = new ReferenceEffects(this.fnByName, (call) => this.optionalArrayReads.get(call) !== null);
         this.callLifetimes = analyzeCallLifetimes(this.fnByName);
         for (const r of mod.records ?? [])
             this.recordsById.set(r.id, r);
@@ -372,7 +396,9 @@ export class LlEmitter {
             isErrorClass: (name) => this.classMeta.get(name)?.root.def.name === "%Error",
             classSubtypes: (name) => {
                 const target = this.classMetaOf(name);
-                return [...this.classMeta.values()].filter((meta) => target.pre <= meta.pre && meta.pre <= target.post).map((meta) => meta.def.name);
+                return [...this.classMeta.values()]
+                    .filter((meta) => target.pre <= meta.pre && meta.pre <= target.post)
+                    .map((meta) => meta.def.name);
             },
         };
         this.walkers = new LlWalkers(this.shapeHost);
@@ -492,8 +518,10 @@ export class LlEmitter {
                 return [`${ffiNativeParamLl(param, this.ffiExtendNarrowIntegers)} %a${i}`];
             });
             if (cb.invoke === "foreign") {
-                if (adapter.table === null || !cb.params.some(isFfiContextParam) || cb.returns !== "void" ||
-                    cb.params.some(param => param === "i64" || param === "u64" || param === "pointer")) {
+                if (adapter.table === null ||
+                    !cb.params.some(isFfiContextParam) ||
+                    cb.returns !== "void" ||
+                    cb.params.some((param) => param === "i64" || param === "u64" || param === "pointer")) {
                     throw new InternalCompilerError("llvm emitter bug: invalid foreign FFI callback descriptor");
                 }
                 const dispatch = `${adapter.symbol}_dispatch`;
@@ -678,7 +706,9 @@ export class LlEmitter {
                 defs.push(`  %invoke_pin = call ptr @scr_closure_retain_v(ptr %cb)`);
             }
             if (cb.returns === "void") {
-                defs.push(`  call void %fn(${callArgs})`, ...(cb.lifetime === "retained" ? [`  call void @scr_closure_release_v(ptr %invoke_pin)`] : []), `  ret void`, `}`, ``);
+                defs.push(`  call void %fn(${callArgs})`, ...(cb.lifetime === "retained"
+                    ? [`  call void @scr_closure_release_v(ptr %invoke_pin)`]
+                    : []), `  ret void`, `}`, ``);
                 continue;
             }
             defs.push(`  %result = call ${internalRet} %fn(${callArgs})`);
@@ -833,18 +863,18 @@ export class LlEmitter {
         // Stream-surface programs fill the loop's stream hook (the deferred
         // next-tick emissions) and the emitter's post-registration flow kick
         // before %main — scr_stream.c links only when the line is emitted
-        // (native-toolchain.ts gates on the same predicate).
+        // (native/executable.ts gates on the same predicate).
         const usesStream = runtimeFeatures.stream;
         // Net-surface programs fill the loop's net hooks (and the netSocket
         // handle-dispatch ops for the checked-dynamic boundary); http-surface
         // programs additionally stamp the httpReq/httpRes ops — the C main's
-        // install lines, gated on the same predicates native-toolchain.ts links by.
+        // install lines, gated on the same predicates native/executable.ts links by.
         const usesNet = runtimeFeatures.net;
         const usesDgram = runtimeFeatures.dgram;
         const usesHttp2 = runtimeFeatures.http2;
         const usesHttp = runtimeFeatures.http;
         // Fetch-referencing programs register the native fetch bridge before
-        // any island entry (the engine's lazy boot consults it) — native-toolchain.ts
+        // any island entry (the engine's lazy boot consults it) — native/executable.ts
         // compiles scr_fetch.c on the same predicate.
         const usesFetch = runtimeFeatures.fetch;
         const embedsZlib = moduleEmbedsBuiltin(this.mod, "node:zlib");
@@ -852,7 +882,8 @@ export class LlEmitter {
             moduleEmbedsBuiltin(this.mod, "node:https") ||
             moduleEmbedsBuiltin(this.mod, "node:net") ||
             moduleEmbedsBuiltin(this.mod, "node:tls");
-        const snapshotsTlsCa = runtimeFeatures.tls || runtimeFeatures.tlsCa ||
+        const snapshotsTlsCa = runtimeFeatures.tls ||
+            runtimeFeatures.tlsCa ||
             moduleEmbedsBuiltin(this.mod, "node:https") ||
             moduleEmbedsBuiltin(this.mod, "node:tls");
         // The process verdict has the same precedence as the C reference
@@ -865,10 +896,14 @@ export class LlEmitter {
             this.declare(`declare void @scr_events_install()`);
         if (usesChildProcess)
             this.declare(`declare void @scr_child_dyn_install()`);
-        const childStreamBoxes = usesChildProcess && usesStream &&
-            this.classMeta.has("%Readable") && this.classMeta.has("%Writable")
-            ? [this.dyn.toDynHelper({ kind: "object", className: "%Readable" }),
-                this.dyn.toDynHelper({ kind: "object", className: "%Writable" })]
+        const childStreamBoxes = usesChildProcess &&
+            usesStream &&
+            this.classMeta.has("%Readable") &&
+            this.classMeta.has("%Writable")
+            ? [
+                this.dyn.toDynHelper({ kind: "object", className: "%Readable" }),
+                this.dyn.toDynHelper({ kind: "object", className: "%Writable" }),
+            ]
             : null;
         if (childStreamBoxes) {
             this.declare(`@scr_stream_child_ops = external constant { ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr }`);
@@ -1159,9 +1194,7 @@ export class LlEmitter {
             // entry points). Every dense slot is present; reads retain immortal
             // strings — a no-op.
             const n = inst.slots.length;
-            const present = n === 0
-                ? "zeroinitializer"
-                : `[ ${inst.slots.map(() => "i8 1").join(", ")} ]`;
+            const present = n === 0 ? "zeroinitializer" : `[ ${inst.slots.map(() => "i8 1").join(", ")} ]`;
             out.push(`@${inst.sym}_data = internal constant [${n} x ptr] [ ${inst.slots.map((s) => `ptr ${s}`).join(", ")} ]`, `@${inst.sym}_present = internal constant [${n} x i8] ${present}`, `@${inst.sym} = internal global %ScrArr { ${this.sizeType} -1, ${this.sizeType} ${n}, ${this.sizeType} ${n}, i32 2, ptr null, ptr null, ptr null, ptr @${inst.sym}_data, ptr @${inst.sym}_present, ptr null, ${this.sizeType} 0, ${this.sizeType} 0, ptr null, ${this.sizeType} 0, ${this.sizeType} 0, ptr null }`);
         }
         if (this.templateStringsInstances.size > 0)
@@ -1189,13 +1222,17 @@ export class LlEmitter {
                 const esm = stored.esm === null
                     ? `ptr null, ${this.sizeType} 0, ${this.sizeType} 0`
                     : `ptr @sc_npm_esm_${i}, ${this.sizeType} ${stored.esm.bytes.length}, ${this.sizeType} ${stored.esm.raw}`;
-                return `%ScrIslandModule { ptr @sc_npm_key_${i}, ptr @sc_npm_src_${i}, ` +
+                return (`%ScrIslandModule { ptr @sc_npm_key_${i}, ptr @sc_npm_src_${i}, ` +
                     `${this.sizeType} ${stored.src.bytes.length}, ${this.sizeType} ${stored.src.raw}, ` +
-                    `i32 ${fmt[m.format]}, ${esm} }`;
+                    `i32 ${fmt[m.format]}, ${esm} }`);
             });
             out.push(`@sc_npm_modules = internal constant [${moduleRows.length} x %ScrIslandModule] [ ${moduleRows.join(", ")} ]`);
             embedded.edges.forEach((edge, i) => {
-                const parts = [["from", edge.from], ["spec", edge.specifier], ["to", edge.to]];
+                const parts = [
+                    ["from", edge.from],
+                    ["spec", edge.specifier],
+                    ["to", edge.to],
+                ];
                 for (const [part, text] of parts) {
                     const bytes = Buffer.from(text, "utf8");
                     out.push(`@sc_npm_edge_${i}_${part} = internal constant [${bytes.length + 1} x i8] c"${llBytes(bytes)}"`);
@@ -1250,7 +1287,10 @@ export class LlEmitter {
         // The exception epilogue is emitted when the entry may throw.
         const stamps = [...errorViews];
         for (const iv of this.errorIntervals) {
-            const fields = [[0, iv.pre], [1, iv.post]];
+            const fields = [
+                [0, iv.pre],
+                [1, iv.post],
+            ];
             for (const [field, value] of fields) {
                 stamps.push(`  store ${this.sizeType} ${value}, ptr getelementptr inbounds ([${RUNTIME_ERROR_CLASSES.size} x %ScrVt], ptr @scr_error_vts, i64 0, i64 ${iv.kind}, i32 ${field})${field === 1 ? ` ; ${iv.lib}` : ""}`);
             }
@@ -1306,8 +1346,12 @@ export class LlEmitter {
         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, 
         // Event-surface programs (signal/exit listeners) fill the loop's
         // nullable event hooks before %main — scr_events.c links only when
-        // this line is emitted (native-toolchain.ts gates on the same predicate).
-        ...(usesEvents ? [`  call void @scr_events_install()`] : []), ...(usesChildProcess ? [`  call void @scr_child_dyn_install()`] : []), ...(childStreamBoxes ? [`  call void @scr_child_dyn_streams_install(ptr @scr_stream_child_ops, ptr @${childStreamBoxes[0]}, ptr @${childStreamBoxes[1]})`] : []), 
+        // this line is emitted (native/executable.ts gates on the same predicate).
+        ...(usesEvents ? [`  call void @scr_events_install()`] : []), ...(usesChildProcess ? [`  call void @scr_child_dyn_install()`] : []), ...(childStreamBoxes
+            ? [
+                `  call void @scr_child_dyn_streams_install(ptr @scr_stream_child_ops, ptr @${childStreamBoxes[0]}, ptr @${childStreamBoxes[1]})`,
+            ]
+            : []), 
         // fs.watch programs fill the loop's watch hooks the same way —
         // scr_watch.c links only when this line is emitted.
         ...(usesFsWatch ? [`  call void @scr_watch_install()`] : []), ...(this.ffiHasForeignCallback ? [`  call void @scr_ffi_install()`] : []), ...(snapshotsTlsCa ? [`  call void @scr_tls_ca_install()`] : []), ...(usesFetch ? [`  call void @scr_fetch_install()`] : []), ...(embedsZlib ? [`  call void @scr_zlib_island_install()`] : []), ...(embedsNet ? [`  call void @scr_net_island_install()`] : []), ...(usesNet ? [`  call void @scr_net_install()`, `  call void @scr_net_dyn_install()`] : []), ...(usesHttp ? [`  call void @scr_http_dyn_install()`] : []), ...(usesDgram ? [`  call void @scr_dgram_install()`] : []), ...(usesHttp2 ? [`  call void @scr_http2_dyn_install()`] : []), ...(usesStream ? [`  call void @scr_stream_install()`] : []), `  call void @scr_lib_init(i32 %argc, ptr %argv)`, ...(usesIsland
@@ -1520,7 +1564,9 @@ export class LlEmitter {
         }
         for (const e of lib.exports) {
             const params = [];
-            const body = [`  call void @scr_library_entry(i1 zeroext ${autoReset ? "true" : "false"}, ptr ${symConst(e.symbol)})`];
+            const body = [
+                `  call void @scr_library_entry(i1 zeroext ${autoReset ? "true" : "false"}, ptr ${symConst(e.symbol)})`,
+            ];
             const args = [];
             if (e.inboundBytesTrap !== undefined) {
                 // The bytes-in helper's trap message: the compiler-assembled
@@ -1879,7 +1925,7 @@ export class LlEmitter {
         for (const fn of this.mod.functions) {
             if (fn.generator === undefined)
                 continue;
-            const { definitions, pack, lifted, fieldTys, ret, tr, spawnParams, argPackLines, } = this.emitArgPackAndTrampolinePrologue(fn);
+            const { definitions, pack, lifted, fieldTys, ret, tr, spawnParams, argPackLines } = this.emitArgPackAndTrampolinePrologue(fn);
             for (const line of definitions)
                 out.push(line);
             this.declare(`declare zeroext i1 @scr_exc_genret_pending()`);
@@ -1995,7 +2041,9 @@ export class LlEmitter {
             lit = { sym: `sc_lit_${this.literals.size}`, len: Buffer.byteLength(text, "utf8") };
             this.literals.set(text, lit);
         }
-        return `@${lit.sym}`;
+        const name = `@${lit.sym}`;
+        this.immortalValues.add(name);
+        return name;
     }
     /** Interned NUL-terminated C-string constant (the scr_jb_puts /
      * stringify-indent currency) — `@`-ref, first-use order. */
@@ -2025,7 +2073,9 @@ export class LlEmitter {
             sym = `sc_unit_${this.unitInstances.size}`;
             this.unitInstances.set(key, sym);
         }
-        return `@${sym}`;
+        const name = `@${sym}`;
+        this.immortalValues.add(name);
+        return name;
     }
     declare(decl) {
         this.decls.add(decl);
@@ -2041,7 +2091,7 @@ export class LlEmitter {
     }
     /** Registers an owned refcounted value on the current statement frame. */
     own(v) {
-        if (isRefCounted(v.type))
+        if (isRefCounted(v.type) && !this.immortalValues.has(v.name))
             this.currentFrame().push(v);
         return v;
     }
@@ -2053,7 +2103,7 @@ export class LlEmitter {
     }
     /** Strike a refcounted temp from its frame: ownership is being moved. */
     moveTemp(v) {
-        if (!isRefCounted(v.type))
+        if (!isRefCounted(v.type) || this.immortalValues.has(v.name))
             return;
         for (let i = this.frames.length - 1; i >= 0; i--) {
             const idx = this.frames[i].findIndex((e) => e.name === v.name);
@@ -2067,6 +2117,8 @@ export class LlEmitter {
     /** The retained (+1) read of a refcounted value — type-directed through
      * the `_v` table (immortals skip, exactly the C retain calls). */
     retainValue(name, type) {
+        if (this.immortalValues.has(name))
+            return name;
         const t = this.B.tmp();
         this.B.line(`${t} = call ptr ${retainSym(this.shapeHost, type)}(ptr ${name})`);
         return t;
@@ -2074,6 +2126,8 @@ export class LlEmitter {
     /** The release call for one owned refcounted value — type-directed like
      * releaseCallC (all runtime releases are NULL-tolerant). */
     releaseValue(name, type) {
+        if (this.immortalValues.has(name))
+            return;
         this.B.line(`call void ${releaseSym(this.shapeHost, type)}(ptr ${name})`);
     }
     releaseFrame(frame) {
@@ -2167,9 +2221,14 @@ export class LlEmitter {
         }
         else {
             const t = this.currentReturnType;
-            terminator = t.kind === "void" ? "ret void"
-                : t.kind === "f64" || t.kind === "date" ? `ret double ${f64Lit(0)}`
-                    : t.kind === "bool" ? "ret i1 false" : "ret ptr null";
+            terminator =
+                t.kind === "void"
+                    ? "ret void"
+                    : t.kind === "f64" || t.kind === "date"
+                        ? `ret double ${f64Lit(0)}`
+                        : t.kind === "bool"
+                            ? "ret i1 false"
+                            : "ret ptr null";
         }
         // Copy the entries now: later declarations extend these lexical scopes.
         // Release order and the handler are part of the shared block's identity.
@@ -2240,7 +2299,10 @@ export class LlEmitter {
             this.declare(`declare void @scr_throw_obj(ptr, ptr, ptr, ptr)`);
             B.line(`call void @scr_throw_obj(ptr ${v.name}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${traceArg(this.shapeHost, t)})`);
         }
-        else if (t.kind === "symbol" || t.kind === "bigint" || t.kind === "func" || t.kind === "classval") {
+        else if (t.kind === "symbol" ||
+            t.kind === "bigint" ||
+            t.kind === "func" ||
+            t.kind === "classval") {
             const rc = vAdapters(this.shapeHost, t);
             this.declare(`declare void @scr_throw_primitive_ref(ptr, ptr, ptr, ptr)`);
             B.line(`call void @scr_throw_primitive_ref(ptr ${v.name}, ptr ${rc.retain}, ptr ${rc.release}, ptr null)`);
@@ -2911,21 +2973,30 @@ export class LlEmitter {
         this.unwindCleanups.clear();
         this.jumpTargets = [];
         this.currentLocals = new Map(fn.locals.map((l) => [l.id, l]));
+        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();
-        const borrowedParameterIndexes = this.callLifetimes.parameters.get(fn.name);
+        this.stableCallBindings = this.callLifetimes.bindings.get(fn.name) ?? new Set();
+        const borrowedParameterIndexes = this.callLifetimes.borrowed.get(fn.name);
         if (borrowedParameterIndexes) {
             for (const index of borrowedParameterIndexes)
                 this.borrowedParameters.add(fn.params[index].localId);
         }
         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.integerViews.clear();
         this.fieldPointerTags.clear();
         this.integerArrayBindings.clear();
-        this.localArrayReads = findLocalArrayReads(fn, this.fnByName, this.unionsById, this.arrayPreservingFunctions, this.callLifetimes, this.optionalArrayReads);
-        this.callArrayReads = findCallArrayReads(fn, this.optionalArrayReads, this.arrayPreservingFunctions, this.callLifetimes);
+        this.localArrayReads = findLocalArrayReads(fn, this.fnByName, this.unionsById, this.referenceEffects.functions, this.callLifetimes, this.optionalArrayReads);
+        this.callArrayReads = findCallArrayReads(fn, this.optionalArrayReads, this.referenceEffects.functions, this.callLifetimes);
         this.mapReadLifetimes = findMapReadLifetimes(fn, this.unionsById, this.callLifetimes);
         this.localStackUnions = findLocalStackUnions(fn, this.callLifetimes, this.unionsById);
-        this.integerRanges = analyzeIntegerRanges(fn);
+        this.localUnionStorageProofs = findLocalUnionStorage(fn, this.callLifetimes, this.unionsById);
+        this.localUnionStorage = new Map();
+        this.integerRanges = analyzeIntegerRanges(numericFn);
+        this.bytesBounds = findBytesBounds(numericFn, this.integerRanges);
         this.chainSlots.clear();
         this.finallyStack = [];
         this.tryStack = [];
@@ -2967,6 +3038,20 @@ export class LlEmitter {
             };
         }
         const paramIds = new Set(fn.params.map((p) => p.localId));
+        if (this.debug === null) {
+            for (const id of findIntegerViews(numericFn)) {
+                const slot = B.slot();
+                B.entryAllocas.push(`${slot} = alloca i32 ; integer view ${this.numericLocals.get(id).name}`);
+                this.integerViews.set(id, slot);
+            }
+        }
+        for (const global of initializerBindings) {
+            if (!this.integerViews.has(global.id))
+                continue;
+            const value = B.tmp();
+            B.line(`${value} = load double, ptr @${mangleGlobal(global.id)}`);
+            this.storeIntegerView(global.id, { name: value, type: global.type });
+        }
         for (const local of fn.locals) {
             // Boxed locals' slots hold their capture BOX (a ptr); captured
             // (env-borrowed) locals bind the incoming box below. A caught-typed
@@ -3016,7 +3101,7 @@ 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 = [];
-        const borrowed = this.callLifetimes.parameters.get(fn.name);
+        const borrowed = this.callLifetimes.borrowed.get(fn.name);
         for (const [index, p] of fn.params.entries()) {
             const local = this.currentLocals.get(p.localId);
             const slot = `%${mangleLocal(p.localId)}`;
@@ -3029,6 +3114,7 @@ export class LlEmitter {
                 continue;
             }
             B.line(`store ${this.llType(p.type)} %p_${mangleLocal(p.localId)}, ptr ${slot}`);
+            this.storeIntegerView(p.localId, { name: `%p_${mangleLocal(p.localId)}`, type: p.type });
             if (isRefCounted(p.type) && !borrowed?.has(index))
                 fnScope.push({ slot, type: p.type });
         }
@@ -3132,17 +3218,24 @@ export class LlEmitter {
         B.terminate(ret === "void" ? "ret void" : `ret ${ret} %result`);
         return `define internal ${ret} @${mangleFunction(fn.name)}(${params.join(", ")}) ${FN_ATTRS} {\n${B.render()}\n}`;
     }
-    /** A local immutable binding keeps its value alive while later arguments
-     * and the callee execute. Global, captured, TDZ and mutable bindings need
-     * an owned snapshot, even when the callee only inspects the value. */
+    /** A local stable binding keeps its value alive while later arguments
+     * and the callee execute. A proven local union box cannot escape or be
+     * rebound during a call; its independent payload owner keeps it alive.
+     * Other writable bindings need an owned snapshot. */
     canBorrowCallArgument(value) {
         if (value.kind === "strLit")
             return true;
         if (value.kind !== "varRef")
             return false;
         const binding = this.binding(value.localId);
-        return binding.kind === "local" && binding.local !== undefined &&
-            (!binding.local.mutable || this.borrowedParameters.has(value.localId)) && !binding.local.boxed && !binding.local.tdz;
+        return (binding.kind === "local" &&
+            binding.local !== undefined &&
+            (!binding.local.mutable ||
+                this.stableCallBindings.has(value.localId) ||
+                this.borrowedParameters.has(value.localId) ||
+                this.localUnionStorage.has(value.localId)) &&
+            !binding.local.boxed &&
+            !binding.local.tdz);
     }
     // ── statements ──────────────────────────────────────────────────────────
     emitStmts(stmts) {
@@ -3192,7 +3285,10 @@ export class LlEmitter {
                     B.line(`store ptr ${union.value.name}, ptr ${b.slot}`);
                     if (union.payload) {
                         this.moveTemp(union.payload);
-                        this.scopes[this.scopes.length - 1].push({ slot: union.payloadSlot, type: union.payload.type });
+                        this.scopes[this.scopes.length - 1].push({
+                            slot: union.payloadSlot,
+                            type: union.payload.type,
+                        });
                     }
                     break;
                 }
@@ -3211,6 +3307,19 @@ export class LlEmitter {
                         this.scopes[this.scopes.length - 1].push(result.owner);
                     break;
                 }
+                const localStorage = this.localUnionStorageProofs.get(s.localId);
+                if (localStorage && s.init) {
+                    const storage = allocateLocalUnion(this, localStorage);
+                    this.localUnionStorage.set(s.localId, storage);
+                    storeLocalUnion(this, storage, s.init);
+                    B.line(`store ptr ${storage.box}, ptr ${b.slot}`);
+                    if (storage.owner && storage.ownerType)
+                        this.scopes[this.scopes.length - 1].push({
+                            slot: storage.owner,
+                            type: storage.ownerType,
+                        });
+                    break;
+                }
                 if (b.kind === "boxed") {
                     // Box FIRST, then evaluate the initializer: a named function
                     // expression's closure captures this box during init evaluation.
@@ -3248,15 +3357,35 @@ export class LlEmitter {
                     }
                     break;
                 }
+                // A lexical const 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)) {
+                    const v = this.emitReadReceiver(s.init);
+                    B.line(`store ptr ${v.name}, ptr ${b.slot}`);
+                    break;
+                }
                 const v = this.emitExpr(s.init);
                 this.moveTemp(v);
                 B.line(`store ${this.llType(b.type)} ${v.name}, ptr ${b.slot}`);
+                this.storeIntegerView(s.localId, v, s.init);
                 if (isRefCounted(b.type)) {
                     this.scopes[this.scopes.length - 1].push({ slot: b.slot, type: b.type });
                 }
                 break;
             }
             case "assign": {
+                const localStorage = this.localUnionStorage.get(s.localId);
+                if (localStorage) {
+                    storeLocalUnion(this, localStorage, s.value);
+                    break;
+                }
                 const concat = s.value;
                 const suffix = matchStringSelfConcat(s.localId, concat);
                 if (suffix && concat.kind === "strConcat") {
@@ -3281,6 +3410,7 @@ export class LlEmitter {
                     this.releaseValue(old, b.type);
                 }
                 B.line(`store ${this.llType(b.type)} ${v.name}, ptr ${b.slot}`);
+                this.storeIntegerView(s.localId, v, s.value);
                 break;
             }
             case "exprStmt":
@@ -3290,7 +3420,7 @@ export class LlEmitter {
                 // Evaluation order matches JS: array, index, then value. Ownership
                 // of a refcounted value moves into the array (the runtime releases
                 // the replaced element itself).
-                const arr = this.emitExpr(s.arr);
+                const arr = emitBorrowedInput(this, s.arr);
                 const idx = this.emitExpr(s.index);
                 const v = this.emitExpr(s.value);
                 if (s.arr.type.kind !== "array")
@@ -3304,7 +3434,7 @@ export class LlEmitter {
                 break;
             }
             case "arraySetLength": {
-                const arr = this.emitExpr(s.arr);
+                const arr = emitBorrowedInput(this, s.arr);
                 const length = this.emitExpr(s.length);
                 if (s.arr.type.kind !== "array")
                     throw new InternalCompilerError("llvm emitter bug: arraySetLength on non-array");
@@ -3315,7 +3445,7 @@ export class LlEmitter {
             }
             case "arraySetUndefined":
             case "arrayDelete": {
-                const arr = this.emitExpr(s.arr);
+                const arr = emitBorrowedInput(this, s.arr);
                 const idx = this.emitExpr(s.index);
                 if (s.arr.type.kind !== "array")
                     throw new InternalCompilerError(`llvm emitter bug: ${s.kind} on non-array`);
@@ -3334,12 +3464,11 @@ export class LlEmitter {
                 // IrBytesElem is static, so never rediscover it through the
                 // generic runtime switch in a hot loop.
                 const arr = this.emitStableReceiver(s.arr, [s.index, s.value]);
-                const integerIndex = this.emitIntegerLoopIndex(s.index);
-                const idx = integerIndex ?? this.emitExpr(s.index).name;
+                const idx = this.emitExpr(s.index);
                 const v = this.emitExpr(s.value);
                 if (s.arr.type.kind !== "bytes")
                     throw new InternalCompilerError("llvm emitter bug: bytesSet on non-bytes");
-                this.emitBytesSet(s.arr.type.elem, arr.name, idx, v.name, integerIndex !== null);
+                this.emitBytesSet(s.arr.type.elem, arr.name, idx, v, s.index, s.value, this.bytesBounds.has(s));
                 break;
             }
             case "fieldSet":
@@ -3349,7 +3478,9 @@ 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 obj = isRefCounted(s.value.type) ? this.emitExpr(s.obj) : this.emitStableReceiver(s.obj, [s.value]);
+                const obj = isRefCounted(s.value.type)
+                    ? this.emitExpr(s.obj)
+                    : this.emitStableReceiver(s.obj, [s.value]);
                 const v = this.emitExpr(s.value);
                 const { ptr, type } = s.kind === "fieldSet"
                     ? this.classFieldPtr(obj.name, s.className, s.field)
@@ -3364,7 +3495,9 @@ export class LlEmitter {
                 else {
                     this.storeField(ptr, type, v.name);
                 }
-                if (s.kind === "fieldSet" && s.field === "name" && this.classMeta.get(s.className)?.root.def.name === "%Error") {
+                if (s.kind === "fieldSet" &&
+                    s.field === "name" &&
+                    this.classMeta.get(s.className)?.root.def.name === "%Error") {
                     const present = this.classFieldPtr(obj.name, s.className, "%namePresent").ptr;
                     const enumerable = this.classFieldPtr(obj.name, s.className, "%nameEnumerable").ptr;
                     const wasPresent = B.tmp(), wasEnumerable = B.tmp(), isPresent = B.tmp(), nextEnumerable = B.tmp();
@@ -3610,10 +3743,33 @@ export class LlEmitter {
             case "for": {
                 // The init's scope wraps the whole loop (break/continue must NOT
                 // release it — scopeDepth captured after the push, C parity).
-                const integerArrayLoop = this.debug === null ? matchIntegerArrayForLoop(s, this.currentLocals, this.integerArrayBindings) : null;
-                const integerLoop = integerArrayLoop ?? (this.debug === null ? matchIntegerBytesForLoop(s, this.currentLocals) : null);
+                const integerArrayLoop = this.debug === null
+                    ? matchIntegerArrayForLoop(s, this.currentLocals, this.integerArrayBindings)
+                    : null;
+                const integerLoop = integerArrayLoop ??
+                    (this.debug === null ? matchIntegerBytesForLoop(s, this.numericLocals) : null);
+                const countedLoop = !integerLoop && this.countedLoopsEnabled
+                    ? matchIntegerCountedForLoop(s, this.numericLocals, this.integerRanges)
+                    : null;
+                let countedJoin = null;
+                if (countedLoop?.guarded) {
+                    const bound = this.emitExpr(countedLoop.limit);
+                    const safe = B.tmp();
+                    const fast = B.newLabel("counted.fast");
+                    const slow = B.newLabel("counted.slow");
+                    countedJoin = B.newLabel("counted.done");
+                    B.line(`${safe} = fcmp ${countedLoop.step > 0 ? "ole" : "oge"} double ${bound.name}, ${f64Lit(countedLoop.guardLimit)}`);
+                    B.condBr(safe, fast, slow);
+                    B.startBlock(slow);
+                    this.countedLoopsEnabled = false;
+                    this.emitStmt(s);
+                    this.countedLoopsEnabled = true;
+                    B.br(countedJoin);
+                    B.startBlock(fast);
+                }
                 this.scopes.push([]);
                 let integerSlot = null;
+                let countedLimit = null;
                 if (integerLoop) {
                     integerSlot = B.slot();
                     B.entryAllocas.push(`${integerSlot} = alloca ${this.sizeType} ; integer induction ${this.currentLocals.get(integerLoop.localId).name}`);
@@ -3625,7 +3781,26 @@ export class LlEmitter {
                         this.integerArrayBindings.add(integerLoop.localId);
                     }
                     B.line(`store ${this.sizeType} ${start}, ptr ${integerSlot}`);
-                    this.integerLoopBindings.set(integerLoop.localId, integerSlot);
+                    this.integerLoopBindings.set(integerLoop.localId, {
+                        slot: integerSlot,
+                        type: this.sizeType,
+                        range: { min: 0, max: integerArrayLoop ? 4294967294 : Number.MAX_SAFE_INTEGER - 1 },
+                    });
+                }
+                else if (countedLoop) {
+                    integerSlot = B.slot();
+                    B.entryAllocas.push(`${integerSlot} = alloca i64 ; integer induction ${this.currentLocals.get(countedLoop.localId).name}`);
+                    const startNumber = this.emitExpr(countedLoop.start);
+                    const start = B.tmp();
+                    B.line(`${start} = fptosi double ${startNumber.name} to i64`);
+                    B.line(`store i64 ${start}, ptr ${integerSlot}`);
+                    this.integerLoopBindings.set(countedLoop.localId, {
+                        slot: integerSlot,
+                        type: "i64",
+                        signed: true,
+                        range: countedLoop.range,
+                    });
+                    countedLimit = emitCountedLoopLimit(this, countedLoop);
                 }
                 else if (s.init) {
                     // A multi-declarator head shares the loop's scope. Emitting its
@@ -3680,6 +3855,13 @@ export class LlEmitter {
                     B.line(`${inBounds} = icmp ult ${this.sizeType} ${index}, ${len}`);
                     B.condBr(inBounds, lb, le);
                 }
+                else if (countedLoop && integerSlot && countedLimit) {
+                    const index = B.tmp();
+                    const inBounds = B.tmp();
+                    B.line(`${index} = load i64, ptr ${integerSlot}`);
+                    B.line(`${inBounds} = icmp ${countedLoop.step > 0 ? "slt" : "sgt"} i64 ${index}, ${countedLimit}`);
+                    B.condBr(inBounds, lb, le);
+                }
                 else if (s.cond)
                     B.condBr(this.emitCondition(s.cond), lb, le);
                 else
@@ -3707,6 +3889,13 @@ export class LlEmitter {
                         B.line(`${next} = add nuw ${this.sizeType} ${old}, 1`);
                         B.line(`store ${this.sizeType} ${next}, ptr ${integerSlot}`);
                     }
+                    else if (countedLoop && integerSlot) {
+                        const old = B.tmp();
+                        const next = B.tmp();
+                        B.line(`${old} = load i64, ptr ${integerSlot}`);
+                        B.line(`${next} = add nsw i64 ${old}, ${countedLoop.step}`);
+                        B.line(`store i64 ${next}, ptr ${integerSlot}`);
+                    }
                     else if (s.update)
                         this.emitStmt(s.update);
                     B.br(lc);
@@ -3715,8 +3904,14 @@ export class LlEmitter {
                 this.releaseScope(this.scopes.pop());
                 if (integerLoop)
                     this.integerLoopBindings.delete(integerLoop.localId);
+                if (countedLoop)
+                    this.integerLoopBindings.delete(countedLoop.localId);
                 if (integerArrayLoop)
                     this.integerArrayBindings.delete(integerArrayLoop.localId);
+                if (countedJoin) {
+                    B.br(countedJoin);
+                    B.startBlock(countedJoin);
+                }
                 break;
             }
             case "forOf": {
@@ -3941,7 +4136,10 @@ export class LlEmitter {
         const frame = this.frames.pop();
         // return/throw already released their frames on the jump path; the
         // fall-through releases after them would be dead double-release code.
-        if (s.kind !== "return" && s.kind !== "throw" && s.kind !== "rethrow" && s.kind !== "runtimeFence") {
+        if (s.kind !== "return" &&
+            s.kind !== "throw" &&
+            s.kind !== "rethrow" &&
+            s.kind !== "runtimeFence") {
             this.releaseFrame(frame);
         }
     }
@@ -4107,7 +4305,8 @@ export class LlEmitter {
     }
     /** JS-exact switch: lazily evaluated, arbitrary-expression case tests in
      * source order, bodies falling through in source order until a break —
-     * A chain of conditional branches. All case bodies
+     * Literal-only tests can use native dispatch; other tests keep a chain
+     * of conditional branches. All case bodies
      * share ONE scope; because dispatch can jump PAST a varDecl into a later
      * case, refcounted/boxed case-body locals are NULL-reset up front and
      * the scope-exit releases rely on NULL tolerance. */
@@ -4134,33 +4333,34 @@ export class LlEmitter {
         }
         const end = B.newLabel("sw.e");
         const caseLabels = s.cases.map(() => B.newLabel("sw.c"));
-        let defaultIdx = -1;
-        s.cases.forEach((c, i) => {
-            if (c.test === null) {
-                defaultIdx = i;
-                return;
-            }
-            // Lazy source-order test evaluation (a test after the match never
-            // runs). Each test's temps release right after its comparison.
-            this.frames.push([]);
-            const t = this.emitExpr(c.test);
-            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})`);
-            }
-            else if (c.test.type.kind === "bool") {
-                B.line(`${hit} = icmp eq i1 ${disc.name}, ${t.name}`);
-            }
-            else {
-                B.line(`${hit} = fcmp oeq double ${disc.name}, ${t.name}`);
-            }
-            this.releaseFrame(this.frames.pop());
-            const next = B.newLabel("sw.t");
-            B.condBr(hit, caseLabels[i], next);
-            B.startBlock(next);
-        });
-        B.br(defaultIdx >= 0 ? caseLabels[defaultIdx] : end);
+        const defaultIdx = s.cases.findIndex((c) => c.test === null);
+        const fallback = defaultIdx >= 0 ? caseLabels[defaultIdx] : end;
+        if (!emitLiteralSwitch(this, disc, s.cases, caseLabels, fallback)) {
+            s.cases.forEach((c, i) => {
+                if (c.test === null)
+                    return;
+                // Lazy source-order test evaluation (a test after the match never
+                // runs). Each test's temps release right after its comparison.
+                this.frames.push([]);
+                const t = this.emitExpr(c.test);
+                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})`);
+                }
+                else if (c.test.type.kind === "bool") {
+                    B.line(`${hit} = icmp eq i1 ${disc.name}, ${t.name}`);
+                }
+                else {
+                    B.line(`${hit} = fcmp oeq double ${disc.name}, ${t.name}`);
+                }
+                this.releaseFrame(this.frames.pop());
+                const next = B.newLabel("sw.t");
+                B.condBr(hit, caseLabels[i], next);
+                B.startBlock(next);
+            });
+            B.br(fallback);
+        }
         this.jumpTargets.push({
             kind: "switch",
             brkLabel: end,
@@ -4202,12 +4402,15 @@ export class LlEmitter {
      * branch and moves the result into `slot`: the chosen value's ownership
      * transfers, every other temp the arm allocated releases inside the
      * branch. The shared core of ternary/logical. */
-    emitBranchInto(slot, expr) {
+    emitBranchInto(slot, expr, integerSlot) {
         this.frames.push([]);
         const v = this.emitExpr(expr);
         this.moveTemp(v);
         this.B.line(`store ${this.llType(expr.type)} ${v.name}, ptr ${slot}`);
+        if (integerSlot !== undefined && v.uint32 !== undefined)
+            this.B.line(`store i32 ${v.uint32}, ptr ${integerSlot}`);
         this.releaseFrame(this.frames.pop());
+        return v.uint32 !== undefined;
     }
     // ── expressions ─────────────────────────────────────────────────────────
     emitLiteralExpr(e) {
@@ -4221,7 +4424,12 @@ export class LlEmitter {
             this.scopes.push([]);
             const result = emitBorrowedFieldSequence(this, e) ?? emitOperatorExpr(this, e);
             for (const local of this.scopes.pop()) {
-                this.currentFrame().push({ name: local.slot, type: local.type, slot: true, ...(local.boxed ? { boxed: true } : {}) });
+                this.currentFrame().push({
+                    name: local.slot,
+                    type: local.type,
+                    slot: true,
+                    ...(local.boxed ? { boxed: true } : {}),
+                });
             }
             return result;
         }
@@ -4319,6 +4527,15 @@ export class LlEmitter {
             this.B.line(`${value} = load ptr, ptr ${binding.slot}`);
             return { name: value, type: e.type };
         }
+        const read = matchMapRead(e, this.unionsById);
+        if (read) {
+            const result = emitStackMapRead(this, read);
+            if (result.owner)
+                this.ownSlot(result.owner.slot, result.owner.type);
+            return result.value;
+        }
+        if (canStackUnion(e, this.unionsById))
+            return emitStackUnion(this, e).value;
         if (e.kind === "unionNarrow") {
             const union = this.emitReadReceiver(e.value);
             return { name: this.unionPeek(union.name), type: e.type };
@@ -4339,7 +4556,10 @@ export class LlEmitter {
             B.entryAllocas.push(`${slot} = alloca ptr`);
             const yes = B.newLabel("read.then"), no = B.newLabel("read.else"), join = B.newLabel("read.join");
             B.condBr(cond.name, yes, no);
-            for (const [label, value] of [[yes, e.then], [no, e.else_]]) {
+            for (const [label, value] of [
+                [yes, e.then],
+                [no, e.else_],
+            ]) {
                 B.startBlock(label);
                 this.frames.push([]);
                 const result = this.emitReadReceiver(value);
@@ -4356,15 +4576,21 @@ export class LlEmitter {
     }
     canBorrowReceiver(e) {
         switch (e.kind) {
-            case "varRef": return this.binding(e.localId).kind !== "boxed";
-            case "unionNarrow": return this.canBorrowReceiver(e.value);
+            case "varRef":
+                return this.binding(e.localId).kind !== "boxed";
+            case "unionNarrow":
+                return this.canBorrowReceiver(e.value);
             case "fieldGet":
-            case "recordGet": return this.canBorrowReceiver(e.obj);
-            case "ternary": return this.canBorrowReceiver(e.then) && this.canBorrowReceiver(e.else_);
+            case "recordGet":
+                return this.canBorrowReceiver(e.obj);
+            case "ternary":
+                return this.canBorrowReceiver(e.then) && this.canBorrowReceiver(e.else_);
             // The runtime always sets a pending exception; its unreachable
             // typed dummy is null and owns no receiver.
-            case "libCall": return e.fn === "error.nodeThrow";
-            default: return false;
+            case "libCall":
+                return e.fn === "error.nodeThrow";
+            default:
+                return false;
         }
     }
     emitExpr(e) {
@@ -4484,8 +4710,8 @@ export class LlEmitter {
     emitIntegerLoopIndex(expr) {
         return emitIntegerLoopIndex(this, expr);
     }
-    emitBytesIndex(receiver, index, integerIndex = false) {
-        return emitBytesIndex(this, receiver, index, integerIndex);
+    emitBytesIndex(receiver, index, expr, inBounds = false) {
+        return emitBytesIndex(this, receiver, index, expr, undefined, inBounds);
     }
     emitBytesData(receiver) {
         return emitBytesData(this, receiver);
@@ -4493,14 +4719,21 @@ export class LlEmitter {
     emitBytesLength(elem, receiver, bytes) {
         return emitBytesLength(this, elem, receiver, bytes);
     }
-    emitBytesGet(elem, receiver, index, integerIndex = false) {
-        return emitBytesGet(this, elem, receiver, index, integerIndex);
+    emitBytesGet(elem, receiver, index, expr, inBounds = false) {
+        return emitBytesGet(this, elem, receiver, index, expr, inBounds);
+    }
+    emitToUint32(value, expr, uint32) {
+        return emitToUint32(this, value, expr, uint32);
     }
-    emitToUint32(value, expr) {
-        return emitToUint32(this, value, expr);
+    storeIntegerView(localId, value, expr) {
+        const slot = this.integerViews.get(localId);
+        if (slot === undefined)
+            return;
+        const integer = this.emitToUint32(value.name, expr, value.uint32);
+        this.B.line(`store i32 ${integer}, ptr ${slot}`);
     }
-    emitBytesSet(elem, receiver, index, value, integerIndex = false) {
-        return emitBytesSet(this, elem, receiver, index, value, integerIndex);
+    emitBytesSet(elem, receiver, index, value, indexExpr, expr, inBounds = false) {
+        return emitBytesSet(this, elem, receiver, index, value, indexExpr, expr, inBounds);
     }
     emitBytesIntrinsic(e) {
         return emitBytesIntrinsic(this, e);