@scriptc/compiler 0.4.2 → 0.4.3

package/dist/backend/llvm/emitter.js

@@ -15,18 +15,21 @@ 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 } 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";
@@ -35,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";
@@ -52,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";
@@ -69,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";
@@ -78,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";
@@ -140,23 +147,58 @@ export function ffiCallbackDummyLl(callback) {
 export function lowRegionTarget(platform, sanitize) {
     return platform === "linux" && !sanitize;
 }
-export function emitLlvmModule(input, options = {}) {
+/** 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 = {}) {
     // IR validation, contracts and the frontend's disposal run after lowering without checks.
     relieveHeapPressure(true);
-    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();
+    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");
@@ -272,6 +314,8 @@ function countLocalMentions(body, id) {
 }
 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();
@@ -297,9 +341,11 @@ export class LlEmitter {
      * 32-bit references to compact class instances (LlClassMeta.compressed):
      * loadField/loadRef decode them and storeField/storeRef encode them. */
     compressedFieldPtrs = new Set();
-    /** Whether a class has compressed fields: main reserves the region before
-     * compiled code runs (scr_plr_init). */
-    usesCompactRefs = false;
+    /** 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
@@ -315,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
@@ -327,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);
@@ -430,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. */
@@ -478,6 +735,9 @@ 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). */
@@ -526,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
@@ -593,7 +856,7 @@ export class LlEmitter {
     /** 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));
+        return (this.runtimeFeaturesValue ??= moduleRuntimeFeatures(this.mod, this.nodeIndex));
     }
     /** Whether timer and tick scheduling goes through the *_als entry
      * points (RuntimeFeatures asyncContext). */
@@ -618,6 +881,11 @@ export class LlEmitter {
     get usesDynBuiltinStream() {
         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();
     dynPromiseAdapters = new Map();
@@ -706,14 +974,6 @@ 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();
@@ -725,7 +985,6 @@ export class LlEmitter {
      * async or generator body resumes with its locals in its frame, which
      * an entry alloca is not part of. */
     integerTempsEnabled = false;
-    countedLoopsEnabled = false;
     /** Speculative integer loops (speculative-integers.ts) run in this function. */
     speculativeLoopsEnabled = false;
     /** The fast copy of a speculative integer loop being emitted: its
@@ -739,6 +998,14 @@ export class LlEmitter {
      * (`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). */
@@ -756,20 +1023,14 @@ 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();
@@ -823,31 +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.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.initializerBindings = findInitializerBindings(mod, this.nodeIndex);
         // One walk finds the dynamic field stores every analysis below consults.
-        const dynamicStores = dynamicFieldStores(mod);
+        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, false, dynamicStores);
+        this.finalFields = analyzeFinalFields(mod, false, dynamicStores, this.nodeIndex);
         this.sizeType = options.pointerBits === 32 ? "i32" : "i64";
         this.ffiExtendNarrowIntegers =
             options.wasi === true || ffiExtendsNarrowIntegers(options.targetTriple);
@@ -896,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);
         }
@@ -904,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;
@@ -914,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, dynamicStores);
+        // 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 ?? []) {
@@ -951,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);
@@ -1003,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.
@@ -1022,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, dynamicStores);
+        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
@@ -1046,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,
@@ -1084,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);
@@ -1119,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.
@@ -1165,21 +1473,18 @@ export class LlEmitter {
                     const f = cls.fields[i];
                     if (this.inlineUnions.classField(cls.name, f.name))
                         return false;
-                    const t = f.type;
-                    if (t.kind === "object")
-                        return isCompact(t.className);
-                    if (t.kind !== "union")
-                        return false;
-                    const single = this.nullableUnions.single(t.unionId);
-                    if (single !== null)
-                        return (single.nullTag < 0 &&
-                            single.arm.kind === "object" &&
-                            isCompact(single.arm.className));
-                    const nullable = this.nullableFields.get(cls.name, f.name);
+                    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.usesCompactRefs = [...this.classMeta.values()].some((m) => m.compressed.some(Boolean));
+        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)
@@ -1777,7 +2082,7 @@ export class LlEmitter {
             B.startBlock(clean);
             if (acc === "ref")
                 this.toHeap(value);
-            this.arrPush(values, acc, value.name);
+            this.arrPush(values, acc, value.name, elem);
             B.br(next);
             B.startBlock(rejected);
             const promise = B.tmp();
@@ -1891,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;
@@ -1900,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) {
@@ -1926,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;
@@ -1938,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;
     }
@@ -1953,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
@@ -1976,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;
@@ -1988,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
@@ -2006,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;
@@ -2046,6 +2369,7 @@ export class LlEmitter {
         return out;
     }
     declare(decl) {
+        this.journal?.entry("decl", decl, null);
         this.decls.add(decl);
     }
     needOom() {
@@ -3056,6 +3380,24 @@ export class LlEmitter {
             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. */
@@ -3104,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 ─────────────────────────────────────────────────────
@@ -3292,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);
@@ -3312,7 +3655,8 @@ export class LlEmitter {
             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) {
@@ -3456,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})`);
     }
@@ -3746,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. */
@@ -4341,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--;
         }
@@ -4669,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
@@ -4822,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,
@@ -4906,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() {
@@ -4960,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);
@@ -5253,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);
@@ -5334,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);
@@ -5534,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