@scriptc/compiler 0.4.1 → 0.4.3

package/dist/backend/llvm/emitter.js

@@ -1,3 +1,4 @@
+import { relieveHeapPressure } from "../../heap-pressure.js";
 import { wasmBoundsChecks } from "./wasm-modules.js";
 import { jsTruthy } from "./jsval.js";
 import { JsIcSites } from "../../ir/js-ic.js";
@@ -12,20 +13,23 @@ import { createHash } from "node:crypto";
 import { endsWithJump, matchFieldSelfConcat, readsArraySlot, streamTypedRefEligible, undefinedArmTag, } from "../../ir/analysis.js";
 import { loopTestsEveryIteration } from "../loop-polls.js";
 import { isDynTypedRefType, isRefCounted, isUnitType, POINTER_KINDS, RUNTIME_EMITTER_CLASS, RUNTIME_EVENT_CLASS, RUNTIME_EVENT_TARGET_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, typeEquals, typeKey, VOID, classJsName, } from "../../ir/ir.js";
-import { moduleRuntimeFeatures, moduleUsesDynBuiltinStream, moduleUsesMockTimers, } from "../../ir/runtime-features.js";
+import { moduleRuntimeFeatures } from "../../ir/runtime-features.js";
 import { captureFreeFunctions, observesStacks } from "../stack-observations.js";
-import {} from "./dense-array-loops.js";
 import { findInitializedByteLoopBindings } from "./byte-windows.js";
 import { matchBytesLoopVersion } from "./bytes-loop-versions.js";
 import { globalSlotAlias } from "./bytes-alias.js";
 import { materializeSplitPiece, } from "./split-loops.js";
 import { scalarizeNumericRecords } from "../../ir/scalar-records.js";
-import { addRecordResultEntries } from "./record-results.js";
+import { addRecordResultEntries, resultEntryName } from "./record-results.js";
 import { specializeCallbackCalls } from "../../ir/callback-specialization.js";
+import { EmitJournal, registerReplay, renameChunk, replayJournal, } from "./emit-journal.js";
 import { specializeNumericCalls } from "../../ir/numeric-call-specialization.js";
+import { versionLoopBoundParameters } from "../../ir/parameter-versions.js";
+import { allocatedLiteral, fillAllocationLength, int32ArrayKey, selectInt32Arrays, } from "../../ir/int32-arrays.js";
 import { everyExpr, everyExprChild, everyStmtChild, everyStmtList } from "../../ir/traverse.js";
-import { INT32_RANGE } from "../../ir/integer-ranges.js";
+import { INT32_RANGE, withinInt32, } from "../../ir/integer-ranges.js";
 import { unshareNodes } from "../../ir/unshare.js";
+import { runPairedWhileLoopsAsFor } from "../../ir/paired-while-loops.js";
 import { copyStableCaptures } from "../../ir/capture-values.js";
 import { resolveSelfCaptures } from "../../ir/self-captures.js";
 import { analyzeInt32Slots, dynamicFieldStores } from "../../ir/int32-slots.js";
@@ -34,10 +38,11 @@ import { foldConstantGlobals } from "../../ir/constant-globals.js";
 import { dropUnwrittenPropertyBags } from "../../ir/property-bags.js";
 import { freezeInitOnlyGlobals } from "../../ir/init-only-globals.js";
 import { hoistFinalFieldReads } from "../../ir/field-values.js";
+import { holdCharLocalsAsUnits } from "../../ir/char-unit-locals.js";
 import { findInt32Abis, INT32_ABI_SUFFIX, SCALAR_UNION_DUMMY, SCALAR_UNION_RESULT, } from "./int32-abi.js";
 import {} from "./int32-locals.js";
 import { findIntegerClones, NO_INTEGER_CLONES } from "./integer-clones.js";
-import { exactInteger, narrowInteger } from "./integer-values.js";
+import { exactInteger, narrowInteger, widenInteger } from "./integer-values.js";
 import { findInitializerBindings } from "../../ir/initializer-bindings.js";
 import { findConstantNumericTables } from "../../ir/constant-tables.js";
 import { allocateFfiCallbackAdapters, hasForeignFfiCallback, hasRetainedFfiCallback, } from "../ffi-callbacks.js";
@@ -51,12 +56,13 @@ import { NullableRefFields } from "./nullable-fields.js";
 import { InlineUnionFields, loadInlineUnion, presentBits, stackUnionBox, storeInlineUnion, unionBoxBits, } from "./inline-unions.js";
 import { OptionalArrayReads } from "./local-array-reads.js";
 import { CheckedNarrows } from "./checked-narrows.js";
-import { emitDenseArraySet, emitDenseSlotUnlink } from "./dense-array-access.js";
+import { emitDenseArraySet, emitDenseSlotUnlink, SCR_ELEM_I32, } from "./dense-array-access.js";
 import { matchMapRead } from "./map-read-lifetimes.js";
 import {} from "./map-entry-fusion.js";
 import { emitBorrowedFieldSequence, guardedValue } from "./borrowed-receivers.js";
 import { emitBorrowedInputs } from "./borrowed-inputs.js";
 import { findWalkBorrows } from "./walk-borrows.js";
+import { IrNodeIndex } from "../../ir/node-index.js";
 import { lastUseRead } from "./local-extents.js";
 import { findReboundParameters } from "./rebound-parameters.js";
 import { ReferenceEffects } from "./reference-effects.js";
@@ -68,7 +74,7 @@ import { AmbientReceiverReaders, findConstantCallbacks } from "./constant-callba
 import { findLentStringParameters, } from "./string-slices.js";
 import { LazyCaptures } from "./lazy-captures.js";
 import { StackCaptures } from "./stack-captures.js";
-import { emitFieldAbsentTest, f64Lit } from "./common.js";
+import { emitFieldAbsentTest, f64Lit, SCR_ARR_FIELD, SCR_ARR_FROZEN } from "./common.js";
 import { ffiExtendsNarrowIntegers } from "../targets.js";
 import { emitLiteralExpr, emitOperatorExpr, emitStringExpr, emitContainerExpr, emitRecordExpr, } from "./expr-primitives.js";
 import { emitControlExpr } from "./expr-control.js";
@@ -77,8 +83,10 @@ import { emitDynamicExpr } from "./expr-dynamic.js";
 import { emitIntrinsicExpr, emitSerializationExpr, emitAsyncExpr } from "./expr-async.js";
 import { PublishWalkers } from "./publish.js";
 import { computeImmutableFields, stableGlobals } from "../immutability.js";
+import { computeCycleMutability, hierarchyUnitOfClass } from "../cycle-mutability.js";
 import { computePublishedTypes } from "../publication.js";
 import { emitExpr } from "./expr-dispatch.js";
+import { LOOPS } from "./loop-state.js";
 import { dynKind, raceAdapterFor, genResultThunkFor, childExitThunkFor, childExitSignalThunkFor, childDataDynThunkFor, childDataThunkFor, execFileThunkFor, ipcMessageThunkFor, ipcSendThunkFor, emitterFixedAdapter, emitterOnceAdapter, wrapEmitterListener, unwrapNullableClosure, closeBindThunkFor, closeOverrideWrapFor, } from "./expr-callbacks.js";
 import { streamDataAdapter, streamDoneFnFor, cryptoBytesThunkFor, cryptoIntThunkFor, 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";
@@ -90,7 +98,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, classMembershipIntervals, classFieldIndex, classPreLines, classStructSym, programLifetimeClass, } from "./classes.js";
+import { assignCompactLayouts, buildClassGraph, classFieldTypes, classMembershipIntervals, classFieldIndex, compactRefLoadLines, compactRefStoreLines, classPreLines, classStructSym, programLifetimeClass, } from "./classes.js";
 import { LifetimeRegions, REGION_TYPES } from "./regions.js";
 import { LlDyn, recordDynKeepsIdentity } from "./dyn.js";
 import { VirtualBorrows } from "./virtual-borrows.js";
@@ -99,7 +107,7 @@ import { LlWalkers } from "./walkers.js";
 import { isObjectArm, NULLABLE_ABSENT, NULLABLE_NULL, NullableUnions } from "./nullable-unions.js";
 import { emitNullablePresent, emitUnionPeek, emitUnionTag } from "./union-repr.js";
 import { emitConcatInputs, emitMixedConcat, numberPart, stringParts, } from "./string-construction.js";
-import { arrNewCall, boxAccess, boxNewCall, boxReleaseSym, computeTraced, emitInlineRcHelpers, emitNullableRetainWrappers, emitShapeUnionHelpers, FN_ATTRS, inlineRcDecls, llFieldType, mapFlagsOffset, releaseSym, retainSym, traceArg, vAdapters, } from "./shapes.js";
+import { arrNewCall, boxAccess, elemAccess, boxNewCall, boxReleaseSym, computeTraced, emitInlineRcHelpers, emitNullableRetainWrappers, emitShapeUnionHelpers, FN_ATTRS, inlineRcDecls, llFieldType, mapFlagsOffset, releaseSym, retainSym, traceArg, vAdapters, } from "./shapes.js";
 import { INLINE_LITERAL_BYTES } from "./string-literal-equality.js";
 import { emitFfiCallbackDefs, emitLibDefs, emitModuleParts, emitParts, helperDefs, } from "./emit-module.js";
 import { emitLoopCopies, emitSpeculativeWrite, emitStmtBody, emitStringSelfConcatAssign, emitSwitch, emitTryCatch, } from "./emit-statements.js";
@@ -131,21 +139,66 @@ export function ffiCallbackDummyLl(callback) {
             return "i32 0";
     }
 }
-export function emitLlvmModule(input, options = {}) {
+/** LlvmTargetOptions.lowRegion for an executable: Linux targets without
+ * sanitizers, whose address space below 32 GiB is free (ASan keeps its
+ * shadow memory there; other systems map their own images and libraries
+ * there). `platform` is a target platform (`linux`, `darwin`, `win32`,
+ * `wasi`). */
+export function lowRegionTarget(platform, sanitize) {
+    return platform === "linux" && !sanitize;
+}
+/** Function versions on loop-bounding number parameters
+ * (ir/parameter-versions.ts). Library builds have no int32 entries, and a
+ * module that observes call stacks could see the version's frame. */
+function versionParameters(mod) {
+    if (mod.lib !== undefined || observesStacks(mod))
+        return mod;
+    return versionLoopBoundParameters(mod, mangleFunction);
+}
+/** The int32 arrays the int32 slot analysis keeps in `mod` (proven and
+ * checked), under the inputs LlEmitter gives it (selectInt32Arrays). */
+function provenInt32Arrays(mod) {
+    const slots = analyzeInt32Slots(mod, {
+        dynamicStores: dynamicFieldStores(mod),
+        initializerBindings: findInitializerBindings(mod),
+    });
+    return new Set([...slots.int32Arrays, ...slots.checkedInt32Arrays]);
+}
+/** The functions whose calls the backend may emit as calls of their
+ * result-slot entries (record-results.ts). */
+function resultEntryTargets(mod) {
+    const names = new Set(mod.functions.map((fn) => fn.name));
+    const targets = new Set();
+    for (const name of names)
+        if (names.has(resultEntryName(name)))
+            targets.add(name);
+    return targets;
+}
+/** The emitter for `input` after the module passes every emission runs. */
+function moduleEmitter(input, options) {
     // Facts are keyed by node identity: emit the same module whether it was
     // lowered in memory or read back from its serialized form.
     const mod = unshareNodes(input);
     // Keep source storage intact for debugger inspection in dev builds.
     return new LlEmitter(options.debugSources === undefined
-        ? addRecordResultEntries(scalarizeNumericRecords(specializeCallbackCalls(specializeNumericCalls(foldConstantGlobals(copyStableCaptures(resolveSelfCaptures(hoistFinalFieldReads(freezeInitOnlyGlobals(dropUnwrittenPropertyBags(mod)))))), mangleFunction), mangleFunction)))
-        : mod, options).emit();
+        ? selectInt32Arrays(versionParameters(addRecordResultEntries(scalarizeNumericRecords(specializeCallbackCalls(specializeNumericCalls(foldConstantGlobals(copyStableCaptures(resolveSelfCaptures(hoistFinalFieldReads(freezeInitOnlyGlobals(holdCharLocalsAsUnits(dropUnwrittenPropertyBags(runPairedWhileLoopsAsFor(mod)))))))), mangleFunction), mangleFunction)))), provenInt32Arrays, resultEntryTargets)
+        : mod, options);
+}
+export function emitLlvmModule(input, options = {}) {
+    return moduleEmitter(input, options).emit();
+}
+/** emitLlvmModule's text as parts that concatenate to it, without the copy
+ * that joining them makes: a large program's text is 150 MB. */
+export function emitLlvmModuleParts(input, options = {}) {
+    return moduleEmitter(input, options)
+        .emitParts()
+        .flatMap((part, index) => (index === 0 ? [part] : ["\n", part]));
 }
 /** Keep large translation units below the host's single-string limit. */
 export function emitLlvmModuleSource(input, options = {}) {
-    const mod = unshareNodes(input);
-    const parts = new LlEmitter(options.debugSources === undefined
-        ? addRecordResultEntries(scalarizeNumericRecords(specializeCallbackCalls(specializeNumericCalls(foldConstantGlobals(copyStableCaptures(resolveSelfCaptures(hoistFinalFieldReads(freezeInitOnlyGlobals(dropUnwrittenPropertyBags(mod)))))), mangleFunction), mangleFunction)))
-        : mod, options).emitParts();
+    // IR validation, contracts and the frontend's disposal run after lowering without checks.
+    relieveHeapPressure(true);
+    const parts = moduleEmitter(input, 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");
@@ -231,8 +284,38 @@ function mentionsLocal(e, localId) {
     expr(e);
     return found;
 }
+/** The IR nodes in `body` that name local `id`: its declaration, reads,
+ * writes and closure captures. */
+function countLocalMentions(body, id) {
+    let count = 0;
+    const visit = (node) => {
+        if (node === null || typeof node !== "object")
+            return;
+        if (Array.isArray(node)) {
+            for (const item of node)
+                visit(item);
+            return;
+        }
+        const record = node;
+        if (record["localId"] === id)
+            count++;
+        const captures = record["captures"];
+        if (Array.isArray(captures))
+            for (const c of captures)
+                if (c === id ||
+                    (typeof c === "object" && c !== null && c.localId === id))
+                    count++;
+        for (const [key, value] of Object.entries(record))
+            if (key !== "type" && key !== "loc" && key !== "captures")
+                visit(value);
+    };
+    visit(body);
+    return count;
+}
 export class LlEmitter {
     mod;
+    /** Per-feature state (emitter-state.ts), indexed by each key's slot. */
+    moduleStates = [];
     localArrayReads = new Map();
     loopArrayBorrows = new Set();
     scalarStringSlices = new Map();
@@ -254,6 +337,15 @@ export class LlEmitter {
     integerArrayBindings = new Set();
     fieldAliasTags = new Map();
     fieldPointerTags = new Map();
+    /** The field pointers (classFieldPtr) of this function whose fields hold
+     * 32-bit references to compact class instances (LlClassMeta.compressed):
+     * loadField/loadRef decode them and storeField/storeRef encode them. */
+    compressedFieldPtrs = new Set();
+    /** Compact class instances live in the program-lifetime region below
+     * 32 GiB (LlvmTargetOptions.lowRegion, and the program has compact
+     * classes): main reserves it before compiled code runs (scr_plr_init), and
+     * fields and arrays of compactRefType hold 32-bit references. */
+    compactRegion = false;
     /** Native class fields with different property names cannot occupy the
      * same slot of one object. Inherited views of the same property share a
      * tag. Array storage has its own disjoint categories; untagged runtime
@@ -269,6 +361,7 @@ export class LlEmitter {
             tag = 2 + this.fieldAliasTags.size * 2;
             this.fieldAliasTags.set(field, tag);
         }
+        this.journal?.entry("tag", field, tag);
         this.fieldPointerTags.set(ptr, tag);
     }
     /** The alias tag of a runtime word that emitted code reads and writes
@@ -281,19 +374,225 @@ export class LlEmitter {
             tag = 2 + this.fieldAliasTags.size * 2;
             this.fieldAliasTags.set(category, tag);
         }
+        this.journal?.entry("tag", category, tag);
         return `, !tbaa !${tag}`;
     }
+    /** The current function's int32 array allocations: the array literals
+     * its int32 arrays are written with. They construct SCR_ELEM_I32 arrays. */
+    int32Allocations = new Set();
+    /** The fill temporaries (`new Array(n).fill(v)`) of those allocations:
+     * the same arrays, so int32 too. */
+    int32ArrayTemps = new Set();
+    /** The same for the current function's int32 arrays with checked stores,
+     * which are only allocated by fills (ir/int32-arrays.ts
+     * checkableInt32Allocations): their temporaries' literals, with the fill's
+     * length (a literal constructs SCR_ELEM_I32 storage when that length is at
+     * least CHECKED_INT32_MIN_LENGTH, SCR_ELEM_F64 otherwise), and their
+     * temporaries. */
+    checkedAllocations = new Map();
+    checkedArrayTemps = new Set();
+    /** The fill calls (`.fill(v)`) of those allocations: a value that is not
+     * an int32 widens the new array first. */
+    checkedFills = new Set();
+    /** Collect the int32 allocations of `fn`, about to be emitted. */
+    findInt32Allocations(fn) {
+        this.int32Allocations.clear();
+        this.int32ArrayTemps.clear();
+        this.checkedAllocations.clear();
+        this.checkedArrayTemps.clear();
+        this.checkedFills.clear();
+        const { int32Arrays, checkedInt32Arrays } = this.int32Slots;
+        if (int32Arrays.size === 0 && checkedInt32Arrays.size === 0)
+            return;
+        everyStmtList(fn.body, {
+            stmt: (s) => {
+                if (s.kind !== "varDecl" && s.kind !== "assign")
+                    return true;
+                const key = int32ArrayKey(fn.name, s.localId);
+                const checked = checkedInt32Arrays.has(key);
+                if (!checked && !int32Arrays.has(key))
+                    return true;
+                const value = s.kind === "varDecl" ? s.init : s.value;
+                const allocation = value && allocatedLiteral(value);
+                if (!allocation)
+                    return true;
+                const length = checked ? fillAllocationLength(value) : null;
+                if (length !== null)
+                    this.checkedAllocations.set(allocation.literal, length);
+                else if (!checked)
+                    this.int32Allocations.add(allocation.literal);
+                if (allocation.temporary !== null)
+                    (checked ? this.checkedArrayTemps : this.int32ArrayTemps).add(allocation.temporary);
+                if (checked && value !== allocation.literal)
+                    this.checkedFills.add(value);
+                return true;
+            },
+            expr: () => true,
+        });
+    }
+    /** Whether `arr` reads one of the int32 arrays (ir/int32-arrays.ts, kept
+     * by the int32 slot analysis): a local or parameter of the current
+     * function, or a module global. */
+    int32Array(arr) {
+        if (arr.kind !== "varRef")
+            return false;
+        if (this.int32KindArray(arr))
+            return true;
+        if (this.int32Slots.int32Arrays.size === 0)
+            return false;
+        return (this.int32ArrayTemps.has(arr.localId) ||
+            this.int32Slots.int32Arrays.has(int32ArrayKey(this.currentFunctionName, arr.localId)));
+    }
+    /** Whether `arr` is one of the current function's int32 arrays with
+     * checked stores: int32 slots until a store widens it to doubles. Every
+     * access tests its kind (emitByElementKind), except in the fast copy of
+     * an int32 kind loop, which reads and writes it as an int32 array. */
+    checkedInt32Array(arr) {
+        if (arr.kind !== "varRef" || this.int32KindArray(arr))
+            return false;
+        if (this.int32Kinds?.wide.has(`${this.currentFunctionName}\0${arr.localId}`))
+            return false;
+        return this.checkedInt32Local(arr.localId);
+    }
+    /** Whether the local `localId` holds one of the current function's int32
+     * arrays with checked stores. */
+    checkedInt32Local(localId) {
+        if (this.int32Slots.checkedInt32Arrays.size === 0)
+            return false;
+        return (this.checkedArrayTemps.has(localId) ||
+            this.int32Slots.checkedInt32Arrays.has(`${this.currentFunctionName}\0${localId}`));
+    }
+    /** Whether `arr` is an int32 array with checked stores that the fast copy
+     * of the int32 kind loop being emitted holds as an int32 array. */
+    int32KindArray(arr) {
+        return (this.int32Kinds !== null &&
+            arr.kind === "varRef" &&
+            this.int32Kinds.int32.has(`${this.currentFunctionName}\0${arr.localId}`));
+    }
+    /** Before a store of `value` (of `expr`) into `arr`, in the fast copy of
+     * an int32 kind loop: continue when it is an int32 that is not -0, and
+     * otherwise leave for the statement's resume point, where it re-executes
+     * with kind tests. Returns the value as an i32 when it is at hand as an
+     * integer, or null when the store converts the double itself. */
+    emitInt32KindStoreCheck(arr, value, expr) {
+        if (!this.int32KindArray(arr) || withinInt32(this.integerRanges.get(expr)))
+            return null;
+        const integer = exactInteger(this, value, expr);
+        if (integer !== null && withinInt32(integer.range))
+            return narrowInteger(this, integer);
+        const resume = this.int32KindResume;
+        if (resume === null)
+            throw new InternalCompilerError("llvm emitter bug: an int32 kind store without a resume");
+        const B = this.B;
+        const ok = B.tmp(), int = B.tmp();
+        if (integer !== null) {
+            // An exact integer: a range test on its 64-bit form.
+            const wide = widenInteger(this, integer), low = B.tmp(), high = B.tmp();
+            B.line(`${low} = icmp sge i64 ${wide}, -2147483648`);
+            B.line(`${high} = icmp sle i64 ${wide}, 2147483647`);
+            B.line(`${ok} = and i1 ${low}, ${high}`);
+            const store = B.newLabel("arr.store.i32");
+            B.condBr(ok, store, resume);
+            B.startBlock(store);
+            B.line(`${int} = trunc i64 ${wide} to i32`);
+            return int;
+        }
+        this.declare("declare i32 @llvm.fptosi.sat.i32.f64(double)");
+        const back = B.tmp(), exact = B.tmp(), bits = B.tmp(), notNegativeZero = B.tmp();
+        B.line(`${int} = call i32 @llvm.fptosi.sat.i32.f64(double ${value.name})`);
+        B.line(`${back} = sitofp i32 ${int} to double`);
+        B.line(`${exact} = fcmp oeq double ${back}, ${value.name}`);
+        B.line(`${bits} = bitcast double ${value.name} to i64`);
+        B.line(`${notNegativeZero} = icmp ne i64 ${bits}, -9223372036854775808`);
+        B.line(`${ok} = and i1 ${exact}, ${notNegativeZero}`);
+        const store = B.newLabel("arr.store.i32");
+        B.condBr(ok, store, resume);
+        B.startBlock(store);
+        return int;
+    }
+    /** Emit an access to the checked int32 array `array` once per element
+     * kind: `arm("i32", widened)` while it holds int32 slots and
+     * `arm("f64", widened)` after it widened, joined after both. `widened` is
+     * the label of the double arm, where an int32 arm's store of a value that
+     * is not an int32 continues after widening the array. Returns the phi of
+     * the arms' results (of LLVM type `ty`), or null when `ty` is null. */
+    emitByElementKind(array, ty, arm) {
+        const B = this.B;
+        const narrow = B.newLabel("arr.kind.i32"), wide = B.newLabel("arr.kind.f64"), join = B.newLabel("arr.kind.join");
+        const kindPtr = B.tmp(), kind = B.tmp(), isInt32 = B.tmp();
+        B.line(`${kindPtr} = getelementptr inbounds %ScrArr, ptr ${array}, i32 0, i32 ${SCR_ARR_FIELD.elem}`);
+        this.markMemoryPointer(kindPtr, "array:header");
+        B.line(`${kind} = load i8, ptr ${kindPtr}${this.fieldAliasAttachment(kindPtr)}`);
+        B.line(`${isInt32} = icmp eq i8 ${kind}, ${SCR_ELEM_I32}`);
+        B.condBr(isInt32, narrow, wide);
+        B.startBlock(narrow);
+        const narrowValue = arm("i32", wide);
+        const narrowEnd = B.isTerminated() ? null : B.currentLabel();
+        if (narrowEnd !== null)
+            B.br(join);
+        B.startBlock(wide);
+        const wideValue = arm("f64", wide);
+        const wideEnd = B.isTerminated() ? null : B.currentLabel();
+        if (wideEnd !== null)
+            B.br(join);
+        B.startBlock(join);
+        // Arms that end in their own branches (a read's shared join) leave this
+        // join without predecessors.
+        if (narrowEnd === null && wideEnd === null)
+            B.terminate("unreachable");
+        if (ty === null)
+            return null;
+        const arms = [];
+        if (narrowEnd !== null)
+            arms.push(`[ ${narrowValue}, %${narrowEnd} ]`);
+        if (wideEnd !== null)
+            arms.push(`[ ${wideValue}, %${wideEnd} ]`);
+        const result = B.tmp();
+        B.line(`${result} = phi ${ty} ${arms.join(", ")}`);
+        return result;
+    }
+    /** Before storing the double `value` (of `expr`) into an int32 arm
+     * (emitByElementKind) of the checked int32 array `array`: continue in this
+     * arm when it is an int32 that is not -0, or widen the array and continue
+     * at `widened`. A value proven an int32 needs no test. */
+    emitCheckedInt32Store(array, value, expr, widened) {
+        if (withinInt32(this.integerRanges.get(expr)))
+            return;
+        const B = this.B;
+        this.declare("declare i32 @llvm.fptosi.sat.i32.f64(double)");
+        this.declare("declare void @scr_arr_widen_i32(ptr)");
+        const int = B.tmp(), back = B.tmp(), exact = B.tmp(), bits = B.tmp(), notNegativeZero = B.tmp(), ok = B.tmp();
+        B.line(`${int} = call i32 @llvm.fptosi.sat.i32.f64(double ${value})`);
+        B.line(`${back} = sitofp i32 ${int} to double`);
+        B.line(`${exact} = fcmp oeq double ${back}, ${value}`);
+        B.line(`${bits} = bitcast double ${value} to i64`);
+        B.line(`${notNegativeZero} = icmp ne i64 ${bits}, -9223372036854775808`);
+        B.line(`${ok} = and i1 ${exact}, ${notNegativeZero}`);
+        const store = B.newLabel("arr.store.i32"), widen = B.newLabel("arr.widen");
+        B.condBr(ok, store, widen);
+        B.startBlock(widen);
+        B.line(`call void @scr_arr_widen_i32(ptr ${array})`);
+        B.br(widened);
+        B.startBlock(store);
+    }
+    /** The access an element operation on `arr` (of element type `elem`)
+     * takes: int32 arrays read and write their 4-byte slots. */
+    arrayAccess(arr, elem) {
+        if (this.checkedInt32Array(arr))
+            throw new InternalCompilerError("llvm emitter bug: a checked int32 array without its kind test");
+        return this.int32Array(arr) ? "i32" : elemAccess(elem);
+    }
     /** Whether an element access at `index` of `arr` lies in the hole-free
-     * prefix: the counter of a dense array loop's fast copy indexing one of
-     * the arrays its entry test covered. */
+     * prefix: a counter of a dense array loop's fast copy indexing one of the
+     * arrays its entry test covered. */
     provenDenseIndex(arr, index) {
-        const loop = this.denseLoop;
+        const loop = LOOPS.of(this).denseLoop;
         return (loop !== null &&
             arr.kind === "varRef" &&
             loop.arrays.has(arr.localId) &&
             index.kind === "varRef" &&
-            index.localId === loop.counter &&
-            this.integerLoopBindings.has(loop.counter));
+            (index.localId === loop.counter || index.localId === loop.pair?.high) &&
+            this.integerLoopBindings.has(index.localId));
     }
     fieldAliasAttachment(ptr) {
         const tag = this.fieldPointerTags.get(ptr);
@@ -384,6 +683,10 @@ export class LlEmitter {
     cstrs = new Map();
     /** Interned ScrMapOps descriptors (scr_map.h): initializer → symbol. */
     mapOpsConsts = new Map();
+    /** Method-id slots of checked-dynamic method calls
+     * (scr_dyn_invoke_prepared_id): method name → symbol of an i32 the
+     * runtime fills with the name's id on the first call. */
+    methodIdSlots = new Map();
     /** Type-directed walker functions (JSON serializers, the indent
      * rewriter, union ToString/join) — interned per typeKey/unionId, defs
      * flushed with the shape helpers. */
@@ -432,6 +735,15 @@ export class LlEmitter {
     callLifetimes;
     constantCallbacks;
     currentConstantCallbacks = new Map();
+    /** The current function's running maximum and minimum updates, whose
+     * branches are weighted as rarely taken (running-extrema.ts). */
+    runningExtrema = new Set();
+    /** Callback bindings whose closures an enclosing callback loop version
+     * proved to hold their known function: calls take the direct entry with
+     * no fallback (emitCallbackVersionedLoop). */
+    knownCallbacks = new Set();
+    callbackVersioning = new Set();
+    callbackVersionsEnabled = false;
     stackCallbacks;
     receiverReaders;
     stackCaptures;
@@ -474,6 +786,9 @@ export class LlEmitter {
     /** Module constants that keep one value once initialized
      * (immutability.ts stableGlobals). */
     stableGlobals = new Set();
+    /** Every function body's nodes in walk order (ir/node-index.ts), for the
+     * constructor's analyses. */
+    nodeIndex;
     tdzGlobals = new Map();
     constantNumericTables;
     /** Constant-key reads on checked-dynamic objects, each with its own
@@ -513,9 +828,15 @@ export class LlEmitter {
     /** Fiberless async functions a stackless coroutine body awaits directly;
      * each gets an inline await entry (emitCoroInlineAwait). */
     inlineAwaitCallees = new Set();
+    /** Stackless async functions some coroutine body awaits directly: each
+     * gets a direct spawn entry (emitCoroDirectAwait). */
+    directAwaitCallees = new Set();
     /** The async functions whose bodies never suspend and that a direct
      * await may enter in place (selectStacklessAsync). */
     inlineAwaitable = new Set();
+    /** Locals whose array literal emitStmts left for the `await Promise.all`
+     * that reads them (deferredPromiseAllLocal). */
+    deferredPromiseAllEntries = new Map();
     /** The promise a `return` emitted past its finally regions already
      * produced for its adopting await (borrowed from the return's parked
      * slot); that await takes it instead of evaluating its operand. */
@@ -531,13 +852,16 @@ export class LlEmitter {
     /** The program calls mock.timers members (moduleUsesMockTimers): timer
      * calls emit scr_test.c's mock-aware entry points. */
     mockTimers;
-    schedulesInContextValue = undefined;
+    runtimeFeaturesValue;
+    /** The module's runtime features (moduleRuntimeFeatures), found with one
+     * walk of the module the first time any of them is read. */
+    get runtimeFeatures() {
+        return (this.runtimeFeaturesValue ??= moduleRuntimeFeatures(this.mod, this.nodeIndex));
+    }
     /** Whether timer and tick scheduling goes through the *_als entry
      * points (RuntimeFeatures asyncContext). */
     get schedulesInContext() {
-        if (this.schedulesInContextValue === undefined)
-            this.schedulesInContextValue = moduleRuntimeFeatures(this.mod).asyncContext;
-        return this.schedulesInContextValue;
+        return this.runtimeFeatures.asyncContext;
     }
     /** Emitted ref-kind resolve thunks for new Promise, interned per inner
      * typeKey → thunk symbol. */
@@ -553,10 +877,14 @@ export class LlEmitter {
     /** Identity-preserving static→dyn capsules for program classes and Web
      * APIs whose values remain directly observable. */
     liveDynRefAdapters = new Map();
-    dynBuiltinStreamUse;
     /** See moduleUsesDynBuiltinStream. */
     get usesDynBuiltinStream() {
-        return (this.dynBuiltinStreamUse ??= moduleUsesDynBuiltinStream(this.mod));
+        return this.runtimeFeatures.dynBuiltinStream;
+    }
+    /** A checked-dynamic for-await may hold a native stream: the program
+     * links the stream unit (and the dyn-async one the loop needs). */
+    get dynForAwaitStreams() {
+        return this.runtimeFeatures.stream && this.runtimeFeatures.dynAsync;
     }
     /** Runtime-arm dispatchers for live union values. */
     liveDynUnionRefAdapters = new Map();
@@ -646,25 +974,38 @@ export class LlEmitter {
      * immortal from construction (classes.ts programLifetimeClass). */
     programLifetime;
     numericLocals = new Map();
-    /** Local arrays of the current function that no other binding can hold
-     * (ir/array-length-stability.ts). */
-    unaliasedArrays = new Set();
-    /** Dense array loops (dense-array-loops.ts) run in this function. */
-    denseLoopsEnabled = false;
-    denseLoopEntries = new Map();
-    /** The fast copy of a dense array loop being emitted. */
-    denseLoop = null;
     captureIds = new Set();
     /** Active induction bindings retain their width independently of size_t. */
     integerLoopBindings = new Map();
-    countedLoopsEnabled = false;
+    /** Constant number locals whose latest emitted declaration stored an
+     * exact integer beside the double, such as `const j = i * 4` in a
+     * typed-array loop version: an i64 slot and the integer's range. */
+    integerTemps = new Map();
+    /** Integer temps are kept only in optimized synchronous functions: an
+     * async or generator body resumes with its locals in its frame, which
+     * an entry alloca is not part of. */
+    integerTempsEnabled = false;
     /** Speculative integer loops (speculative-integers.ts) run in this function. */
     speculativeLoopsEnabled = false;
     /** The fast copy of a speculative integer loop being emitted: its
      * integer-computed writes and where each resumes in the ordinary copy. */
     speculation = null;
+    /** Speculative loop sites numbered so far in the module. */
+    speculativeLoopSites = 0;
     /** The ordinary copy being emitted: resume labels still to place. */
     speculationResume = null;
+    /** Run once at the top of the next loop copy's header
+     * (`enterLoopHeader`): records the ordinary copy's header, or sends the
+     * third copy's header there. */
+    speculationHeader = null;
+    /** A copy of an int32 kind loop (int32-kind-loops.ts) being emitted: the
+     * int32 arrays with checked stores it reads and writes as int32 arrays
+     * (the fast copy) or as double arrays (an ordinary copy entered only
+     * after they widened), as `function\0local` keys, and where each of the
+     * fast copy's writes resumes in the third copy. */
+    int32Kinds = null;
+    /** The resume label of the fast-copy write being emitted. */
+    int32KindResume = null;
     /** The function being emitted, for speculative globals. */
     speculativeFunction = "";
     /** Every function that writes each number global (computed on demand). */
@@ -682,20 +1023,17 @@ export class LlEmitter {
     int32Elements = null;
     /** Sums whose result only feeds 32-bit conversions (wrapping-sums.ts). */
     wrappingSums = new Set();
-    byteWindowsEnabled = true;
-    byteWindowEntries = new Map();
-    /** Typed-array loop versioning (bytes-loop-versions.ts) for the current
-     * function: off in debug and suspending functions and inside a copy. */
-    bytesLoopVersionsEnabled = false;
-    /** Loops being versioned around the statement being emitted: a loop is
-     * never versioned inside its own copies, and versions nest boundedly. */
-    bytesLoopVersioning = new Set();
-    bytesLoopEntries = null;
-    bytesLoopFunction = null;
-    /** Counted loops whose integer-form safety test an enclosing version
-     * guard already passed. */
-    provenCountedGuards = new Set();
+    /** Number locals of the current function that hold exact integers or NaN
+     * (findIntegerOrNaNLocals in wrapping-sums.ts). */
+    integerOrNaNLocals = new Map();
     bytesBounds = new Set();
+    /** The charCodeAt reads standing for charAt reads the emitter rewrote
+     * (one-unit tests and switches, charAtUnitRead), with the charAt each
+     * stands for: a loop version's proof for the charAt covers its read. */
+    charAtUnitReads = new Map();
+    /** Worker programs: typed-array accesses whose views an enclosing version
+     * guard proved thread-owned. */
+    bytesOwned = new Set();
     integerViews = new Map();
     /** Module globals the current function owns outright (initializer
      * bindings): their function-local slot, which stands in for the global. */
@@ -746,27 +1084,50 @@ export class LlEmitter {
     chainSlots = new Map();
     logArgSlots = 0;
     stackTraces;
+    /** The options this emitter was built with (chunk emitters reuse them). */
+    targetOptions;
+    /** Records the module-level effects of emitting a range of functions,
+     * which the emitter that merges the range replays (emit-journal.ts). Null
+     * when this emitter emits the whole module itself. */
+    journal;
+    /** The emitter's hosts forward to `journal` (journal set, or workers). */
+    journaled;
     /** Stack-trace mode: functions no capture can include (no frame push). */
     unframedFunctions;
-    constructor(mod, options) {
+    constructor(mod, options, journal = null) {
         this.mod = mod;
-        this.stackTraces = observesStacks(mod);
-        this.nullableUnions = new NullableUnions(mod, options.debugSources === undefined);
-        this.mockTimers = moduleUsesMockTimers(mod);
+        this.targetOptions = options;
+        this.journal = journal;
+        this.journaled =
+            journal !== null ||
+                ((options.functionWorkers ?? 1) > 1 &&
+                    options.forkPrimitives !== undefined &&
+                    options.debugSources === undefined);
+        // One walk of every body, which the analyses below read instead of
+        // walking the bodies themselves.
+        this.nodeIndex = new IrNodeIndex(mod);
+        this.stackTraces = observesStacks(mod, this.nodeIndex);
+        this.nullableUnions = new NullableUnions(mod, options.debugSources === undefined, this.nodeIndex);
+        this.mockTimers = this.runtimeFeatures.mockTimers;
         this.debug =
             options.debugSources === undefined
                 ? null
                 : new LlvmDebugInfo(mod.sourceFile, options.debugSources, options.pointerBits, mod.unions, this.nullableUnions.armTypes());
         this.constantNumericTables = findConstantNumericTables(mod);
-        this.initializerBindings = findInitializerBindings(mod);
-        this.int32Slots = analyzeInt32Slots(mod);
-        const dynamicStores = dynamicFieldStores(mod);
+        this.initializerBindings = findInitializerBindings(mod, this.nodeIndex);
+        // One walk finds the dynamic field stores every analysis below consults.
+        const dynamicStores = dynamicFieldStores(mod, undefined, undefined, this.nodeIndex);
+        this.int32Slots = analyzeInt32Slots(mod, {
+            dynamicStores,
+            initializerBindings: this.initializerBindings,
+            nodes: this.nodeIndex,
+        });
         this.liveViewsReadOnly =
             mod.lib === undefined && !dynamicStores.all && dynamicStores.names.size === 0;
         this.int32Abis = this.debug === null ? findInt32Abis(mod, this.int32Slots) : new Map();
         this.immortalGlobals = new Set(mod.contracts?.immortalGlobals ?? []);
         this.programLifetime = new Set(mod.contracts?.programLifetime ?? []);
-        this.finalFields = analyzeFinalFields(mod);
+        this.finalFields = analyzeFinalFields(mod, false, dynamicStores, this.nodeIndex);
         this.sizeType = options.pointerBits === 32 ? "i32" : "i64";
         this.ffiExtendNarrowIntegers =
             options.wasi === true || ffiExtendsNarrowIntegers(options.targetTriple);
@@ -815,7 +1176,7 @@ export class LlEmitter {
         this.ffiHasForeignCallback = hasForeignFfiCallback(mod.ffiImports ?? []);
         for (const fn of mod.functions)
             this.fnByName.set(fn.name, fn);
-        this.appendedArrayLiterals = findAppendedArrayLiterals(mod);
+        this.appendedArrayLiterals = findAppendedArrayLiterals(mod, this.nodeIndex);
         for (const entry of mod.ffiImports ?? []) {
             this.ffiByName.set(entry.name, entry);
         }
@@ -823,8 +1184,11 @@ export class LlEmitter {
         // and per async fiber; WASI, Windows and library builds have none.
         const triple = (options.targetTriple ?? "").toLowerCase();
         const windows = triple === "" ? process.platform === "win32" : triple.includes("windows");
+        this.publishedTypes = computePublishedTypes(mod, this.nodeIndex);
         const mt = computeMayThrow(mod, {
             stackChecks: !this.wasi && mod.lib === undefined && !windows,
+            published: this.publishedTypes,
+            nodes: this.nodeIndex,
         });
         this.mayThrow = mt.fns;
         this.workerEntryPolls = mt.workerEntryPolls ?? null;
@@ -833,11 +1197,12 @@ export class LlEmitter {
         // runtime moves deep prefix nests to a fresh stack using the guard,
         // which Windows lacks.
         this.stacklessAsyncAllowed = this.stacklessGenerators && mod.lib === undefined && !windows;
-        this.publishedTypes = computePublishedTypes(mod);
         this.unframedFunctions = this.stackTraces
             ? captureFreeFunctions(mod, this.stackChecks, this.publishedTypes)
             : new Set();
-        this.immutableFields = computeImmutableFields(mod);
+        // One field-mutability answer serves immutable fields and traced shapes.
+        const cycleMutability = computeCycleMutability(mod, hierarchyUnitOfClass(mod), dynamicStores);
+        this.immutableFields = computeImmutableFields(mod, dynamicStores, cycleMutability);
         this.constructorFunctions = new Set((mod.classes ?? []).map((c) => `%${c.name}.constructor`));
         this.indirectMayThrow = mt.indirect || mod.workers === true;
         for (const cls of mod.classes ?? []) {
@@ -870,12 +1235,13 @@ export class LlEmitter {
         this.checkedNarrows = new CheckedNarrows(this.fnByName);
         this.referenceEffects = new ReferenceEffects(this.fnByName, (call) => this.optionalArrayReads.get(call) !== null, mod.classes ?? []);
         if (this.debug === null)
-            this.referenceWrites = new ReferenceWrites(this.fnByName, mod.classes ?? [], (call) => this.optionalArrayReads.get(call) !== null, new Set((mod.globals ?? []).map((g) => g.id)), { unions: mod.unions, records: mod.records }, this.immutableFields);
+            this.referenceWrites = new ReferenceWrites(this.fnByName, mod.classes ?? [], (call) => this.optionalArrayReads.get(call) !== null, new Set((mod.globals ?? []).map((g) => g.id)), { unions: mod.unions, records: mod.records }, this.immutableFields, this.nodeIndex);
         const walkParameters = new Map();
         if (this.debug === null) {
             const host = {
                 pointerLocal: (local) => this.plainReference(local.type),
                 borrowsWithoutOwning: (e) => this.borrowsWithoutOwning(e),
+                nodes: this.nodeIndex,
             };
             for (const fn of this.fnByName.values()) {
                 const preserving = this.referenceEffects.functions.has(fn.name);
@@ -922,7 +1288,7 @@ export class LlEmitter {
         });
         this.lentStringParameters =
             this.debug === null ? findLentStringParameters(this.fnByName, this.callLifetimes) : new Map();
-        this.constantCallbacks = findConstantCallbacks(mod, this.callLifetimes);
+        this.constantCallbacks = findConstantCallbacks(mod, this.callLifetimes, this.nodeIndex);
         // Integer clones signal a stack overflow through their result, which
         // needs the single-threaded guard; worker programs also poll for
         // termination, and debug builds and stack traces keep every frame.
@@ -941,7 +1307,7 @@ export class LlEmitter {
         this.receiverReaders = new AmbientReceiverReaders(this.fnByName);
         this.stackCaptures = new StackCaptures(this.fnByName, this.callLifetimes, this.stackCallbacks);
         this.lazyCaptures = new LazyCaptures(this.fnByName);
-        const traced = computeTraced(mod);
+        const traced = computeTraced(mod, dynamicStores, cycleMutability);
         this.tracedShapes = traced.shapes;
         this.tracedUnions = traced.unions;
         // A shape union's value is whichever record it holds, and the collector
@@ -965,6 +1331,22 @@ export class LlEmitter {
             }
         }
         this.shapeHost = {
+            // Journal hooks only on emitters that can emit ranges (chunk
+            // emitters, and emitters whose workers take a journal after the
+            // fork), so the host's optional calls cost nothing otherwise.
+            journalAllocated: !this.journaled
+                ? undefined
+                : (name, op, args) => this.journal?.allocated(name, op, args),
+            journalBuilt: !this.journaled ? undefined : () => this.journal?.built(),
+            journalOpened: !this.journaled ? undefined : (op) => this.journal?.opened(op),
+            journalUsed: !this.journaled
+                ? undefined
+                : (name, op, args) => this.journal?.used(name, op, args),
+            journalEntry: !this.journaled
+                ? undefined
+                : (table, key, value) => this.journal?.entry(table, key, value),
+            compactArrayElem: (elem) => this.compactArrayElem(elem),
+            compactRegion: () => this.compactRegion,
             sizeType: this.sizeType,
             cycleBufOffset: this.cycleBufOffset,
             tracedShapes: this.tracedShapes,
@@ -1003,9 +1385,16 @@ export class LlEmitter {
             liveDynRefAdapter: (type) => this.liveDynRefAdapter(type),
             usesDynBuiltinStream: () => this.usesDynBuiltinStream,
             liveDynUnionRefAdapter: (type) => this.liveDynUnionRefAdapter(type),
+            declBoundary: () => this.mod.declBoundary === true,
             dynPromiseAdapter: (type) => this.dynPromiseAdapter(type),
             isErrorClass: (name) => this.classMeta.get(name)?.root.def.name === "%Error",
             classRootOf: (name) => this.classMeta.get(name)?.root.def.name,
+            releasesNothing: (t) => {
+                if (t.kind !== "object" || (this.shapeHost.regions ?? null) !== null)
+                    return false;
+                const meta = this.classMeta.get(t.className);
+                return meta !== undefined && programLifetimeClass(this.shapeHost, meta);
+            },
             classSubtypes: (name) => {
                 const target = this.classMetaOf(name);
                 const intervals = classMembershipIntervals(this.classMeta, target.def.name);
@@ -1038,7 +1427,7 @@ export class LlEmitter {
             if (g.tdz)
                 this.tdzGlobals.set(g.id, g.name);
         }
-        this.stableGlobals = stableGlobals(mod);
+        this.stableGlobals = stableGlobals(mod, this.nodeIndex);
         // Runtime error, EventEmitter, stream, EventTarget and Event classes
         // have known layouts. Subclasses embed the runtime prefixes from
         // classes.ts.
@@ -1068,6 +1457,34 @@ export class LlEmitter {
                 classDefinitions: (cls, sizeOf) => regions.classDefs(cls, sizeOf),
             };
         }
+        // ProgramLifetime hierarchies count nothing: their instances get the
+        // 32-bit header and packed fields (classes.ts LlClassMeta.compact),
+        // except where regions count them or a slot word follows the header.
+        if (this.sizeType === "i64" && mod.lifetimeRegions !== true)
+            assignCompactLayouts(this.classMeta, (root) => programLifetimeClass(this.shapeHost, root) && !root.threadSlot, (cls) => classFieldTypes(this.shapeHost, cls, this.int32Slots), 
+            // Executables whose region lies below 32 GiB hold compact class
+            // instances there (scr_plr_alloc), so fields referring to one store
+            // a 32-bit reference: the field's type, the class of a
+            // `C | undefined` or `C | null` pointer, or the reference arm of a
+            // nullable pointer field, is a compact class. `C | null | undefined`
+            // keeps the pointer: its null is a sentinel outside the region.
+            mod.lib === undefined && options.lowRegion === true
+                ? (cls, i, isCompact) => {
+                    const f = cls.fields[i];
+                    if (this.inlineUnions.classField(cls.name, f.name))
+                        return false;
+                    if (this.compactRefType(f.type, isCompact))
+                        return true;
+                    const nullable = f.type.kind === "union" && this.nullableUnions.single(f.type.unionId) === null
+                        ? this.nullableFields.get(cls.name, f.name)
+                        : null;
+                    return nullable !== null && isCompact(nullable.arm.className);
+                }
+                : undefined);
+        this.compactRegion =
+            mod.lib === undefined &&
+                options.lowRegion === true &&
+                [...this.classMeta.values()].some((m) => m.compact);
         for (const [name, rec] of RUNTIME_ERROR_CLASSES) {
             const meta = this.classMeta.get(name);
             if (!meta)
@@ -1330,16 +1747,33 @@ export class LlEmitter {
             this.fnDefText.set(fn.name, coroText);
         });
     }
+    /** Whether a fiberless body running on its caller's stack needs the
+     * frame scr_async_inline_enter/exit keep: it isolates the Error.stack
+     * frame chain, which only stack-observing programs push, as a fresh fiber
+     * would. Other programs run the body with a plain call. The body runs in
+     * its caller's AsyncLocalStorage context either way, as Node runs an async
+     * body up to its first await. The frame also counts the bodies running on
+     * a fiber's stack for the runtime's trap on a fiberless body that
+     * suspends. */
+    get fiberlessFrames() {
+        return this.stackTraces;
+    }
     /** The spawn wrapper of a fiberless async function: runs the body on the
-     * caller's stack between scr_async_inline_enter/leave and settles the
-     * fresh promise from its outcome — the fiber trampoline's epilogue,
-     * without the fiber. */
+     * caller's stack (between scr_async_inline_enter/leave when
+     * fiberlessFrames) and settles a fresh promise from its outcome — the
+     * fiber trampoline's epilogue, without the fiber. */
     emitFiberlessAsyncSpawn(fn, spawnParams) {
         const ret = fn.returnType;
         const retTy = this.llType(ret);
         const lifted = fn.captures !== undefined;
-        this.declare(`declare void @scr_async_inline_enter(ptr)`);
-        this.declare(`declare ptr @scr_async_inline_leave(ptr)`);
+        const framed = this.fiberlessFrames;
+        if (framed) {
+            this.declare(`declare void @scr_async_inline_enter(ptr)`);
+            this.declare(`declare ptr @scr_async_inline_leave(ptr)`);
+        }
+        else {
+            this.declare(`declare ptr @scr_promise_new()`);
+        }
         this.declare(`declare void @scr_promise_reject_pending(ptr)`);
         if (lifted) {
             this.declare(`declare ptr @scr_closure_retain_v(ptr)`);
@@ -1349,15 +1783,17 @@ export class LlEmitter {
         const out = [
             `define internal ptr @${mangleAsyncSpawn(fn.name)}(${spawnParams.join(", ")}) ${FN_ATTRS} { ; fiberless ${fn.name}`,
             `entry:`,
-            `  %frame = alloca { ptr, ptr }`,
+            ...(framed ? [`  %frame = alloca { ptr, ptr }`] : []),
             // The fiber path holds +1 on a lifted environment for the body's
             // duration (packed, released by the trampoline); keep that lifetime.
             ...(lifted ? [`  %env = call ptr @scr_closure_retain_v(ptr %a0)`] : []),
-            `  call void @scr_async_inline_enter(ptr %frame)`,
+            ...(framed ? [`  call void @scr_async_inline_enter(ptr %frame)`] : []),
             retTy === "void" ? `  ${bodyCall}` : `  %r = ${bodyCall}`,
             ...(lifted ? [`  call void @scr_closure_release(ptr %a0)`] : []),
             ...this.pendingTestLines("%pend"),
-            `  %p = call ptr @scr_async_inline_leave(ptr %frame)`,
+            framed
+                ? `  %p = call ptr @scr_async_inline_leave(ptr %frame)`
+                : `  %p = call ptr @scr_promise_new()`,
             `  br i1 %pend, label %thrown, label %clean`,
             `clean:`,
             ...this.asyncFulfillLines(ret, "%p"),
@@ -1397,24 +1833,94 @@ export class LlEmitter {
             return false;
         return fn.captures === undefined;
     }
+    /** Whether a stackless coroutine body's `await f(...)` may await f's
+     * fiber record instead of its promise (emitCoroDirectAwait): f is a
+     * stackless async function whose direct call an await-call entry could
+     * take. The await consumes the promise, so nothing else can observe it.
+     * Worker programs keep the promise for their stop checkpoint. */
+    directAwaitEligible(fnName) {
+        if (this.wasi || this.mod.workers === true || this.currentCoro?.kind !== "async")
+            return false;
+        const fn = this.fnByName.get(fnName);
+        if (fn === undefined || fn.async !== true || fn.generator !== undefined)
+            return false;
+        if (!this.stacklessAsync.has(fnName) || fn.captures !== undefined)
+            return false;
+        if (fn.returnType.kind === "dyn")
+            return false;
+        return fn.asyncCacheGlobal === undefined && fn.asyncCycleCacheGlobal === undefined;
+    }
+    /** A stackless coroutine body's `await f(...)` of a stackless f, without
+     * f's promise object: f's prefix runs as the spawn of a fiber record that
+     * keeps the promise inside. A body still running wakes this coroutine
+     * when it finishes, where its promise's settlement would wake its one
+     * waiter; a finished one takes the settled await's turn. The result (or
+     * the rejection, re-thrown) comes out of the record, which goes. */
+    emitCoroDirectAwait(call, type) {
+        const coro = this.currentCoro;
+        if (coro === null)
+            throw new InternalCompilerError("llvm emitter bug: direct await outside a coroutine");
+        const B = this.B;
+        const record = emitCallExpr(this, call, "direct").name;
+        this.declare(`declare zeroext i1 @scr_coro_direct_prepare(ptr, ptr)`);
+        const suspend = B.tmp();
+        B.line(`${suspend} = call zeroext i1 @scr_coro_direct_prepare(ptr ${coro.self}, ptr ${record})`);
+        const park = B.newLabel("await.suspend");
+        const ready = B.newLabel("await.ready");
+        B.condBr(suspend, park, ready);
+        B.startBlock(park);
+        this.emitCoroSuspendPrepared();
+        B.br(ready);
+        B.startBlock(ready);
+        if (type.kind === "void") {
+            this.declare(`declare void @scr_coro_direct_void(ptr)`);
+            B.line(`call void @scr_coro_direct_void(ptr ${record})`);
+            this.emitPendingCheck();
+            return { name: "", type };
+        }
+        const t = B.tmp();
+        if (type.kind === "f64" || type.kind === "date") {
+            this.declare(`declare double @scr_coro_direct_f64(ptr)`);
+            B.line(`${t} = call double @scr_coro_direct_f64(ptr ${record})`);
+        }
+        else if (type.kind === "bool") {
+            this.declare(`declare zeroext i1 @scr_coro_direct_bool(ptr)`);
+            B.line(`${t} = call zeroext i1 @scr_coro_direct_bool(ptr ${record})`);
+        }
+        else if (type.kind === "string") {
+            this.declare(`declare ptr @scr_coro_direct_str(ptr)`);
+            B.line(`${t} = call ptr @scr_coro_direct_str(ptr ${record})`);
+        }
+        else {
+            this.declare(`declare ptr @scr_coro_direct_ref(ptr)`);
+            B.line(`${t} = call ptr @scr_coro_direct_ref(ptr ${record})`);
+        }
+        const out = this.own({ name: this.adoptHeap(t, type), type });
+        this.emitPendingCheck();
+        return out;
+    }
     /** The inline await entry of a fiberless async function (`sc_ai_*`): its
-     * body on the caller's stack between scr_async_inline_enter/exit, as in
-     * its spawn wrapper, returning the result and leaving a throw pending for
-     * the awaiting coroutine (emitCoroInlineAwait). */
+     * body on the caller's stack (between scr_async_inline_enter/exit when
+     * fiberlessFrames), as in its spawn wrapper, returning the result and
+     * leaving a throw pending for the awaiting coroutine (emitCoroInlineAwait). */
     emitAsyncInlineAwaitCall(fn) {
         const retTy = this.llType(fn.returnType);
         const params = fn.params.map((p, i) => `${this.llType(p.type)} %a${i}`);
         const args = params.join(", ");
-        this.declare(`declare void @scr_async_inline_enter(ptr)`);
-        this.declare(`declare void @scr_async_inline_exit(ptr)`);
+        const framed = this.fiberlessFrames;
+        if (framed) {
+            this.declare(`declare void @scr_async_inline_enter(ptr)`);
+            this.declare(`declare void @scr_async_inline_exit(ptr)`);
+        }
         const bodyCall = `call ${retTy} @${mangleFunction(fn.name)}(${args})`;
         return [
             `define internal ${retTy} @${mangleAsyncInlineAwaitCall(fn.name)}(${args}) ${FN_ATTRS} { ; inline await ${fn.name}`,
             `entry:`,
-            `  %frame = alloca { ptr, ptr }`,
-            `  call void @scr_async_inline_enter(ptr %frame)`,
+            ...(framed
+                ? [`  %frame = alloca { ptr, ptr }`, `  call void @scr_async_inline_enter(ptr %frame)`]
+                : []),
             retTy === "void" ? `  ${bodyCall}` : `  %r = ${bodyCall}`,
-            `  call void @scr_async_inline_exit(ptr %frame)`,
+            ...(framed ? [`  call void @scr_async_inline_exit(ptr %frame)`] : []),
             retTy === "void" ? `  ret void` : `  ret ${retTy} %r`,
             `}`,
             ``,
@@ -1457,6 +1963,193 @@ export class LlEmitter {
         this.emitPendingCheck();
         return value;
     }
+    /** The entries of `Promise.all(arg)` that a stackless coroutine body's
+     * await may run in place (emitCoroInlinePromiseAll): `arg` is a non-empty
+     * array literal, or the local whose declaration emitStmts deferred to this
+     * await (deferredPromiseAllEntries), whose every entry is a call to a
+     * never-suspending async function, and the result is an array. Null
+     * otherwise. Consumes a deferred local's entries. */
+    inlinePromiseAllEntries(all) {
+        if (all.name !== "promise.all" || all.type.kind !== "promise")
+            return null;
+        if (all.type.inner.kind !== "array")
+            return null;
+        const arg = all.args[0];
+        if (arg?.kind === "varRef") {
+            const deferred = this.deferredPromiseAllEntries.get(arg.localId);
+            if (deferred === undefined)
+                return null;
+            this.deferredPromiseAllEntries.delete(arg.localId);
+            return deferred;
+        }
+        return arg?.kind === "arrayLit" && this.promiseAllInlineable(arg) ? arg : null;
+    }
+    /** Whether every entry of `entries` is a call an await could run in place
+     * (inlineAwaitEligible) that yields its promise's inner type. */
+    promiseAllInlineable(entries) {
+        if (entries.elems.length === 0 || (entries.spreads?.length ?? 0) > 0)
+            return false;
+        if (entries.type.kind !== "array" || entries.type.elem.kind !== "promise")
+            return false;
+        const inner = entries.type.elem.inner;
+        return entries.elems.every((el) => {
+            if (el.kind !== "call" || !this.inlineAwaitEligible(el.callee))
+                return false;
+            const callee = this.fnByName.get(el.callee);
+            return typeEquals(callee.returnType, inner) && !this.callLifetimes.borrowed.has(el.callee);
+        });
+    }
+    /** Whether `stmts[i]` declares a local holding an array literal that only
+     * `stmts[i + 1]` reads, as the operand of `await Promise.all(local)` that
+     * runs first in that statement and may run its entries in place. Nothing
+     * runs between the literal and the await, so the await evaluates the
+     * literal itself (inlinePromiseAllEntries). Debug builds keep the local. */
+    deferredPromiseAllLocal(stmts, i) {
+        const decl = stmts[i];
+        const next = stmts[i + 1];
+        if (this.debug !== null || decl?.kind !== "varDecl" || decl.init?.kind !== "arrayLit")
+            return null;
+        if (this.currentCoro?.kind !== "async" || next === undefined)
+            return null;
+        const operand = next.kind === "varDecl"
+            ? next.init
+            : next.kind === "exprStmt"
+                ? next.expr
+                : next.kind === "assign"
+                    ? next.value
+                    : null;
+        if (operand?.kind !== "awaitExpr" || operand.adopt === true)
+            return null;
+        const all = operand.value;
+        if (all.kind !== "intrinsic" || all.name !== "promise.all" || all.type.kind !== "promise")
+            return null;
+        if (all.type.inner.kind !== "array")
+            return null;
+        const arg = all.args[0];
+        if (arg?.kind !== "varRef" || arg.localId !== decl.localId)
+            return null;
+        if (!this.promiseAllInlineable(decl.init))
+            return null;
+        if (this.currentLocals.get(decl.localId)?.boxed)
+            return null;
+        // The declaration and this read are the local's only mentions.
+        return countLocalMentions(this.currentFunctionBody, decl.localId) === 2 ? decl.init : null;
+    }
+    /** A stackless coroutine body's `await Promise.all([f(...), ...])` of
+     * never-suspending calls, with Promise.all's turns and without its
+     * promises: the entries run in place in order and their values fill the
+     * result array. Promise.all queues one reaction job per entry, back to
+     * back, and the last of them settles the result, whose await then takes a
+     * turn: here one turn stands for the entries' jobs and a second for the
+     * await. A throwing entry becomes the rejection the await re-throws from
+     * its turn; the remaining entries still run, and later throws are handled
+     * rejections, as Promise.all's subscriptions make them. */
+    emitCoroInlinePromiseAll(entries, type) {
+        if (type.kind !== "array")
+            throw new InternalCompilerError("llvm emitter bug: inline Promise.all result");
+        const B = this.B;
+        const elem = type.elem;
+        const acc = elemAccess(elem);
+        const values = B.tmp();
+        // Up to three values fit in the array's own block (scr_arr_new_*_small).
+        const small = entries.elems.length <= 3;
+        B.line(`${values} = ${arrNewCall(this.shapeHost, elem, small ? "0" : String(entries.elems.length), small)}`);
+        const out = this.own({ name: values, type });
+        this.declare(`declare ptr @scr_promise_new()`);
+        this.declare(`declare void @scr_promise_reject_pending(ptr)`);
+        this.declare(`declare void @scr_promise_mark_handled(ptr)`);
+        const promiseType = entries.type.kind === "array" ? entries.type.elem : type;
+        // Each entry's rejection, owned by the frame: unobserved until the
+        // entries have all run, as Promise.all subscribes only then, so an
+        // entry argument's synchronous throw leaves them unhandled.
+        const rejections = [];
+        for (const entry of entries.elems) {
+            if (entry.kind !== "call")
+                throw new InternalCompilerError("llvm emitter bug: inline Promise.all entry");
+            const slot = B.tmp();
+            B.entryAllocas.push(`${slot} = alloca ptr`);
+            B.line(`store ptr null, ptr ${slot}`);
+            this.ownSlot(slot, promiseType);
+            rejections.push(slot);
+            const value = emitCallExpr(this, entry, "inline");
+            const thrown = B.tmp();
+            for (const line of this.pendingTestLines(thrown))
+                B.line(line.trim());
+            const clean = B.newLabel("pa.clean");
+            const rejected = B.newLabel("pa.rejected");
+            const next = B.newLabel("pa.next");
+            B.condBr(thrown, rejected, clean);
+            B.startBlock(clean);
+            if (acc === "ref")
+                this.toHeap(value);
+            this.arrPush(values, acc, value.name, elem);
+            B.br(next);
+            B.startBlock(rejected);
+            const promise = B.tmp();
+            B.line(`${promise} = call ptr @scr_promise_new()`);
+            B.line(`call void @scr_promise_reject_pending(ptr ${promise})`);
+            B.line(`store ptr ${promise}, ptr ${slot}`);
+            B.br(next);
+            B.startBlock(next);
+        }
+        // Promise.all's subscriptions handle every rejection, and the first
+        // (in entry order) rejects the result.
+        let first = "null";
+        for (let k = rejections.length - 1; k >= 0; k--) {
+            const slot = rejections[k];
+            const rejection = B.tmp();
+            const present = B.tmp();
+            B.line(`${rejection} = load ptr, ptr ${slot}`);
+            B.line(`${present} = icmp ne ptr ${rejection}, null`);
+            const mark = B.newLabel("pa.handled");
+            const after = B.newLabel("pa.unrejected");
+            B.condBr(present, mark, after);
+            B.startBlock(mark);
+            B.line(`call void @scr_promise_mark_handled(ptr ${rejection})`);
+            B.br(after);
+            B.startBlock(after);
+            const chosen = B.tmp();
+            B.line(`${chosen} = select i1 ${present}, ptr ${rejection}, ptr ${first}`);
+            first = chosen;
+        }
+        // The entries' reaction jobs.
+        this.emitCoroAwait(null);
+        const failed = B.tmp();
+        B.line(`${failed} = icmp ne ptr ${first}, null`);
+        const fulfilled = B.newLabel("pa.fulfilled");
+        const rejected = B.newLabel("pa.reject");
+        const join = B.newLabel("pa.join");
+        B.condBr(failed, rejected, fulfilled);
+        B.startBlock(fulfilled);
+        this.emitCoroAwait(null);
+        B.br(join);
+        B.startBlock(rejected);
+        this.declare(`declare void @scr_coro_await_void(ptr)`);
+        this.emitCoroAwait(first);
+        B.line(`call void @scr_coro_await_void(ptr ${first})`);
+        B.br(join);
+        B.startBlock(join);
+        // The rejections are released here, only where an entry threw, rather
+        // than by the frame, which releases each slot whether or not it holds a
+        // promise.
+        this.declare(`declare void @scr_promise_release(ptr)`);
+        for (const slot of rejections) {
+            const rejection = B.tmp();
+            const present = B.tmp();
+            B.line(`${rejection} = load ptr, ptr ${slot}`);
+            B.line(`${present} = icmp ne ptr ${rejection}, null`);
+            const release = B.newLabel("pa.release");
+            const after = B.newLabel("pa.released");
+            B.condBr(present, release, after);
+            B.startBlock(release);
+            B.line(`call void @scr_promise_release(ptr ${rejection})`);
+            B.br(after);
+            B.startBlock(after);
+        }
+        this.disownSlots(rejections.map((ptr) => ({ ptr })));
+        this.emitPendingCheck();
+        return out;
+    }
     emitAsyncAwaitCall(fn, argPackLines, adopt = false) {
         return emitAsyncAwaitCall(this, fn, argPackLines, adopt);
     }
@@ -1503,6 +2196,7 @@ export class LlEmitter {
             };
             this.literals.set(text, lit);
         }
+        this.journal?.entry("literal", text, lit);
         const name = `@${lit.sym}`;
         this.immortalValues.add(name);
         return name;
@@ -1512,6 +2206,7 @@ export class LlEmitter {
     literalEquals(text) {
         const literal = this.internLiteral(text);
         const name = `@sc_streq_${literal.slice("@sc_lit_".length)}`;
+        this.journal?.entry("literalEquality", text, name);
         if (!this.literalEqualities.has(text)) {
             this.literalEqualities.set(text, name);
             if (Buffer.byteLength(text, "utf8") > INLINE_LITERAL_BYTES) {
@@ -1538,6 +2233,7 @@ export class LlEmitter {
             lit = { sym: this.contentSymbol("sc_bigint_", key), value };
             this.bigintLiterals.set(key, lit);
         }
+        this.journal?.entry("bigint", key, { sym: lit.sym, value: lit.value.toString() });
         const name = `@${lit.sym}`;
         this.immortalValues.add(name);
         return name;
@@ -1550,8 +2246,19 @@ export class LlEmitter {
             c = { sym: this.contentSymbol("sc_cs_", text), len: Buffer.byteLength(text, "utf8") };
             this.cstrs.set(text, c);
         }
+        this.journal?.entry("cstr", text, c);
         return `@${c.sym}`;
     }
+    /** The method-id slot for a constant method name (methodIdSlots). */
+    methodIdSlot(name) {
+        let sym = this.methodIdSlots.get(name);
+        if (!sym) {
+            sym = this.contentSymbol("sc_mid_", name);
+            this.methodIdSlots.set(name, sym);
+        }
+        this.journal?.entry("methodIdSlot", name, sym);
+        return `@${sym}`;
+    }
     needBadTag() {
         this.needsBadTag = true;
     }
@@ -1565,6 +2272,7 @@ export class LlEmitter {
             sym = this.contentSymbol("sc_map_ops_", body);
             this.mapOpsConsts.set(body, sym);
         }
+        this.journal?.entry("mapOps", body, sym);
         return `@${sym}`;
     }
     /** The interned immortal instance for a UNIT arm of a union — asserts
@@ -1588,6 +2296,7 @@ export class LlEmitter {
             sym = `sc_unit_${this.unitInstances.size}`;
             this.unitInstances.set(key, sym);
         }
+        this.journal?.entry("unit", key, sym);
         const name = `@${sym}`;
         this.immortalValues.add(name);
         return name;
@@ -1600,6 +2309,7 @@ export class LlEmitter {
             sym = `sc_retype_guard_${this.retypeGuards.size}`;
             this.retypeGuards.set(unionId, sym);
         }
+        this.journal?.entry("retype", unionId, sym);
         return `@${sym}`;
     }
     /** The immortal ABSENT state of an undefined-armed record field slot
@@ -1618,6 +2328,7 @@ export class LlEmitter {
             sym = `sc_absent_${this.absentInstances.size}`;
             this.absentInstances.set(unionId, sym);
         }
+        this.journal?.entry("absent", unionId, sym);
         const name = `@${sym}`;
         this.immortalValues.add(name);
         return name;
@@ -1658,6 +2369,7 @@ export class LlEmitter {
         return out;
     }
     declare(decl) {
+        this.journal?.entry("decl", decl, null);
         this.decls.add(decl);
     }
     needOom() {
@@ -1998,8 +2710,10 @@ export class LlEmitter {
      * releases the dummy (NULL for refcounted kinds) harmlessly. A scalar
      * call result of the function's return type may be passed as the unwind's
      * dummy value (see emitUnwind). `poll` marks a worker termination poll
-     * (function entry or loop budget), whose test must stay ordered. */
-    emitPendingCheck(passThrough, poll = false) {
+     * (function entry or loop budget), whose test must stay ordered. A
+     * `guard` (an i1) limits the test to the paths where it is true: false
+     * where the joined call could not have left anything pending. */
+    emitPendingCheck(passThrough, poll = false, guard) {
         const through = passThrough !== undefined &&
             this.llType(passThrough.type) === this.llType(this.currentReturnType) &&
             (passThrough.type.kind === "f64" || passThrough.type.kind === "bool")
@@ -2008,6 +2722,13 @@ export class LlEmitter {
         const B = this.B;
         if (B.isTerminated())
             return;
+        let skip;
+        if (guard !== undefined) {
+            const test = B.newLabel("exc.t");
+            skip = B.newLabel("exc.n");
+            B.condBr(guard, test, skip);
+            B.startBlock(test);
+        }
         if (this.mod.lib !== undefined) {
             this.declare(`declare zeroext i1 @scr_exc_pending()`);
             const p = B.tmp();
@@ -2018,6 +2739,10 @@ export class LlEmitter {
             B.startBlock(lu);
             this.emitUnwind(through);
             B.startBlock(lk);
+            if (skip !== undefined) {
+                B.br(skip);
+                B.startBlock(skip);
+            }
             return;
         }
         // Executables test the active exception cell's kind inline (its first
@@ -2094,6 +2819,10 @@ export class LlEmitter {
         B.startBlock(lu);
         this.emitUnwind(through);
         B.startBlock(lk);
+        if (skip !== undefined) {
+            B.br(skip);
+            B.startBlock(skip);
+        }
     }
     /** After a runtime call that ALWAYS leaves an exception pending (the
      * compiler-resolved Node throws): the pending test would always answer
@@ -2641,13 +3370,63 @@ export class LlEmitter {
      * 1 on hierarchy members, then the flattened field list. Runtime error
      * classes GEP through %ScrError (their structs live in the runtime; the
      * def's [name, message, %code, %cause] order matches the layout). */
-    classFieldPtr(objName, className, field) {
+    classFieldPtr(objName, className, field, refs = "pointer") {
         const meta = this.classMetaOf(className);
-        const { index, type } = classFieldIndex(meta, field);
+        const { index, type, compressed } = classFieldIndex(meta, field, refs);
         const p = this.B.tmp();
         this.B.line(`${p} = getelementptr inbounds %${classStructSym(className)}, ptr ${objName}, i64 0, i32 ${index}`);
         this.markFieldPointer(p, field);
-        return { ptr: p, type, inline: this.inlineUnions.classField(className, field) };
+        if (compressed)
+            this.compressedFieldPtrs.add(p);
+        return { ptr: p, type, inline: this.inlineUnions.classField(className, field), compressed };
+    }
+    /** Whether values of `t` are NULL or a compact class instance: `C`,
+     * `C | undefined` or `C | null` for a compact class `C`. `C | null |
+     * undefined` is not: its null is a sentinel outside the region. */
+    compactRefType(t, isCompact = (name) => this.classMeta.get(name)?.compact === true) {
+        if (t.kind === "object")
+            return isCompact(t.className);
+        if (t.kind !== "union")
+            return false;
+        const single = this.nullableUnions.single(t.unionId);
+        return (single !== null &&
+            single.nullTag < 0 &&
+            single.arm.kind === "object" &&
+            isCompact(single.arm.className));
+    }
+    /** Whether arrays of `elem` hold 32-bit references (SCR_ELEM_CREF). */
+    compactArrayElem(elem) {
+        return this.compactRegion && this.compactRefType(elem);
+    }
+    /** Loads the reference a field pointer addresses: a pointer, or the
+     * decoded 32-bit reference of a compressed field (compressedFieldPtrs).
+     * `tagged`: the load carries the field's alias tags. */
+    loadRef(ptr, tagged = true) {
+        const B = this.B;
+        const v = B.tmp();
+        const tags = tagged ? this.fieldAliasAttachment(ptr) : "";
+        if (!this.compressedFieldPtrs.has(ptr)) {
+            B.line(`${v} = load ptr, ptr ${ptr}${tags}`);
+            return v;
+        }
+        const idx = B.tmp();
+        B.line(`${idx} = load i32, ptr ${ptr}${tags}`);
+        for (const line of compactRefLoadLines(idx, v, `${v}.r`))
+            B.line(line.trimStart());
+        return v;
+    }
+    /** Stores `value` (a pointer) through a field pointer: as is, or encoded
+     * as the 32-bit reference of a compressed field. */
+    storeRef(ptr, value) {
+        const B = this.B;
+        if (!this.compressedFieldPtrs.has(ptr)) {
+            B.line(`store ptr ${value}, ptr ${ptr}${this.fieldAliasAttachment(ptr)}`);
+            return;
+        }
+        const idx = B.tmp();
+        for (const line of compactRefStoreLines(value, idx, `${idx}.r`))
+            B.line(line.trimStart());
+        B.line(`store i32 ${idx}, ptr ${ptr}${this.fieldAliasAttachment(ptr)}`);
     }
     /** The dynamic class's preorder number (borrowed object; the static class
      * names the struct spelling and where the number is, classPreLines). */
@@ -2667,6 +3446,7 @@ export class LlEmitter {
             const meta = this.classMetaOf(className);
             this.classObjs.set(className, { nameSym: this.internLiteral(classJsName(meta.def)) });
         }
+        this.journal?.entry("classObj", className, this.classObjs.get(className));
         return mangleClassObj(className);
     }
     // ── record plumbing ─────────────────────────────────────────────────────
@@ -2754,6 +3534,8 @@ export class LlEmitter {
             const { tag, bits } = loadInlineUnion(B, ptr);
             return stackUnionBox(B, this.sizeType, tag, bits);
         }
+        if (this.compressedFieldPtrs.has(ptr))
+            return this.loadRef(ptr);
         const fieldTy = llFieldType(t, false);
         const raw = B.tmp();
         B.line(`${raw} = load ${fieldTy}, ptr ${ptr}${this.fieldAliasAttachment(ptr)}`);
@@ -2778,8 +3560,7 @@ export class LlEmitter {
     replaceField(ptr, type, inline, v) {
         if (!inline && isRefCounted(type)) {
             this.toHeap(v);
-            const old = this.B.tmp();
-            this.B.line(`${old} = load ptr, ptr ${ptr}`);
+            const old = this.loadRef(ptr, false);
             this.storeField(ptr, type, v.name, false);
             this.releaseHeap(old, type);
             return;
@@ -2802,6 +3583,10 @@ export class LlEmitter {
             storeInlineUnion(B, ptr, tag, bits);
             return;
         }
+        if (this.compressedFieldPtrs.has(ptr)) {
+            this.storeRef(ptr, value);
+            return;
+        }
         const fieldTy = llFieldType(t, false);
         if (fieldTy !== "i8") {
             B.line(`store ${fieldTy} ${value}, ptr ${ptr}${this.fieldAliasAttachment(ptr)}`);
@@ -2850,12 +3635,12 @@ export class LlEmitter {
     // ── bindings ────────────────────────────────────────────────────────────
     /** A binding's storage: a module global, a plain local slot, or a boxed
      * local (the slot holds the capture BOX; access goes through it). */
-    matchBytesLoopVersion(s, counted) {
-        const fn = this.bytesLoopFunction;
+    matchBytesLoopVersion(s, counted, paired = null) {
+        const fn = LOOPS.of(this).bytesLoopFunction;
         if (!fn)
             return null;
-        this.bytesLoopEntries ??= findInitializedByteLoopBindings(fn);
-        const initialized = this.bytesLoopEntries.get(s);
+        LOOPS.of(this).bytesLoopEntries ??= findInitializedByteLoopBindings(fn);
+        const initialized = LOOPS.of(this).bytesLoopEntries.get(s);
         if (!initialized)
             return null;
         const invariantGlobals = new Set(this.stableGlobals);
@@ -2868,7 +3653,10 @@ export class LlEmitter {
             ranges: this.integerRanges,
             initialized,
             proven: this.bytesBounds,
-        });
+            workers: this.mod.workers === true,
+            owned: this.bytesOwned,
+            scalarStrings: new Set(this.stringSlices.keys()),
+        }, paired);
     }
     /** The alias tag of a whole-slot load of a binding (module globals only). */
     slotAlias(id) {
@@ -2907,6 +3695,24 @@ export class LlEmitter {
         this.B.line(`${b} = load ptr, ptr ${slot}`);
         return b;
     }
+    /** The function a call through `callee` is known to reach (a literal
+     * closure, or a binding the constant-callback census resolves) and the
+     * entry it calls directly. Async and generator functions stay indirect. */
+    knownCallbackTarget(callee) {
+        const knownName = callee.kind === "closure"
+            ? callee.fnName
+            : callee.kind === "varRef"
+                ? this.currentConstantCallbacks.get(callee.localId)
+                : undefined;
+        const known = knownName ? this.fnByName.get(knownName) : undefined;
+        if (!known || known.async || known.generator)
+            return undefined;
+        if (known.captures === undefined) {
+            this.fnValues.add(known.name);
+            return { known, direct: `@${mangleWrapper(known.name)}` };
+        }
+        return { known, direct: `@${this.callTarget(known.name)}` };
+    }
     /** The payload slot of a capture box (ScrBox.slot, field 5). */
     boxSlot(box) {
         const slot = this.B.tmp();
@@ -2919,13 +3725,15 @@ export class LlEmitter {
         const r = B.tmp();
         // Scalar payloads are read in place (scr_box_get_f64/bool are a
         // memcpy and a nonzero test of the same slot), so LLVM can keep a
-        // captured number in a register across a loop of calls.
+        // captured number in a register across a loop of calls. They have an
+        // alias category of their own: every other access to a box's payload
+        // is untagged or a runtime call.
         if (acc === "f64") {
-            B.line(`${r} = load double, ptr ${this.boxSlot(box)}`);
+            B.line(`${r} = load double, ptr ${this.boxSlot(box)}${this.memoryAliasAttachment("box:scalar")}`);
         }
         else if (acc === "bool") {
             const raw = B.tmp();
-            B.line(`${raw} = load i64, ptr ${this.boxSlot(box)}`);
+            B.line(`${raw} = load i64, ptr ${this.boxSlot(box)}${this.memoryAliasAttachment("box:scalar")}`);
             B.line(`${r} = icmp ne i64 ${raw}, 0`);
         }
         else {
@@ -2939,12 +3747,12 @@ export class LlEmitter {
         const B = this.B;
         const acc = boxAccess(t);
         if (acc === "f64") {
-            B.line(`store double ${value}, ptr ${this.boxSlot(box)}`);
+            B.line(`store double ${value}, ptr ${this.boxSlot(box)}${this.memoryAliasAttachment("box:scalar")}`);
         }
         else if (acc === "bool") {
             const raw = B.tmp();
             B.line(`${raw} = zext i1 ${value} to i64`);
-            B.line(`store i64 ${raw}, ptr ${this.boxSlot(box)}`);
+            B.line(`store i64 ${raw}, ptr ${this.boxSlot(box)}${this.memoryAliasAttachment("box:scalar")}`);
         }
         else {
             this.declare(`declare void @scr_box_set_ref(ptr, ptr)`);
@@ -2992,7 +3800,7 @@ export class LlEmitter {
         const acc = boxAccess(t);
         const cell = B.tmp();
         B.line(`${cell} = ${arrNewCall(this.shapeHost, t, "1")} ; TDZ cell`);
-        this.arrPush(cell, acc === "bool" ? "bool" : "f64", value);
+        this.arrPush(cell, acc === "bool" ? "bool" : "f64", value, null);
         this.declare(`declare void @scr_box_set_ref(ptr, ptr)`);
         B.line(`call void @scr_box_set_ref(ptr ${box}, ptr ${cell})`);
     }
@@ -3282,6 +4090,171 @@ export class LlEmitter {
     emitFunction(fn) {
         return emitFunction(this, fn);
     }
+    /** What this range emitter (chunkEmitter) hands the merging emitter, as
+     * plain data a worker process can write: its journal and the sets and
+     * flags its functions set. */
+    chunkResult() {
+        return {
+            entries: this.journal.entries,
+            flags: {
+                usesCoroutines: this.usesCoroutines,
+                usesTimers: this.usesTimers,
+                usesGenSlots: this.usesGenSlots,
+                needsUnionNone: this.needsUnionNone,
+                needsNullableAbsent: this.needsNullableAbsent,
+                needsOom: this.needsOom,
+                needsBadTag: this.needsBadTag,
+                needsBadKey: this.needsBadKey,
+                needsRetainBox: this.needsRetainBox,
+            },
+            publishedNamesSym: this.publishedNamesSym,
+            rcHelpers: this.rcHelpers === null ? [] : [...this.rcHelpers],
+            immortalValues: [...this.immortalValues],
+            fnValues: [...this.fnValues],
+            arraySearchKinds: [...this.arraySearchKinds],
+            recordCloneShapes: [...this.recordCloneShapes],
+            awaitCallees: [...this.awaitCallees],
+            adoptCallees: [...this.adoptCallees],
+            directAwaitCallees: [...this.directAwaitCallees],
+            inlineAwaitCallees: [...this.inlineAwaitCallees],
+        };
+    }
+    /** Merges a range emitter's result (chunkResult) into this emitter, in
+     * the range's order, and answers the rename of the range's text to this
+     * emitter's numbered helpers. Ranges merge in function order. */
+    mergeChunk(chunk) {
+        const names = new Map();
+        const tags = new Map();
+        // The range's helpers and table entries first, in its order; then the
+        // sets and flags, which replayed definitions must find as serial
+        // emission left them (a helper set guards the declarations its first
+        // request adds).
+        replayJournal(this, chunk.entries, names, tags);
+        const flags = chunk.flags;
+        this.usesCoroutines ||= flags.usesCoroutines;
+        this.usesTimers ||= flags.usesTimers;
+        this.usesGenSlots ||= flags.usesGenSlots;
+        this.needsUnionNone ||= flags.needsUnionNone;
+        this.needsNullableAbsent ||= flags.needsNullableAbsent;
+        this.needsOom ||= flags.needsOom;
+        this.needsBadTag ||= flags.needsBadTag;
+        this.needsBadKey ||= flags.needsBadKey;
+        this.needsRetainBox ||= flags.needsRetainBox;
+        this.publishedNamesSym ??= chunk.publishedNamesSym;
+        if (this.rcHelpers !== null)
+            for (const key of chunk.rcHelpers)
+                this.rcHelpers.add(key);
+        for (const name of chunk.immortalValues)
+            this.immortalValues.add(name);
+        for (const name of chunk.fnValues)
+            this.fnValues.add(name);
+        for (const kind of chunk.arraySearchKinds)
+            this.arraySearchKinds.add(kind);
+        for (const shapeId of chunk.recordCloneShapes)
+            this.recordCloneShapes.add(shapeId);
+        for (const name of chunk.awaitCallees)
+            this.awaitCallees.add(name);
+        for (const name of chunk.adoptCallees)
+            this.adoptCallees.add(name);
+        for (const name of chunk.directAwaitCallees)
+            this.directAwaitCallees.add(name);
+        for (const name of chunk.inlineAwaitCallees)
+            this.inlineAwaitCallees.add(name);
+        return renameChunk(names, tags);
+    }
+    /** Adds a content-named constant a chunk interned. Its symbol is this
+     * emitter's own: a digest collision retries in first-use order, which a
+     * chunk alone does not know. */
+    addContentEntry(into, key, entry, prefix, names) {
+        let own = into.get(key);
+        if (own === undefined) {
+            own = { ...entry, sym: this.contentSymbol(prefix, key) };
+            into.set(key, own);
+        }
+        if (own.sym !== entry.sym)
+            names.set(entry.sym, own.sym);
+    }
+    /** Applies a chunk's table entry (EmitJournal.entry) at its place in the
+     * chunk's order: a key this emitter lacks is added, numbered after its
+     * own entries where the table numbers them, and the chunk's name for it
+     * is renamed to this emitter's. */
+    applyJournalEntry(table, key, value, names, tags) {
+        switch (table) {
+            case "decl":
+                this.decls.add(key);
+                return;
+            case "literal":
+                this.addContentEntry(this.literals, key, value, "sc_lit_", names);
+                return;
+            case "literalEquality":
+                addEntry(this.literalEqualities, key, value);
+                return;
+            case "bigint":
+                {
+                    const entry = value;
+                    this.addContentEntry(this.bigintLiterals, key, { sym: entry.sym, value: BigInt(entry.value) }, "sc_bigint_", names);
+                }
+                return;
+            case "cstr":
+                this.addContentEntry(this.cstrs, key, value, "sc_cs_", names);
+                return;
+            case "mapOps": {
+                let own = this.mapOpsConsts.get(key);
+                if (own === undefined) {
+                    own = this.contentSymbol("sc_map_ops_", key);
+                    this.mapOpsConsts.set(key, own);
+                }
+                if (own !== value)
+                    names.set(value, own);
+                return;
+            }
+            case "methodIdSlot": {
+                let own = this.methodIdSlots.get(key);
+                if (own === undefined) {
+                    own = this.contentSymbol("sc_mid_", key);
+                    this.methodIdSlots.set(key, own);
+                }
+                if (own !== value)
+                    names.set(value, own);
+                return;
+            }
+            case "classObj":
+                addEntry(this.classObjs, key, value);
+                return;
+            case "retainWrapper":
+                addEntry(this.nullableUnions.retainWrappers, key, value);
+                return;
+            case "unit":
+                return addNumbered(this.unitInstances, key, value, "sc_unit_", names);
+            case "absent":
+                return addNumbered(this.absentInstances, key, value, "sc_absent_", names);
+            case "retype":
+                return addNumbered(this.retypeGuards, key, value, "sc_retype_guard_", names);
+            case "slots":
+                return addNumbered(this.threadSlotsBlocks, key, value, "@sc_slots_", names);
+            case "regex":
+                return addNumberedSymbol(this.regexInstances, key, value, "sc_re_", names);
+            case "templateStrings":
+                return addNumberedSymbol(this.templateStringsInstances, key, value, "sc_tsa_", names);
+            case "tag": {
+                let own = this.fieldAliasTags.get(key);
+                if (own === undefined) {
+                    own = 2 + this.fieldAliasTags.size * 2;
+                    this.fieldAliasTags.set(key, own);
+                }
+                if (own !== value)
+                    tags.set(value, own);
+                return;
+            }
+            default:
+                throw new InternalCompilerError(`llvm emitter bug: no journal table ${table}`);
+        }
+    }
+    /** An emitter for a range of this module's functions: the same facts,
+     * empty module-level tables, and a journal of what the range adds. */
+    chunkEmitter() {
+        return new LlEmitter(this.mod, { ...this.targetOptions, functionChunks: 1 }, new EmitJournal());
+    }
     /** The double-ABI entry of a function with an i32 entry: every caller
      * that is not a direct call (closures, dispatch, adapters, the runtime)
      * enters here. A pending exception passes through to its caller. */
@@ -3833,6 +4806,11 @@ export class LlEmitter {
                 if (cursor)
                     cursor.index = i;
                 this.stmtCursor = cursor;
+                const deferred = this.deferredPromiseAllLocal(stmts, i);
+                if (deferred !== null) {
+                    this.deferredPromiseAllEntries.set(stmts[i].localId, deferred);
+                    continue;
+                }
                 this.emitStmt(stmts[i]);
             }
         }
@@ -3872,11 +4850,15 @@ export class LlEmitter {
         const loop = s.kind === "while" || s.kind === "doWhile" || s.kind === "for" || s.kind === "forOf";
         if (loop)
             this.loopDepth++;
+        // An int32 kind loop's fast-copy write leaves for its resume point.
+        const kindResume = this.int32KindResume;
+        this.int32KindResume = this.int32Kinds?.resume.get(s) ?? null;
         try {
             this.emitStmtBody(s);
         }
         finally {
             this.B.debugLocation = previous;
+            this.int32KindResume = kindResume;
             if (loop)
                 this.loopDepth--;
         }
@@ -4200,6 +5182,7 @@ export class LlEmitter {
             sym = `@sc_slots_${this.threadSlotsBlocks.size}`;
             this.threadSlotsBlocks.set(name, sym);
         }
+        this.journal?.entry("slots", name, sym);
         return sym;
     }
     /** InternTable's runtime calls (scr_itable.c). Table and entry handles
@@ -4353,6 +5336,20 @@ export class LlEmitter {
             return this.publishWalkersCache;
         const byPre = [...this.classMeta.values()].sort((a, b) => a.pre - b.pre);
         this.publishWalkersCache = new PublishWalkers({
+            // Journal hooks only on emitters that can emit ranges (chunk
+            // emitters, and emitters whose workers take a journal after the
+            // fork), so the host's optional calls cost nothing otherwise.
+            journalAllocated: !this.journaled
+                ? undefined
+                : (name, op, args) => this.journal?.allocated(name, op, args),
+            journalBuilt: !this.journaled ? undefined : () => this.journal?.built(),
+            journalOpened: !this.journaled ? undefined : (op) => this.journal?.opened(op),
+            journalUsed: !this.journaled
+                ? undefined
+                : (name, op, args) => this.journal?.used(name, op, args),
+            journalEntry: !this.journaled
+                ? undefined
+                : (table, key, value) => this.journal?.entry(table, key, value),
             declare: (decl) => this.declare(decl),
             cstr: (text) => this.cstr(text),
             sizeType: this.sizeType,
@@ -4376,14 +5373,16 @@ export class LlEmitter {
                     post: meta.post,
                     runtimeRooted: meta.root.def.runtime === true,
                     idInRc: meta.idInRc,
+                    compact: meta.compact,
                     // Inline scalar-union fields are plain bits: nothing to push.
                     fields: meta.def.fields.flatMap((f) => this.inlineUnions.classField(className, f.name)
                         ? []
                         : [
                             {
                                 name: f.name,
-                                index: classFieldIndex(meta, f.name).index,
+                                index: classFieldIndex(meta, f.name, "compressed").index,
                                 type: this.nullableFields.storageType(className, f.name, f.type),
+                                compressed: classFieldIndex(meta, f.name, "compressed").compressed,
                             },
                         ]),
                 };
@@ -4414,13 +5413,20 @@ export class LlEmitter {
     }
     /** Branches on "`obj` is published" (rc == SIZE_MAX, or a count of
      * UINT32_MAX in the low half for `count` i32: classes.ts
-     * LlClassMeta.idInRc); leaves the builder in the cold block and answers
-     * the continuation label. */
+     * LlClassMeta.idInRc, or the top bit of a compact header word for
+     * "compact": classes.ts COMPACT_PUBLISHED); leaves the builder in the cold
+     * block and answers the continuation label. */
     emitPublishedTest(obj, count = this.sizeType) {
         const B = this.B;
         const rc = B.tmp(), frozen = B.tmp(), expected = B.tmp();
-        B.line(`${rc} = load ${count}, ptr ${obj}`);
-        B.line(`${frozen} = icmp eq ${count} ${rc}, -1`);
+        if (count === "compact") {
+            B.line(`${rc} = load i32, ptr ${obj}`);
+            B.line(`${frozen} = icmp slt i32 ${rc}, 0`);
+        }
+        else {
+            B.line(`${rc} = load ${count}, ptr ${obj}`);
+            B.line(`${frozen} = icmp eq ${count} ${rc}, -1`);
+        }
         this.declare(`declare i1 @llvm.expect.i1(i1, i1)`);
         B.line(`${expected} = call i1 @llvm.expect.i1(i1 ${frozen}, i1 false)`);
         const cold = B.newLabel("pub.frozen"), ok = B.newLabel("pub.ok");
@@ -4428,6 +5434,33 @@ export class LlEmitter {
         B.startBlock(cold);
         return ok;
     }
+    /** Branches on "the array `arr` is frozen" (SCR_ARR_FROZEN in its storage
+     * flags, scr_array.h), or published too when `published`; like
+     * emitPublishedTest, leaves the builder in the cold block and answers the
+     * continuation label. */
+    emitFrozenArrayTest(arr, published) {
+        const B = this.B;
+        const sparep = B.tmp(), spare = B.tmp(), bit = B.tmp();
+        let frozen = B.tmp();
+        B.line(`${sparep} = getelementptr inbounds %ScrArr, ptr ${arr}, i32 0, i32 ${SCR_ARR_FIELD.spare}`);
+        B.line(`${spare} = load i16, ptr ${sparep}`);
+        B.line(`${bit} = and i16 ${spare}, ${SCR_ARR_FROZEN}`);
+        B.line(`${frozen} = icmp ne i16 ${bit}, 0`);
+        if (published) {
+            const rc = B.tmp(), immortal = B.tmp(), either = B.tmp();
+            B.line(`${rc} = load ${this.sizeType}, ptr ${arr}`);
+            B.line(`${immortal} = icmp eq ${this.sizeType} ${rc}, -1`);
+            B.line(`${either} = or i1 ${frozen}, ${immortal}`);
+            frozen = either;
+        }
+        this.declare(`declare i1 @llvm.expect.i1(i1, i1)`);
+        const expected = B.tmp();
+        B.line(`${expected} = call i1 @llvm.expect.i1(i1 ${frozen}, i1 false)`);
+        const cold = B.newLabel("arr.frozen"), ok = B.newLabel("arr.ok");
+        B.condBr(expected, cold, ok);
+        B.startBlock(cold);
+        return ok;
+    }
     publishedNamesSym = null;
     /** The class-name table the hierarchy field guards index by preorder. */
     publishedClassNamesDefs() {
@@ -4461,7 +5494,7 @@ export class LlEmitter {
             return;
         const B = this.B;
         const meta = className === null ? undefined : this.classMeta.get(className);
-        const ok = this.emitPublishedTest(obj, meta?.idInRc === true ? "i32" : this.sizeType);
+        const ok = this.emitPublishedTest(obj, meta?.compact === true ? "compact" : meta?.idInRc === true ? "i32" : this.sizeType);
         let owner;
         if (meta === undefined)
             owner = this.cstr("Object");
@@ -4482,14 +5515,24 @@ export class LlEmitter {
     }
     /** The frozen-array guard (scr_throw_published_array's ops): `index` and
      * `count` are doubles (the written index, the argument count). */
-    emitPublishedArrayGuard(arr, arrType, op, index = f64Lit(0), count = f64Lit(0)) {
-        if (this.publishedTypes?.containerGuarded(arrType) !== true)
+    emitPublishedArrayGuard(arr, arrType, op, index = f64Lit(0), count = f64Lit(0), third = null) {
+        const published = this.publishedTypes;
+        if (published?.containerGuarded(arrType) !== true)
             return;
         const B = this.B;
-        const ok = this.emitPublishedTest(arr);
-        this.declare(`declare zeroext i1 @scr_throw_published_array(i32, ptr, double, double)`);
+        const guards = published.arrayGuards(arrType);
+        const ok = guards.frozen
+            ? this.emitFrozenArrayTest(arr, guards.published)
+            : this.emitPublishedTest(arr);
         const threw = B.tmp();
-        B.line(`${threw} = call zeroext i1 @scr_throw_published_array(i32 ${op}, ptr ${arr}, double ${index}, double ${count})`);
+        if (third === null) {
+            this.declare(`declare zeroext i1 @scr_throw_published_array(i32, ptr, double, double)`);
+            B.line(`${threw} = call zeroext i1 @scr_throw_published_array(i32 ${op}, ptr ${arr}, double ${index}, double ${count})`);
+        }
+        else {
+            this.declare(`declare zeroext i1 @scr_throw_published_array_range(i32, ptr, double, double, double)`);
+            B.line(`${threw} = call zeroext i1 @scr_throw_published_array_range(i32 ${op}, ptr ${arr}, double ${index}, double ${count}, double ${third})`);
+        }
         const unwind = B.newLabel("pub.throw");
         B.condBr(threw, unwind, ok);
         B.startBlock(unwind);
@@ -4556,11 +5599,9 @@ export class LlEmitter {
         const nullable = this.nullableFieldGet(e);
         if (!nullable || e.kind !== "fieldGet")
             return this.emitReadReceiver(e);
-        const B = this.B;
         const receiver = this.emitReadReceiver(e.obj);
-        const { ptr } = this.classFieldPtr(receiver.name, e.className, e.field);
-        const p = B.tmp();
-        B.line(`${p} = load ptr, ptr ${ptr}${this.fieldAliasAttachment(ptr)}`);
+        const { ptr } = this.classFieldPtr(receiver.name, e.className, e.field, "compressed");
+        const p = this.loadRef(ptr);
         return { name: this.stackNullableBox(p, nullable), type: e.type };
     }
     /** A private stack box over a nullable-pointer field read whose payload
@@ -4572,9 +5613,8 @@ export class LlEmitter {
         if (!nullable || e.kind !== "fieldGet")
             throw new InternalCompilerError("llvm emitter bug: owned nullable stack of non-field");
         const receiver = this.emitReadReceiver(e.obj);
-        const { ptr } = this.classFieldPtr(receiver.name, e.className, e.field);
-        const p = this.B.tmp();
-        this.B.line(`${p} = load ptr, ptr ${ptr}${this.fieldAliasAttachment(ptr)}`);
+        const { ptr } = this.classFieldPtr(receiver.name, e.className, e.field, "compressed");
+        const p = this.loadRef(ptr);
         const owner = this.own({ name: this.retainFrame(p, nullable.arm), type: nullable.arm });
         return { box: this.stackNullableBox(owner.name, nullable), owner };
     }
@@ -4635,7 +5675,6 @@ export class LlEmitter {
      * retained payload of a borrowed box otherwise. Unlink-then-release like
      * every field store. */
     emitNullableFieldStore(obj, className, field, nullable, value) {
-        const B = this.B;
         let next;
         if (value.kind === "unionWrap" &&
             value.unionId === nullable.unionId &&
@@ -4660,10 +5699,9 @@ export class LlEmitter {
         else {
             next = this.unionToNullable(this.emitUnionProjection(value).name, nullable);
         }
-        const { ptr } = this.classFieldPtr(obj, className, field);
-        const old = B.tmp();
-        B.line(`${old} = load ptr, ptr ${ptr}`);
-        B.line(`store ptr ${next}, ptr ${ptr}${this.fieldAliasAttachment(ptr)}`);
+        const { ptr } = this.classFieldPtr(obj, className, field, "compressed");
+        const old = this.loadRef(ptr, false);
+        this.storeRef(ptr, next);
         this.releaseHeap(old, nullable.arm);
     }
     /** A union binding whose slot may hold a private stack box: stack locals
@@ -4780,11 +5818,25 @@ export class LlEmitter {
         return (this.jsIcSitesMemo ??= new JsIcSites(this.mod));
     }
     jsIcSite() {
-        return `@sc_js_ic_${this.jsIcSiteCount++}`;
+        const name = `@sc_js_ic_${this.jsIcSiteCount++}`;
+        this.journal?.site(name, "jsIcSite");
+        return name;
     }
     /** A fresh read-site cache for one constant-key dyn read. */
     dynReadIcSite() {
-        return `@sc_dyn_read_ic_${this.dynReadIcSites++}`;
+        const name = `@sc_dyn_read_ic_${this.dynReadIcSites++}`;
+        this.journal?.site(name, "dynReadIcSite");
+        return name;
+    }
+    /** A fresh speculative loop site: the global that counts its bailing
+     * entries in a row. */
+    speculativeLoopSite() {
+        const name = `@sc_spec_bails_${this.speculativeLoopSites++}`;
+        this.journal?.site(name, "speculativeLoopSite");
+        this.journal?.opened("speculativeLoopSite");
+        this.declare(`${name} = internal global i8 0`);
+        this.journal?.built();
+        return name;
     }
     dynKind(d) {
         return dynKind(this, d);
@@ -4861,8 +5913,8 @@ export class LlEmitter {
     tagInSet(uName, unionId, tags) {
         return tagInSet(this, uName, unionId, tags);
     }
-    arrPush(arr, acc, value) {
-        return arrPush(this, arr, acc, value);
+    arrPush(arr, acc, value, element) {
+        return arrPush(this, arr, acc, value, element);
     }
     emitArrayCopyLoop(dst, src, acc) {
         return emitArrayCopyLoop(this, dst, src, acc);
@@ -4903,8 +5955,8 @@ export class LlEmitter {
     emitBytesLength(elem, receiver, bytes) {
         return emitBytesLength(this, elem, receiver, bytes);
     }
-    emitBytesGet(elem, receiver, index, expr, inBounds = false, invalidNaN = false) {
-        return emitBytesGet(this, elem, receiver, index, expr, inBounds, invalidNaN);
+    emitBytesGet(elem, receiver, index, expr, inBounds = false, invalidNaN = false, owned = false) {
+        return emitBytesGet(this, elem, receiver, index, expr, inBounds, invalidNaN, owned);
     }
     emitToUint32(value, expr, uint32) {
         return emitToUint32(this, value, expr, uint32);
@@ -4959,8 +6011,8 @@ export class LlEmitter {
         const integer = this.emitToUint32(value.name, expr, value.uint32);
         this.B.line(`store i32 ${integer}, ptr ${slot}`);
     }
-    emitBytesSet(elem, receiver, index, value, indexExpr, expr, inBounds = false) {
-        return emitBytesSet(this, elem, receiver, index, value, indexExpr, expr, inBounds);
+    emitBytesSet(elem, receiver, index, value, indexExpr, expr, inBounds = false, owned = false) {
+        return emitBytesSet(this, elem, receiver, index, value, indexExpr, expr, inBounds, owned);
     }
     emitBytesIntrinsic(e) {
         return emitBytesIntrinsic(this, e);
@@ -5061,4 +6113,64 @@ export function adoptingAwaitOf(value) {
     });
     return found;
 }
+/** Adds `key` to `into` when it lacks it. */
+function addEntry(into, key, value) {
+    if (!into.has(key))
+        into.set(key, value);
+}
+/** Adds `key` to a numbered table when it lacks it, numbering it after the
+ * table's own entries (`prefix` and its index), and records the rename of
+ * the chunk's `name` for it. */
+function addNumbered(into, key, name, prefix, names) {
+    let own = into.get(key);
+    if (own === undefined) {
+        own = `${prefix}${into.size}`;
+        into.set(key, own);
+    }
+    if (own !== name)
+        names.set(name.replace(/^@/, ""), own.replace(/^@/, ""));
+}
+/** addNumbered for entries that keep their numbered name in `sym`. */
+function addNumberedSymbol(into, key, entry, prefix, names) {
+    let own = into.get(key);
+    if (own === undefined) {
+        own = { ...entry, sym: `${prefix}${into.size}` };
+        into.set(key, own);
+    }
+    if (own.sym !== entry.sym)
+        names.set(entry.sym, own.sym);
+}
+registerReplay("jsIcSite", (emitter) => emitter.jsIcSite());
+registerReplay("dynReadIcSite", (emitter) => emitter.dynReadIcSite());
+registerReplay("speculativeLoopSite", (emitter) => emitter.speculativeLoopSite());
+for (const op of [
+    "dyn.collectionDynOps",
+    "dyn.dynMatchHelper",
+    "dyn.jsonSchema",
+    "dyn.recordNameTable",
+    "dyn.jsonParseHelper",
+    "dyn.dynCheckHelper",
+    "dyn.toDynHelper",
+    "dyn.promiseDynAdapterHelper",
+    "dyn.dynFuncThunkHelper",
+    "dyn.dynFuncBoxHelper",
+    "dyn.dynFuncAdapterHelper",
+    "dyn.dynToStrHelper",
+    "dyn.dynIterNHelper",
+    "dyn.dynDestrCheckHelper",
+    "dyn.dynKeyGetHelper",
+    "dyn.dynComputedKeyGetHelper",
+    "dyn.caughtToDynHelper",
+    "dyn.messageListenerHelper",
+    "dyn.messageReaderHelper",
+])
+    registerReplay(op, (emitter, args) => emitter.dyn.replayHelper(op, args));
+for (const op of [
+    "walkers.jsonWriteHelper",
+    "walkers.recordFieldWriter",
+    "walkers.unionJoinHelper",
+])
+    registerReplay(op, (emitter, args) => emitter.walkers.replayHelper(op, args));
+for (const op of ["publish.walker", "publish.refusal"])
+    registerReplay(op, (emitter, args) => emitter.publishWalkers.replayHelper(op, args));
 //# sourceMappingURL=emitter.js.map