@scriptc/compiler 0.4.5 → 0.4.6

package/dist/backend/llvm/emitter.js

@@ -1,4 +1,6 @@
+import { loopEntryInlines } from "./loop-entry-versions.js";
 import { relieveHeapPressure } from "../../heap-pressure.js";
+import { analyzeFrameEscapes } from "./frame-escapes.js";
 import { wasmBoundsChecks } from "./wasm-modules.js";
 import { jsTruthy } from "./jsval.js";
 import { JsIcSites } from "../../ir/js-ic.js";
@@ -12,7 +14,7 @@ import { InternalCompilerError } from "../../errors.js";
 import { serializeModuleParts } from "../../ir/serialize.js";
 import { createHash } from "node:crypto";
 import { endsWithJump, matchFieldSelfConcat, readsArraySlot, streamTypedRefEligible, undefinedArmTag, } from "../../ir/analysis.js";
-import { loopTestsEveryIteration } from "../loop-polls.js";
+import { containsLoop, 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, classValueAbiEquals, } from "../../ir/ir.js";
 import { moduleRuntimeFeatures } from "../../ir/runtime-features.js";
 import { captureFreeFunctions, observesStacks } from "../stack-observations.js";
@@ -27,7 +29,10 @@ import { EmitJournal, registerReplay, renameChunk, replayJournal, } from "./emit
 import { specializeNumericCalls } from "../../ir/numeric-call-specialization.js";
 import { versionLoopBoundParameters } from "../../ir/parameter-versions.js";
 import { inlineExpressionFunctions } from "../../ir/expression-inlining.js";
+import { inlineArrayReads, NO_INLINE_ARRAYS, planInlineArrays, } from "../../ir/inline-arrays.js";
+import { inlineArraysApply, programLifetimeClassOf } from "./inline-arrays.js";
 import { pairRowSums } from "../../ir/row-pairs.js";
+import { jamSaturatingLoops } from "../../ir/saturating-loop-jams.js";
 import { allocatedLiteral, fillAllocationLength, int32ArrayKey, selectInt32Arrays, } from "../../ir/int32-arrays.js";
 import { everyExpr, everyExprChild, everyStmtChild, everyStmtList } from "../../ir/traverse.js";
 import { INT32_RANGE, withinInt32, } from "../../ir/integer-ranges.js";
@@ -46,13 +51,16 @@ import { unitSafeFunctions } from "./string-unit-versions.js";
 import { stringScanInline } from "./string-reads.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 { findIntegerClones, NO_INTEGER_CLONES, } from "./integer-clones.js";
+import { writeRepresentationReport } from "./repr-report.js";
+import { heapCensusOf } from "./heap-census.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";
 import { computeMayThrow } from "../may-throw.js";
-import { UNWIND_PERSONALITY, UNWIND_RAISE, UNWIND_RAISE_DECLARATION, UNWIND_RESUME, UNWIND_SLOT, UnwindAbiViolation, bridgePlainUnwindCalls, unwindAbiFunctions, } from "./unwind-abi.js";
+import { UNWIND_PERSONALITY, UNWIND_RAISE, UNWIND_RAISE_DECLARATION, UNWIND_RESUME_DECLARATION, UNWIND_RESUME, UNWIND_SLOT, UnwindAbiViolation, bridgePlainUnwindCalls, unwindAbiFunctions, } from "./unwind-abi.js";
+import { cloneForCpuDispatch } from "./cpu-dispatch.js";
 import { mangleAsyncInlineAwaitCall, mangleAsyncSpawn, mangleBorrowedFunction, mangleClassObj, mangleFnClosure, mangleFunction, mangleGenSpawn, mangleGlobal, mangleLocal, mangleRecordStruct, mangleWrapper, mangleBorrowingWrapper, } from "../mangle.js";
 import { analyzeCallLifetimes } from "./call-lifetimes.js";
 import { stackObjectStruct, } from "./stack-objects.js";
@@ -61,9 +69,9 @@ import { BlockBuilder } from "./blocks.js";
 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 { borrowsCheckedNarrow, CheckedNarrows } from "./checked-narrows.js";
 import { emitDenseArraySet, emitDenseSlotUnlink, SCR_ELEM_I32, } from "./dense-array-access.js";
-import { matchMapRead } from "./map-read-lifetimes.js";
+import { matchMapRead, pointerMapGet } from "./map-read-lifetimes.js";
 import {} from "./map-entry-fusion.js";
 import { emitBorrowedFieldSequence, guardedValue } from "./borrowed-receivers.js";
 import { emitBorrowedInputs } from "./borrowed-inputs.js";
@@ -80,7 +88,7 @@ import { AmbientReceiverReaders, findConstantCallbacks } from "./constant-callba
 import { findLentRecordFields, findLentStringParameters, findRecordFieldProducers, } from "./string-slices.js";
 import { LazyCaptures } from "./lazy-captures.js";
 import { StackCaptures } from "./stack-captures.js";
-import { emitFieldAbsentTest, f64Lit, SCR_ARR_FIELD, SCR_ARR_FROZEN } from "./common.js";
+import { CLOSURE_KIND, 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";
@@ -97,7 +105,7 @@ import { dynKind, raceAdapterFor, genResultThunkFor, childExitThunkFor, childExi
 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";
 import { emitIntegerLoopIndex, emitBytesIndex, emitBytesData, emitBytesLength, emitBytesGet, emitToUint32, emitBytesSet, emitBytesIntrinsic, } from "./expr-bytes.js";
-import { emitRegexIntrinsic, emitRecordKeyGet, keyedRecordReadInto } from "./expr-records.js";
+import { borrowedRecordKeyGetOr, emitRecordKeyGet, emitRegexIntrinsic, immortalDefault, keyedRecordReadInto, pointerRecordKeyGet, } from "./expr-records.js";
 import { dynPromiseAdapter, streamTypedRefCommitAdapter, liveDynUnionRefAdapter, streamTypedRefBoxValue, streamTypedRefMaterializeAdapter, streamFromArrayAdapter, } from "./expr-stream-bridges.js";
 import { emitWebLibCall, emitDynamicLibCall, emitFilesystemLibCall, emitPathUrlLibCall, emitPrimitiveLibCall, } from "./lib-filesystem.js";
 import { emitChildProcessLibCall, emitAsyncContextLibCall, emitProcessLibCall, emitErrorsEventsLibCall, } from "./lib-process.js";
@@ -106,14 +114,18 @@ import { emitNetworkHttpLibCall } from "./lib-network.js";
 import { emitAssertInspectLibCall, emitIoLibCall, emitGenericLibCall, emitLibCall, } from "./lib-dispatch.js";
 import { assignCompactLayouts, buildClassGraph, classFieldTypes, classMembershipIntervals, classFieldIndex, compactRefLoadLines, compactRefStoreLines, classPreLines, classStructSym, programLifetimeClass, } from "./classes.js";
 import { LifetimeRegions, REGION_TYPES } from "./regions.js";
+import { arenaAware, arenaCurrentAddress, arenaNewSym, arenasRequested, planArenas, } from "./arenas.js";
+import { children } from "./region-ir.js";
 import { LlDyn, recordDynKeepsIdentity } from "./dyn.js";
 import { VirtualBorrows } from "./virtual-borrows.js";
+import { planRecordViews, recordViewFieldPtr } from "./record-views.js";
 import { LlvmUnsupportedError } from "./unsupported.js";
 import { LlWalkers } from "./walkers.js";
-import { isObjectArm, NULLABLE_ABSENT, NULLABLE_NULL, NullableUnions } from "./nullable-unions.js";
+import { isObjectArm, isPayloadTag, NULLABLE_ABSENT, NULLABLE_NULL, NullableUnions, pointerTagFn, } from "./nullable-unions.js";
+import { classUnionHeaders, emitClassUnionHelpers } from "./class-unions.js";
 import { emitNullablePresent, emitUnionPeek, emitUnionTag } from "./union-repr.js";
 import { emitConcatInputs, emitMixedConcat, numberPart, stringParts, } from "./string-construction.js";
-import { arrNewCall, boxAccess, elemAccess, 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, traceAdapter, } from "./shapes.js";
 import { INLINE_LITERAL_BYTES } from "./string-literal-equality.js";
 import { inlinableNumberFunction, withSpeculativeValue, } from "./speculative-integers.js";
 import { emitFfiCallbackDefs, emitLibDefs, emitModuleParts, emitParts, helperDefs, workerMinFunctions, } from "./emit-module.js";
@@ -121,6 +133,7 @@ import { forkedAnalysis } from "./forked-analysis.js";
 import { emitLoopCopies, emitSpeculativeWrite, emitStmtBody, emitStringSelfConcatAssign, emitSwitch, emitTryCatch, } from "./emit-statements.js";
 import { emitArgPackAndTrampolinePrologue, emitAsyncAwaitCall, emitAsyncScaffolding, emitFunction, emitGenScaffolding, emitWasiFulfill, fiberlessAsyncFunctions, parkingFunctions, } from "./emit-function.js";
 import { analyzeBorrowedReturns, canBorrowCallArgument, canBorrowReceiver, canStackReceiver, emitReadReceiver, fieldAliasMetadata, isStackUnionSource, } from "./receivers.js";
+import { findLoopCallees } from "./loop-callees.js";
 export { LlvmUnsupportedError } from "./unsupported.js";
 export function ffiCallbackDummyLl(callback) {
     switch (callback.returns) {
@@ -221,6 +234,13 @@ function resultEntryTargets(mod) {
             targets.add(name);
     return targets;
 }
+/** The reads and constructions of inline array fields prepared for their
+ * layout (ir/inline-arrays.ts), where the target keeps them inline. */
+function inlineArraysPass(options, mod) {
+    if (!inlineArraysApply(mod, options))
+        return mod;
+    return inlineArrayReads(mod, planInlineArrays(mod, programLifetimeClassOf(mod)));
+}
 /** 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
@@ -258,7 +278,9 @@ function moduleEmitter(input, options) {
     // Keep source storage intact for debugger inspection in dev builds.
     if (options.debugSources !== undefined)
         return new LlEmitter(mod, options, null, null);
-    const passed = versionParameters(addRecordResultEntries(scalarizeLiteralResults(scalarizeNumericRecords(specializeCallbackCalls(specializeNumericCalls(pairRowSums(inlineExpressionFunctions(foldConstantGlobals(copyStableCaptures(resolveSelfCaptures(hoistFinalFieldReads(freezeInitOnlyGlobals(holdCharLocalsAsUnits(dropUnwrittenPropertyBags(runPairedWhileLoopsAsFor(mod)))))))))), mangleFunction), mangleFunction)))));
+    const timing = options.timing ?? (() => { });
+    const passed = versionParameters(addRecordResultEntries(scalarizeLiteralResults(scalarizeNumericRecords(specializeCallbackCalls(specializeNumericCalls(pairRowSums(jamSaturatingLoops(inlineArraysPass(options, inlineExpressionFunctions(foldConstantGlobals(copyStableCaptures(resolveSelfCaptures(hoistFinalFieldReads(freezeInitOnlyGlobals(holdCharLocalsAsUnits(dropUnwrittenPropertyBags(runPairedWhileLoopsAsFor(mod)))))))))))), mangleFunction), mangleFunction)))));
+    timing("llvm-emit-rewrites");
     let emitted = selectInt32Arrays(passed, proven, resultEntryTargets);
     let prepared = rounds.last;
     // A proof that revised functions analyzed the module of the functions it
@@ -280,7 +302,10 @@ function moduleEmitter(input, options) {
     }
     if (process.env["SCRIPTC_INT32_VERIFY"] === "1")
         verifyInt32Selection(passed, emitted, prepared?.mod === emitted ? prepared : null);
-    return new LlEmitter(emitted, options, null, prepared?.mod === emitted ? prepared : null);
+    timing("llvm-emit-int32");
+    const emitter = new LlEmitter(emitted, options, null, prepared?.mod === emitted ? prepared : null);
+    timing("llvm-emit-analyses");
+    return emitter;
 }
 /** SCRIPTC_INT32_VERIFY=1: throws unless the selection with revisions
  * (`emitted`, and the analysis the emitter takes over) is the one rounds
@@ -310,7 +335,9 @@ function emitModuleText(input, options) {
     for (let excluded = options.unwindExcluded ?? new Set();;) {
         const emitter = moduleEmitter(input, { ...options, unwindExcluded: excluded });
         try {
-            return emitter.emitParts();
+            const parts = emitter.emitParts();
+            writeRepresentationReport(emitter);
+            return parts;
         }
         catch (error) {
             if (!(error instanceof UnwindAbiViolation))
@@ -350,6 +377,9 @@ export function llStrBytes(text) {
 const NO_BORROWED = new Set();
 /** The nodes that write a binding by its id (numberGlobalWriters). */
 const GLOBAL_WRITE_KINDS = ["assign", "varDecl", "assignExpr", "incDec"];
+/** workerLoopBudget's answer for a loop that polls on every iteration
+ * instead of counting down in a slot. */
+const POLL_EVERY_ITERATION = "%worker.poll.every";
 /** Runtime library calls (readsLoopMetrics). */
 const LIB_CALL_KINDS = ["libCall"];
 /** [A-Za-z0-9_] */
@@ -360,14 +390,20 @@ function isIdentifierByte(code) {
         code === 95);
 }
 /** Runtime entry points (and await-call entries) that may park the running
- * execution context, as they appear in emitted function text. */
-export const SUSPENDS = /@(?:scr_(?:await_|module_await\b|promise_await_settled\b|test_sub\b|gen_yield_|async_gen_|fiber_)|sc_a[wd]_)/;
+ * execution context, as they appear in emitted function text. An async
+ * generator's next, return and throw only queue a request and run its body
+ * to its next suspension, which returns to the caller, and the body's own
+ * bookkeeping calls do not suspend it. */
+export const SUSPENDS = /@(?:scr_(?:await_|module_await\b|promise_await_settled\b|test_sub\b|gen_yield_|async_gen_(?!new\b|next_|return_|throw\b|hop_done\b)|fiber_)|sc_a[wd]_)/;
 /** The suspensions of a fiber body's own awaits, which its stackless
  * coroutine form suspends itself at instead. */
-const AWAIT_SUSPENSIONS = /@(?:scr_await_(?:void|f64|bool|str|ref|hop)\b|sc_a[wd]_[A-Za-z0-9_]+)/g;
+const AWAIT_SUSPENSIONS = /@(?:scr_await_(?:void|f64|bool|str|ref|hop|dyn_value)\b|sc_a[wd]_[A-Za-z0-9_]+)/g;
+/** The suspensions of a fiber generator body's own yields, which its
+ * coroutine form also suspends itself at. */
+const YIELD_SUSPENSIONS = /@scr_(?:gen_yield_(?:f64|bool|ref))\b/g;
 /** SUSPENDS in a stackless coroutine body, whose frame bookkeeping reads its
  * own fiber and promise. */
-const COROUTINE_SUSPENDS = /@(?:scr_(?:await_|module_await\b|promise_await_settled\b|test_sub\b|gen_yield_|async_gen_|fiber_(?!self\b|promise\b))|sc_a[wd]_)/;
+const COROUTINE_SUSPENDS = /@(?:scr_(?:await_|module_await\b|promise_await_settled\b|test_sub\b|gen_yield_|async_gen_(?!new\b|next_|return_|throw\b|hop_done\b)|fiber_(?!self\b|promise\b))|sc_a[wd]_)/;
 /** Captured bindings (boxes a body declares or receives) from which a
  * function compiles without LLVM optimization (see boxSlotCount). */
 export const UNOPTIMIZED_BOX_SLOTS = 512;
@@ -770,11 +806,13 @@ export class LlEmitter {
      * generator stacks) and so do debug builds (the debugger reads locals
      * from the native frame). */
     stacklessGenerators = false;
-    /** Async bodies that suspend only at their own awaits compile to the same
-     * switched coroutines on native targets (selectStacklessAsync), under the
-     * generators' conditions; library and Windows builds keep fibers. */
+    /** Async bodies that suspend only at their own awaits (and an async
+     * generator's yields) compile to the same switched coroutines on native
+     * targets (selectStacklessAsync), under the generators' conditions;
+     * library and Windows builds keep fibers. */
     stacklessAsyncAllowed = false;
-    /** The async functions selectStacklessAsync lowered as coroutines. */
+    /** The async functions and async generators selectStacklessAsync lowered
+     * as coroutines. */
     stacklessAsync = new Set();
     /** Some function in the module is lowered as a coroutine. */
     usesCoroutines = false;
@@ -794,7 +832,12 @@ export class LlEmitter {
     emitLibraryIdentity;
     runtimeAbiMarker;
     detachedExit;
+    nodeIslandModuleData;
     targetCpu;
+    /** Emitted functions carry `sanitize_address` (LlvmTargetOptions). */
+    sanitizeAttributes;
+    /** LlvmTargetOptions.cpuDispatch, where it applies. */
+    cpuDispatch;
     wasmBoundsChecks;
     /** Interned string literals: UTF-8 text → { symbol, byte length } —
      * first-use order, the runtime ABI’s determinism discipline. */
@@ -826,6 +869,9 @@ export class LlEmitter {
      * compiles it lazily on first use. The source/flags strings intern at
      * REGISTRATION (bodies emit before the literal table flushes). */
     regexInstances = new Map();
+    /** Build-time replacers: one per (pattern, flags, replacement) of a
+     * global substitution with a literal replacement (regex-matchers.ts). */
+    regexReplacers = new Map();
     /** Interned tagged-template strings objects: per-site key → { symbol,
      * interned cooked-literal refs }. One immortal ScrArr of string slots
      * per template SITE (the spec's per-occurrence identity — the C
@@ -849,6 +895,8 @@ export class LlEmitter {
     dyn;
     /** Explicit callback boundary for standalone layout and walker stages. */
     shapeHost;
+    /** The record view plan's target set (record-views.ts), shared by reference. */
+    recordViewTargets = null;
     /** External declarations, in first-use order. */
     decls = new Set();
     /** Declared functions referenced as values: each needs an env-signature
@@ -892,6 +940,9 @@ export class LlEmitter {
     /** The current function's fused string-key Map get-then-set pairs (map-entry-fusion.ts). */
     mapEntryFusion = null;
     callLifetimes;
+    /** The locals whose value never leaves its frame (frame-escapes.ts), for
+     * class instances with reference fields in frame storage. */
+    frameEscapes = null;
     constantCallbacks;
     currentConstantCallbacks = new Map();
     /** The current function's running maximum and minimum updates, whose
@@ -969,6 +1020,9 @@ export class LlEmitter {
     /** Functions that check the native stack guard on entry
      * (stackCheckedFunctions); null where the runtime has no guard. */
     stackChecks;
+    /** Small leaf functions called only from loops, whose direct calls are
+     * `alwaysinline` (loop-callees.ts). */
+    loopCallees;
     /** Static types whose values can be published (@scriptc/threads): their
      * stores carry the frozen-object guard. Null without publish calls. */
     publishedTypes;
@@ -1017,6 +1071,10 @@ export class LlEmitter {
     /** setTimeout and friends appeared somewhere: main must run the event
      * loop even in programs with no async functions. */
     usesTimers = false;
+    /** A promise is made somewhere (Promise statics, `new Promise`,
+     * Promise.withResolvers): main runs the event loop, whose end reports an
+     * unhandled rejection as Node does, even without async functions. */
+    usesPromises = false;
     /** The program calls mock.timers members (moduleUsesMockTimers): timer
      * calls emit scr_test.c's mock-aware entry points. */
     mockTimers;
@@ -1062,6 +1120,8 @@ export class LlEmitter {
     inlineUnions;
     /** Unions whose values are nullable arm pointers (nullable-unions.ts). */
     nullableUnions;
+    /** The counters of a build instrumented for the heap census, or null. */
+    heapCensus;
     /** The union table without nullable unions: the stack-box analyses. */
     boxedUnionsById;
     recordsById = new Map();
@@ -1132,6 +1192,11 @@ export class LlEmitter {
      * commit back into their objects. Library builds keep their commits:
      * their values cross a native boundary. */
     liveViewsReadOnly;
+    /** IrModule.sloppyDynWrites: untyped writes in sloppy-mode code. */
+    sloppyDynWrites;
+    /** IrModule.foreignElementKeys: element keys whose arrays can hold
+     * SCR_ARR_FOREIGN elements. */
+    foreignElementKeys;
     /** The program freezes, seals or prevents extensions of untyped values
      * (IrModule.untypedIntegrity): the commits of class views store the
      * view's integrity state in the instance's integrity word. */
@@ -1140,6 +1205,8 @@ export class LlEmitter {
     int32Abis;
     /** Pure number functions with speculative integer clones. */
     integerClones;
+    /** The records integer clones read (64-bit layouts). */
+    cloneReferences;
     /** The IR function being emitted. */
     currentFunctionName = "";
     integerParamRange(fnName, localId) {
@@ -1151,6 +1218,9 @@ export class LlEmitter {
     /** ProgramLifetime hierarchy roots (contract types): their instances are
      * immortal from construction (classes.ts programLifetimeClass). */
     programLifetime;
+    /** Inline array fields this emission may keep inline (ir/inline-arrays.ts);
+     * the classes that do have LlClassMeta.inlineTail. */
+    inlineArrays;
     numericLocals = new Map();
     captureIds = new Set();
     /** Active induction bindings retain their width independently of size_t. */
@@ -1252,15 +1322,29 @@ export class LlEmitter {
     /** Worker programs: typed-array accesses whose views an enclosing version
      * guard proved thread-owned. */
     bytesOwned = new Set();
+    /** Worker programs: the strip-mined counted loop whose body is being
+     * emitted (emitStripMinedCountedLoop), with its counter, its jump target
+     * and its loopDepth. An element access of a view that may be shared, at
+     * the counter and directly in that loop's body, is a plain load or store
+     * (plainSharedElement in expr-bytes.ts). */
+    plainSharedLoop = null;
     /** The alias-scope attachment of each typed-array element read and write
      * in the current loop version's fast copy (emitVersionedLoop), and the
      * one the element access being emitted carries (bytesElementAlias). */
     bytesAliasScopes = new Map();
     bytesAccessScope = "";
+    /** Header fields a speculative loop's entry read for its views
+     * (bytes-headers.ts), while its copies are emitted. */
+    bytesHeaders = null;
+    /** The parameters of the function being emitted. */
+    currentParameters = new Set();
     /** Loop versions with alias scopes in the current function; it names
      * their scopes. */
     aliasScopedVersions = 0;
     integerViews = new Map();
+    /** The i1 slot beside an integer view of a local that only holds exact
+     * integers or NaN: true when the local is not NaN. */
+    orderedViews = new Map();
     /** Module globals the current function owns outright (initializer
      * bindings): their function-local slot, which stands in for the global. */
     privateGlobalSlots = new Map();
@@ -1295,7 +1379,8 @@ export class LlEmitter {
     currentUnionResult = false;
     /** Active only while emitting a body lowered with LLVM's
      * switched-coroutine intrinsics (wasm32 async bodies and generators,
-     * native synchronous generators; see coroLowered). */
+     * native synchronous generators, and the native async bodies
+     * selectStacklessAsync chose; see coroLowered). */
     currentCoro = null;
     /** Inline generator slot accesses need the %ScrGenHead/%ScrGenSlot
      * mirrors in the module header. */
@@ -1341,7 +1426,10 @@ export class LlEmitter {
         else
             this.startInt32Slots(dynamicStores);
         this.stackTraces = observesStacks(mod, this.nodeIndex);
-        this.nullableUnions = new NullableUnions(mod, options.debugSources === undefined, this.nodeIndex);
+        this.nullableUnions = new NullableUnions(mod, options.debugSources === undefined, this.nodeIndex, options.pointerBits !== 32, options.boxedUnions);
+        this.heapCensus = heapCensusOf(mod, this.nullableUnions);
+        for (const decl of this.heapCensus?.declarations() ?? [])
+            this.declare(decl);
         this.mockTimers = this.runtimeFeatures.mockTimers;
         this.debug =
             options.debugSources === undefined
@@ -1349,11 +1437,13 @@ export class LlEmitter {
                 : new LlvmDebugInfo(mod.sourceFile, options.debugSources, options.pointerBits, mod.unions, this.nullableUnions.armTypes());
         this.constantNumericTables = findConstantNumericTables(mod);
         this.untypedIntegrity = mod.untypedIntegrity === true;
+        this.sloppyDynWrites = new Set(mod.sloppyDynWrites ?? []);
         this.liveViewsReadOnly =
             mod.lib === undefined &&
                 !this.untypedIntegrity &&
                 !dynamicStores.all &&
                 dynamicStores.names.size === 0;
+        this.foreignElementKeys = new Set(mod.foreignElementKeys ?? []);
         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 ?? []);
@@ -1389,7 +1479,16 @@ export class LlEmitter {
         this.emitLibraryIdentity = options.emitLibraryIdentity !== false;
         this.runtimeAbiMarker = options.runtimeAbiMarker === true;
         this.detachedExit = options.detachedExit === true;
+        this.nodeIslandModuleData = options.nodeIslandModuleData ?? null;
         this.targetCpu = options.targetCpu;
+        this.sanitizeAttributes = options.sanitizeAttributes !== false;
+        this.cpuDispatch =
+            options.cpuDispatch === true &&
+                options.targetCpu === undefined &&
+                !this.wasi &&
+                mod.lib === undefined &&
+                this.debug === null &&
+                /^(x86_64|amd64|x64)\b/.test(options.targetTriple || process.arch);
         this.wasmBoundsChecks =
             options.wasmBoundsChecks === true ||
                 wasmBoundsChecks({
@@ -1430,10 +1529,11 @@ export class LlEmitter {
                 (options.targetTriple
                     ? /-linux-(?:gnu|musl)/.test(options.targetTriple)
                     : process.platform === "linux")
-                ? unwindAbiFunctions(mod, this.mayThrow, options.unwindExcluded)
+                ? unwindAbiFunctions(mod, this.mayThrow, options.unwindExcluded, this.nodeIndex, options.rareExceptions === true)
                 : new Set();
         this.workerEntryPolls = mt.workerEntryPolls ?? null;
         this.stackChecks = mt.stackChecks ?? null;
+        this.loopCallees = findLoopCallees(mod);
         // A stackless call's eager prefix borrows its caller's stack; the
         // runtime moves deep prefix nests to a fresh stack using the guard,
         // which Windows lacks.
@@ -1477,6 +1577,12 @@ export class LlEmitter {
         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.nodeIndex);
+        // Inline array fields (ir/inline-arrays.ts), where the module passes
+        // prepared their reads and constructions.
+        this.inlineArrays =
+            options.debugSources === undefined && inlineArraysApply(mod, options)
+                ? planInlineArrays(mod, programLifetimeClassOf(mod))
+                : NO_INLINE_ARRAYS;
         const walkParameters = new Map();
         if (this.debug === null) {
             const host = {
@@ -1508,7 +1614,7 @@ export class LlEmitter {
                 const rebound = findReboundParameters(fn, (type) => this.plainReference(type) &&
                     type.kind !== "string" &&
                     (type.kind !== "union" ||
-                        this.nullableUnions.single(type.unionId)?.arm.kind !== "string"), this.walkBorrowsByFunction.get(fn.name) ?? new Set());
+                        this.nullableUnions.single(type.unionId)?.arm.kind !== "string"), this.walkBorrowsByFunction.get(fn.name) ?? new Set(), this.nodeIndex);
                 if (rebound.size === 0)
                     continue;
                 this.reboundByFunction.set(fn.name, rebound);
@@ -1527,6 +1633,8 @@ export class LlEmitter {
             const shape = this.recordsById.get(shapeId);
             return shape !== undefined && !recordDynKeepsIdentity(shape);
         }, (wrap) => this.borrowableNullableWrap(wrap) === "ref");
+        if (this.stackObjects)
+            this.frameEscapes = analyzeFrameEscapes(this.mod);
         if (this.debug === null) {
             const strings = findLentStringParameters(this.fnByName, this.callLifetimes);
             this.lendingFacts = {
@@ -1536,24 +1644,6 @@ export class LlEmitter {
             };
         }
         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.
-        // Clones read number arrays their function borrows (64-bit layouts).
-        this.integerClones =
-            this.debug === null &&
-                this.stackChecks !== null &&
-                mod.workers !== true &&
-                mod.lib === undefined &&
-                !this.stackTraces
-                ? findIntegerClones(mod, this.sizeType === "i64"
-                    ? (fn, index) => this.callLifetimes.borrowed.get(fn)?.has(index) === true
-                    : undefined)
-                : NO_INTEGER_CLONES;
-        // Integer clones and their dispatchers call each other through their
-        // own lowering, which keeps plain calls and flag tests.
-        for (const name of this.integerClones.members)
-            this.unwindAbi.delete(name);
         this.stackCallbacks = new StackCallbacks(this.fnByName);
         this.receiverReaders = new AmbientReceiverReaders(this.fnByName, this.nodeIndex);
         this.stackCaptures = new StackCaptures(this.fnByName, this.callLifetimes, this.stackCallbacks);
@@ -1581,6 +1671,8 @@ export class LlEmitter {
                 }
             }
         }
+        // The same holds for a class union's arms (class-unions.ts).
+        classUnionHeaders(mod, this.nullableUnions.allClassUnions(), this.tracedShapes, this.tracedUnions);
         this.shapeHost = {
             // Journal hooks only on emitters that can emit ranges (chunk
             // emitters, and emitters whose workers take a journal after the
@@ -1626,6 +1718,7 @@ export class LlEmitter {
             declare: (decl) => this.declare(decl),
             needOom: () => this.needOom(),
             needBadTag: () => this.needBadTag(),
+            mayHoldForeign: (elem) => this.mayHoldForeign(elem),
             internLiteral: (text) => this.internLiteral(text),
             cstr: (text) => this.cstr(text),
             mapOps: (operands) => this.mapOps(operands),
@@ -1656,7 +1749,73 @@ export class LlEmitter {
             virtualEntry: (implFn) => this.virtualEntry(implFn),
             programLifetime: this.programLifetime,
             regionAliasTag: (word) => this.memoryAliasAttachment(`region.${word}`),
+            heapCensus: this.heapCensus,
         };
+        // An instance of a class that extends Array is an array: a slot of its
+        // element array type can hold it, and the collector visits it there as
+        // an array, which has a collector header when its element ops trace
+        // (scr_arr_make_ops_kind). Such a class carries a header too, and so
+        // does the rest of its hierarchy. A class whose elements are instances
+        // of another such class follows that class, so repeat until no class
+        // adds one.
+        const arrayClasses = (mod.classes ?? []).filter((c) => c.arrayElem !== undefined);
+        if (arrayClasses.length > 0) {
+            const baseOf = new Map((mod.classes ?? []).map((c) => [c.name, c.base]));
+            const rootOf = (name) => {
+                let root = name;
+                for (let base = baseOf.get(root); base !== undefined && baseOf.has(base); base = baseOf.get(root))
+                    root = base;
+                return root;
+            };
+            for (let changed = true; changed;) {
+                changed = false;
+                for (const cls of arrayClasses) {
+                    if (this.tracedShapes.has(`object:${cls.name}`))
+                        continue;
+                    if (traceAdapter(this.shapeHost, { kind: "array", elem: cls.arrayElem }) === null)
+                        continue;
+                    const root = rootOf(cls.name);
+                    for (const member of mod.classes ?? [])
+                        if (rootOf(member.name) === root)
+                            this.tracedShapes.add(`object:${member.name}`);
+                    changed = true;
+                }
+            }
+        }
+        // Planned before any host copies the shape host (record-views.ts).
+        {
+            const views = planRecordViews(mod, {
+                traced: (id) => this.tracedShapes.has(`record:${id}`),
+                // A tagged shape's values share field reads with the other arms of
+                // its shape union.
+                excluded: (id) => this.nullableUnions.shapeNumber(id) !== 0 ||
+                    this.publishedTypes?.recordGuarded(id) === true ||
+                    mod.workers === true,
+            });
+            this.shapeHost.recordViews = views;
+            this.recordViewTargets = views.targets;
+        }
+        // Integer clones signal a stack overflow through their result. Worker
+        // programs have them only as ELF executables, where the stack guard
+        // and the pending word clones poll for termination are plain
+        // thread-locals; debug builds and stack traces keep every frame.
+        // Clones read number arrays and record graphs their function borrows
+        // (64-bit layouts), but no record that may be a view (planned above).
+        this.cloneReferences = this.sizeType === "i64" ? this.recordCloneReferences() : undefined;
+        this.integerClones =
+            this.debug === null &&
+                this.stackChecks !== null &&
+                (mod.workers !== true || this.executableTls) &&
+                mod.lib === undefined &&
+                !this.stackTraces
+                ? findIntegerClones(mod, this.sizeType === "i64"
+                    ? (fn, index) => this.callLifetimes.borrowed.get(fn)?.has(index) === true
+                    : undefined, this.cloneReferences)
+                : NO_INTEGER_CLONES;
+        // Integer clones and their dispatchers call each other through their
+        // own lowering, which keeps plain calls and flag tests.
+        for (const name of this.integerClones.members)
+            this.unwindAbi.delete(name);
         this.walkers = new LlWalkers(this.shapeHost);
         this.dyn = new LlDyn(this.shapeHost);
         for (const g of mod.globals ?? []) {
@@ -1695,7 +1854,7 @@ export class LlEmitter {
         // The class graph: base/children links, hierarchy membership, the
         // whole-program preorder numbering for instanceof over runtime and
         // compiled error objects, and the per-hierarchy virtual slot lists.
-        this.classMeta = buildClassGraph(mod, this.fnByName, this.sizeType);
+        this.classMeta = buildClassGraph(mod, this.fnByName, this.sizeType, this.nullableUnions.taggedClasses());
         if (mod.lifetimeRegions === true) {
             this.regions = new LifetimeRegions(this.shapeHost, mod, this.classMeta, (meta) => programLifetimeClass(this.shapeHost, meta), this.nullableFields);
             const regions = this.regions;
@@ -1730,11 +1889,50 @@ export class LlEmitter {
                         : null;
                     return nullable !== null && isCompact(nullable.arm.className);
                 }
-                : undefined);
+                : undefined, this.inlineArrays.classes);
         this.compactRegion =
             mod.lib === undefined &&
                 options.lowRegion === true &&
                 [...this.classMeta.values()].some((m) => m.compact);
+        // Group arenas: off with lifetime regions, which own their classes'
+        // allocation, and in libraries, whose exports any host code calls.
+        if (arenasRequested() && mod.lifetimeRegions !== true && mod.lib === undefined) {
+            this.arenas = planArenas(mod, {
+                shape: (id) => {
+                    const shape = this.recordsById.get(id);
+                    return (shape !== undefined &&
+                        shape.freezable !== true &&
+                        shape.indexValue === undefined &&
+                        this.publishedTypes?.recordGuarded(id) !== true);
+                },
+                cls: (def) => {
+                    const meta = this.classMeta.get(def.name);
+                    return (meta !== undefined &&
+                        !meta.compact &&
+                        !meta.threadSlot &&
+                        // An Array subclass's instance is an array (the runtime's header).
+                        def.arrayElem === undefined &&
+                        meta.root.def.arrayElem === undefined &&
+                        !this.programLifetime.has(def.name) &&
+                        this.publishedTypes?.classGuarded(def.name) !== true);
+                },
+                nullableArm: (unionId) => this.nullableUnions.single(unionId)?.arm ?? null,
+                traced: (t) => traceAdapter(this.shapeHost, t) !== null,
+            });
+            if (this.arenas !== null) {
+                this.shapeHost.arenaShapes = this.arenas.shapes;
+                this.shapeHost.arenaClasses = this.arenas.classes;
+                this.shapeHost.arenasClosed = this.arenas.allClosed;
+            }
+        }
+        // Arena shapes are known only now; the plan's target set is shared by
+        // every host that copied the shape host, so dropping them here reaches
+        // all of them.
+        const arenaShapes = this.shapeHost.arenaShapes;
+        const viewTargets = this.recordViewTargets;
+        if (arenaShapes !== undefined && viewTargets !== null)
+            for (const id of arenaShapes)
+                viewTargets.delete(id);
         for (const [name, rec] of RUNTIME_ERROR_CLASSES) {
             const meta = this.classMeta.get(name);
             if (!meta)
@@ -1842,7 +2040,9 @@ export class LlEmitter {
     }
     emitParts() {
         const parts = emitParts(this);
-        return this.unwindAbi.size > 0 ? bridgePlainUnwindCalls(parts) : parts;
+        const bridged = this.unwindAbi.size > 0 ? bridgePlainUnwindCalls(parts) : parts;
+        const out = this.cpuDispatch ? cloneForCpuDispatch(bridged) : bridged;
+        return this.heapCensus === null ? out : [...out, this.heapCensus.definitions().join("\n")];
     }
     /** The dispose-observer gates the emitted frees and record writers test
      * (alloc.ts): defined after every helper is emitted, because dynCheck
@@ -1882,6 +2082,7 @@ export class LlEmitter {
             ...late,
             ...emitNullableRetainWrappers(this.shapeHost),
             ...emitShapeUnionHelpers(this.shapeHost),
+            ...emitClassUnionHelpers(this.shapeHost, this.classMeta),
             ...emitInlineRcHelpers(this.shapeHost),
         ];
     }
@@ -1900,7 +2101,7 @@ export class LlEmitter {
             const ret = fn.async === true || fn.generator !== undefined ? "ptr" : this.llType(fn.returnType);
             const call = `call ${ret} @${this.callTarget(name)}(${args})`;
             const lending = this.lendsEveryArgument(name);
-            out.push(`define internal ${ret} @${mangleWrapper(name)}(ptr %env${params.length ? ", " + params.join(", ") : ""}) ${FN_ATTRS} { ; ${name} as a value`, `entry:`, ret === "void" ? `  ${call}` : `  %r = ${call}`, ret === "void" ? `  ret void` : `  ret ${ret} %r`, `}`, `@${mangleFnClosure(name)} = internal ${this.mod.workers === true || this.mod.lib?.threadInstances === true ? "thread_local " : ""}global %ScrClosure { ${this.sizeType} -1, ptr @${mangleWrapper(name)}, ${this.sizeType} 0, ptr null, i32 ${(fn.generator ? 1 : 0) + (fn.async ? 2 : 0) + (fn.ownsPrototype ? 4 : 0)}, i32 0, ptr null, ptr ${lending ? `@${mangleBorrowingWrapper(name)}` : "null"} }`, ``);
+            out.push(`define internal ${ret} @${mangleWrapper(name)}(ptr %env${params.length ? ", " + params.join(", ") : ""}) ${FN_ATTRS} { ; ${name} as a value`, `entry:`, ret === "void" ? `  ${call}` : `  %r = ${call}`, ret === "void" ? `  ret void` : `  ret ${ret} %r`, `}`, `@${mangleFnClosure(name)} = internal ${this.mod.workers === true || this.mod.lib?.threadInstances === true ? "thread_local " : ""}global %ScrClosure { ${this.sizeType} -1, ptr @${mangleWrapper(name)}, ${this.sizeType} 0, ptr null, i32 ${this.closureFunctionKind(fn)}, i32 0, ptr null, ptr ${lending ? `@${mangleBorrowingWrapper(name)}` : "null"} }`, ``);
             if (lending)
                 out.push(`define internal ${ret} @${mangleBorrowingWrapper(name)}(ptr %env${params.length ? ", " + params.join(", ") : ""}) ${FN_ATTRS} { ; ${name} as a value, lending its arguments`, `entry:`, ret === "void"
                     ? `  call void @${mangleBorrowedFunction(name)}(${args})`
@@ -1992,19 +2193,21 @@ export class LlEmitter {
             at = text.indexOf("@sc_", end);
         }
     }
-    /** Chooses the native async functions whose bodies compile to switched
-     * coroutines instead of running on a fiber: a suspended call then keeps a
-     * heap frame of the values live across its awaits rather than a fiber and
-     * its stack. A body qualifies when its only suspension points are its own
-     * awaits, which the coroutine form suspends itself at (emitCoroAwait), so
-     * nothing it runs can park the stack it borrows. It is first emitted as
-     * usual: that text may suspend only through await runtime calls and
-     * await-call entries, which the coroutine form replaces, and may call no
-     * function that parks. The coroutine form is then emitted and must pass
-     * the same test with no exceptions (its frame bookkeeping excepted);
-     * otherwise the fiber form stays. Bodies that never suspend stay
-     * fiberless, and module evaluation bodies and `dyn` results keep fibers
-     * as they do there. The runtime traps if a stackless body ever parks. */
+    /** Chooses the native async functions and async generators whose bodies
+     * compile to switched coroutines instead of running on a fiber: a
+     * suspended call then keeps a heap frame of the values live across its
+     * awaits and yields rather than a fiber and its stack. A body qualifies
+     * when its only suspension points are its own awaits and yields, which
+     * the coroutine form suspends itself at (emitCoroAwait,
+     * emitCoroSuspendPrepared), so nothing it runs can park the stack it
+     * borrows. It is first emitted as usual: that text may suspend only
+     * through await and yield runtime calls and await-call entries, which the
+     * coroutine form replaces, and may call no function that parks. The
+     * coroutine form is then emitted and must pass the same test with no
+     * exceptions (its frame bookkeeping excepted); otherwise the fiber form
+     * stays. Bodies that never suspend stay fiberless, and module evaluation
+     * bodies and async functions with `dyn` results keep fibers as they do
+     * there. The runtime traps if a stackless body ever parks. */
     selectStacklessAsync(fnDefs) {
         if (!this.stacklessAsyncAllowed)
             return;
@@ -2023,14 +2226,21 @@ export class LlEmitter {
             return true;
         };
         this.mod.functions.forEach((fn, index) => {
-            if (fn.async !== true || fn.generator !== undefined)
+            if (fn.async !== true)
                 return;
             if (fn.asyncCacheGlobal !== undefined || fn.asyncCycleCacheGlobal !== undefined)
                 return;
-            if (fn.returnType.kind === "dyn" || !parks.has(fn.name))
+            // A dyn result may adopt a thenable when it settles the promise; an
+            // async generator's completion value settles its request's record.
+            if (fn.generator === undefined && fn.returnType.kind === "dyn")
                 return;
-            const fiberText = fnDefs[index];
-            if (!qualifies(fn, fiberText.replace(AWAIT_SUSPENSIONS, ""), SUSPENDS))
+            if (!parks.has(fn.name))
+                return;
+            // An async generator's body also suspends at its own yields.
+            let fiberText = fnDefs[index].replace(AWAIT_SUSPENSIONS, "");
+            if (fn.generator !== undefined)
+                fiberText = fiberText.replace(YIELD_SUSPENSIONS, "");
+            if (!qualifies(fn, fiberText, SUSPENDS))
                 return;
             this.stacklessAsync.add(fn.name);
             const coroText = this.emitFunction(fn);
@@ -2458,18 +2668,19 @@ export class LlEmitter {
         if (this.wasi)
             return fn.async === true || fn.generator !== undefined;
         if (fn.async === true)
-            return fn.generator === undefined && this.stacklessAsync.has(fn.name);
+            return this.stacklessAsync.has(fn.name);
         return this.stacklessGenerators && fn.generator !== undefined;
     }
     emitGenScaffolding() {
         return emitGenScaffolding(this);
     }
     // ── plumbing (frame and scope ownership) ──────
-    /** A symbol derived from the constant's text rather than its first-use
-     * index, so an edit that interns one more string leaves every other
-     * constant's symbol, and the code referencing it, unchanged. This lets
-     * native builds reuse the compiled partitions an edit does not touch. A
-     * collision retries with a counter, still in first-use order. */
+    /** A symbol derived from a constant's text, or a helper's key, rather
+     * than its first-use index, so an edit that interns one more string or
+     * helper leaves every other symbol, and the code referencing it,
+     * unchanged. This lets native builds reuse the compiled partitions an
+     * edit does not touch. A collision retries with a counter, still in
+     * first-use order. */
     contentSymbol(prefix, text) {
         for (let attempt = 0;; attempt++) {
             const digest = createHash("sha256")
@@ -2588,7 +2799,7 @@ export class LlEmitter {
         const key = `${unionId}:${tag}`;
         let sym = this.unitInstances.get(key);
         if (!sym) {
-            sym = `sc_unit_${this.unitInstances.size}`;
+            sym = this.contentSymbol("sc_unit_", key);
             this.unitInstances.set(key, sym);
         }
         this.journal?.entry("unit", key, sym);
@@ -2695,9 +2906,14 @@ export class LlEmitter {
     }
     /** Registers a SLOT whose current contents the frame owns (conditional
      * results: optional chains, branch joins that park ownership). */
-    ownSlot(slot, type) {
+    ownSlot(slot, type, rarelyFilled = false) {
         if (isRefCounted(type))
-            this.currentFrame().push({ name: slot, type, slot: true });
+            this.currentFrame().push({
+                name: slot,
+                type,
+                slot: true,
+                ...(rarelyFilled ? { rarelyFilled: true } : {}),
+            });
     }
     /** The innermost lexical scope releases a frame object's reference
      * fields when it exits, as it releases its bindings. */
@@ -2791,12 +3007,25 @@ export class LlEmitter {
     /** Releases a statement frame's temps and owned slots. */
     releaseTemps(frame) {
         for (const v of frame) {
+            if (v.arena !== undefined)
+                continue;
             if (v.slot) {
                 const t = this.B.tmp();
                 this.B.line(`${t} = load ptr, ptr ${v.name}`);
                 if (v.boxed) {
                     this.B.line(`call void ${boxReleaseSym(this.shapeHost)}(ptr ${t})`);
                 }
+                else if (v.rarelyFilled && !this.B.isTerminated()) {
+                    // Skip the release call on the common empty path.
+                    const filled = this.B.tmp();
+                    this.B.line(`${filled} = icmp ne ptr ${t}, null`);
+                    const release = this.B.newLabel("slot.release"), join = this.B.newLabel("slot.release.j");
+                    this.B.condBr(filled, release, join);
+                    this.B.startBlock(release);
+                    this.releaseFrame(t, v.type);
+                    this.B.br(join);
+                    this.B.startBlock(join);
+                }
                 else {
                     this.releaseFrame(t, v.type);
                 }
@@ -2805,9 +3034,20 @@ export class LlEmitter {
                 this.releaseFrame(v.name, v.type);
             }
         }
+        // Arena lists last: the frame's temps may be arena objects.
+        for (const v of frame)
+            if (v.arena === "drop")
+                this.B.line(`call void @scr_arena_drop(ptr ${v.name})`);
+            else if (v.arena === "close") {
+                const head = this.B.tmp();
+                this.B.line(`${head} = load ptr, ptr ${v.name}`);
+                this.B.line(`call void @scr_arena_close(ptr ${head})`);
+            }
     }
     releaseScope(scope) {
         for (const e of scope) {
+            if (e.arena === true)
+                continue;
             const t = this.B.tmp();
             this.B.line(`${t} = load ptr, ptr ${e.slot}`);
             if (e.boxed && e.lazy) {
@@ -2831,6 +3071,10 @@ export class LlEmitter {
                 this.releaseFrame(t, e.type); // runtime releases are NULL-tolerant
             }
         }
+        // Arena lists last: the scope's bindings may hold arena objects.
+        for (const e of scope)
+            if (e.arena === true)
+                this.B.line(`call void @scr_arena_drop(ptr ${e.slot})`);
     }
     /** THE release-on-jump path (break/continue/return): pending statement
      * frames and entered scopes down to the given depths, innermost first —
@@ -3018,7 +3262,10 @@ export class LlEmitter {
      * (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) {
+    emitPendingCheck(passThrough, poll = false, guard, 
+    /** Runs at the start of the cold unwind block, before the unwind (a
+     * package-declared check's origin note). */
+    onUnwind) {
         const through = passThrough !== undefined &&
             this.llType(passThrough.type) === this.llType(this.currentReturnType) &&
             (passThrough.type.kind === "f64" || passThrough.type.kind === "bool")
@@ -3042,6 +3289,7 @@ export class LlEmitter {
             const lk = B.newLabel("exc.k");
             B.condBr(p, lu, lk);
             B.startBlock(lu);
+            onUnwind?.();
             this.emitUnwind(through);
             B.startBlock(lk);
             if (skip !== undefined) {
@@ -3122,6 +3370,7 @@ export class LlEmitter {
             B.condBr(cold, lu, lk);
         }
         B.startBlock(lu);
+        onUnwind?.();
         this.emitUnwind(through);
         B.startBlock(lk);
         if (skip !== undefined) {
@@ -3149,6 +3398,17 @@ export class LlEmitter {
      * calls (unwindAbiFunctions excludes their callees). */
     emitDirectCall(line, callee) {
         const B = this.B;
+        // A small leaf called only from loops inlines into each of them, past
+        // LLVM's cost threshold (loop-callees.ts), and so does a function called
+        // only from a loop's entry-range version (loop-entry-versions.ts).
+        // Debug builds keep the call.
+        if (this.debug === null && (this.loopCallees.has(callee) || loopEntryInlines(this, callee))) {
+            const comment = line.indexOf(" ; ");
+            line =
+                comment < 0
+                    ? `${line} alwaysinline`
+                    : `${line.slice(0, comment)} alwaysinline${line.slice(comment)}`;
+        }
         if (!this.unwindAbi.has(callee) || this.currentCoro !== null || B.isTerminated()) {
             B.line(line);
             return false;
@@ -3272,9 +3532,19 @@ export class LlEmitter {
     workerLoopPolls(loop) {
         return (this.mod.workers === true && !loopTestsEveryIteration(loop, (e) => this.callTestsPending(e)));
     }
+    /** The countdown slot of `loop`'s cancellation poll (emitWorkerLoopCheck),
+     * or null when the loop does not poll. An ELF worker executable's poll is
+     * one ordered load of the thread's own pending word. A loop nest keeps
+     * one countdown per loop, which its register pressure often leaves in
+     * memory, so the loops of a nest there poll on every iteration and get
+     * POLL_EVERY_ITERATION instead of a slot. A loop on its own keeps its
+     * countdown in a register, which costs less than the load. */
     workerLoopBudget(loop) {
         if (!this.workerLoopPolls(loop))
             return null;
+        if (this.executableTls &&
+            (this.jumpTargets.some((target) => target.kind === "loop") || containsLoop(loop.body)))
+            return POLL_EVERY_ITERATION;
         const slot = this.B.slot();
         this.B.entryAllocas.push(`${slot} = alloca i32 ; worker cancellation budget`);
         this.B.line(`store i32 0, ptr ${slot}`);
@@ -3368,6 +3638,10 @@ export class LlEmitter {
     emitWorkerLoopCheck(slot) {
         if (slot === null)
             return;
+        if (slot === POLL_EVERY_ITERATION) {
+            this.emitWorkerPoll();
+            return;
+        }
         const B = this.B;
         const budget = B.tmp(), due = B.tmp(), remaining = B.tmp();
         const poll = B.newLabel("worker.poll"), next = B.newLabel("worker.next");
@@ -3383,9 +3657,9 @@ export class LlEmitter {
         B.startBlock(next);
     }
     /** The cancellation poll itself. Calls and throwing operations retain
-     * their own checks. Loops amortize this extra poll across bounded
-     * batches of iterations so scalar work does not cross the runtime ABI on
-     * every iteration. */
+     * their own checks. Outside ELF worker executables, loops amortize this
+     * extra poll across bounded batches of iterations so scalar work does not
+     * cross the runtime ABI on every iteration. */
     emitWorkerPoll() {
         this.emitPendingCheck(undefined, true);
     }
@@ -3537,6 +3811,7 @@ export class LlEmitter {
             case "url":
             case "searchParams":
             case "stats":
+            case "bigintStats":
             case "fileHandle":
             case "dir":
             case "spawnRes":
@@ -3683,9 +3958,7 @@ export class LlEmitter {
         const nullable = this.nullableUnions.get(unionId);
         if (nullable) {
             // The owned payload IS the nullable union's value.
-            if (nullable.repr === "single"
-                ? tag !== nullable.refTag
-                : !nullable.arms.some((arm) => arm.tag === tag))
+            if (!isPayloadTag(nullable, tag))
                 throw new InternalCompilerError(`llvm emitter bug: payload wrap into unit arm ${tag} of ${unionId}`);
             return v.name;
         }
@@ -3726,10 +3999,16 @@ export class LlEmitter {
      * def's [name, message, %code, %cause] order matches the layout). */
     classFieldPtr(objName, className, field, refs = "pointer") {
         const meta = this.classMetaOf(className);
+        // An inline array field's slot holds its element count: its reads and
+        // writes go through backend/llvm/inline-arrays.ts.
+        const tail = this.inlineTailOf(className);
+        if (tail !== undefined && meta.def.fields[tail.field].name === field)
+            throw new InternalCompilerError(`llvm emitter bug: field pointer to the inline array field ${className}.${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);
+        this.heapCensus?.countAccess((line) => this.B.line(line), className, field);
         if (compressed)
             this.compressedFieldPtrs.add(p);
         return { ptr: p, type, inline: this.inlineUnions.classField(className, field), compressed };
@@ -3855,13 +4134,66 @@ export class LlEmitter {
     }
     /** The field-slot pointer of a record member (rc header at index 0).
      * `inline`: the slot stores a scalar union's tag and bits. */
+    /** The record layouts integer clones read in place: record pointers,
+     * `R | null` unions of a record (NULL is `null`), and fields stored as a
+     * double, an i8 boolean or such a pointer. Records that may be views
+     * (record-views.ts) are not among them. */
+    recordCloneReferences() {
+        // A view's fields live in the record it views (recordViewFieldPtr), not
+        // at its own shape's offsets.
+        const plain = (shapeId) => this.recordsById.has(shapeId) && this.shapeHost.recordViews?.targets.has(shapeId) !== true;
+        const nullable = (unionId) => {
+            const single = this.nullableUnions.single(unionId);
+            if (single === null || single.nullTag !== -1 || single.arm.kind !== "record")
+                return null;
+            if (!plain(single.arm.shapeId))
+                return null;
+            const unit = this.unionsById.get(unionId)?.arms[single.unitTag];
+            return unit?.kind === "nullT" ? single : null;
+        };
+        const reference = (type) => type.kind === "record"
+            ? plain(type.shapeId)
+            : type.kind === "union" && nullable(type.unionId) !== null;
+        return {
+            reference,
+            arm: (unionId, tag) => {
+                const single = nullable(unionId);
+                if (single === null)
+                    return null;
+                return tag === single.refTag ? "record" : tag === single.unitTag ? "null" : null;
+            },
+            field: (shapeId, field) => {
+                const shape = this.recordsById.get(shapeId);
+                const index = shape?.fields.findIndex((f) => f.name === field) ?? -1;
+                if (shape === undefined || index < 0 || !plain(shapeId))
+                    return null;
+                const type = shape.fields[index].type;
+                if (this.inlineUnions.record(type))
+                    return null;
+                if (type.kind !== "f64" && type.kind !== "bool" && !reference(type))
+                    return null;
+                return {
+                    struct: mangleRecordStruct(shapeId),
+                    index: index + this.nullableUnions.fieldBase(shapeId),
+                    type,
+                };
+            },
+        };
+    }
     recordFieldPtr(objName, shapeId, field) {
         const shape = this.recordShape(shapeId);
         const idx = shape.fields.findIndex((f) => f.name === field);
         if (idx < 0)
             throw new InternalCompilerError(`llvm emitter bug: unknown field ${field} on shape ${shapeId}`);
-        const p = this.B.tmp();
-        this.B.line(`${p} = getelementptr inbounds %${mangleRecordStruct(shapeId)}, ptr ${objName}, i64 0, i32 ${idx + this.nullableUnions.fieldBase(shapeId)}`);
+        const base = this.nullableUnions.fieldBase(shapeId);
+        let p;
+        if (this.shapeHost.recordViews?.targets.has(shapeId) === true) {
+            p = recordViewFieldPtr(this.B, this.sizeType, mangleRecordStruct(shapeId), objName, idx + base, idx, (decl) => this.declare(decl), this.rcMode === undefined);
+        }
+        else {
+            p = this.B.tmp();
+            this.B.line(`${p} = getelementptr inbounds %${mangleRecordStruct(shapeId)}, ptr ${objName}, i64 0, i32 ${idx + base}`);
+        }
         const type = shape.fields[idx].type;
         return { ptr: p, type, inline: this.inlineUnions.record(type) };
     }
@@ -4334,7 +4666,7 @@ export class LlEmitter {
     /** Awaits in the current body suspend its coroutine: every wasm32 async
      * body, and native stackless async bodies (selectStacklessAsync). */
     get coroAwait() {
-        return this.wasi || this.currentCoro?.kind === "async";
+        return this.wasi || this.currentCoro?.awaits === true;
     }
     /** Suspends the current coroutine body at an await of `promise` (null: a
      * single microtask hop, as for a non-promise operand). A native body
@@ -4370,7 +4702,7 @@ export class LlEmitter {
      * coroutine has already suspended until the promise settled, so its
      * extraction takes no further turn. */
     awaitResultFn(kind) {
-        return !this.wasi && this.currentCoro?.kind === "async"
+        return !this.wasi && this.currentCoro?.awaits === true
             ? `scr_coro_await_${kind}`
             : `scr_await_${kind}`;
     }
@@ -4468,6 +4800,7 @@ export class LlEmitter {
             flags: {
                 usesCoroutines: this.usesCoroutines,
                 usesTimers: this.usesTimers,
+                usesPromises: this.usesPromises,
                 usesGenSlots: this.usesGenSlots,
                 needsUnionNone: this.needsUnionNone,
                 needsNullableAbsent: this.needsNullableAbsent,
@@ -4504,6 +4837,7 @@ export class LlEmitter {
         const flags = chunk.flags;
         this.usesCoroutines ||= flags.usesCoroutines;
         this.usesTimers ||= flags.usesTimers;
+        this.usesPromises ||= flags.usesPromises;
         this.usesGenSlots ||= flags.usesGenSlots;
         this.needsUnionNone ||= flags.needsUnionNone;
         this.needsNullableAbsent ||= flags.needsNullableAbsent;
@@ -4601,8 +4935,16 @@ export class LlEmitter {
             case "retainWrapper":
                 addEntry(this.nullableUnions.retainWrappers, key, value);
                 return;
-            case "unit":
-                return addNumbered(this.unitInstances, key, value, "sc_unit_", names);
+            case "unit": {
+                let own = this.unitInstances.get(key);
+                if (own === undefined) {
+                    own = this.contentSymbol("sc_unit_", key);
+                    this.unitInstances.set(key, own);
+                }
+                if (own !== value)
+                    names.set(value, own);
+                return;
+            }
             case "absent":
                 return addNumbered(this.absentInstances, key, value, "sc_absent_", names);
             case "retype":
@@ -4610,7 +4952,9 @@ export class LlEmitter {
             case "slots":
                 return addNumbered(this.threadSlotsBlocks, key, value, "@sc_slots_", names);
             case "regex":
-                return addNumberedSymbol(this.regexInstances, key, value, "sc_re_", names);
+                return this.addContentEntry(this.regexInstances, key, value, "sc_re_", names);
+            case "regexReplacer":
+                return this.addContentEntry(this.regexReplacers, key, value, "sc_rr_", names);
             case "templateStrings":
                 return addNumberedSymbol(this.templateStringsInstances, key, value, "sc_tsa_", names);
             case "tag": {
@@ -4807,7 +5151,8 @@ export class LlEmitter {
             B.line(`${exception} = landingpad { ptr, i32 } cleanup`);
             for (const index of borrowed)
                 this.releaseFrame(`%p${index}`, fn.params[index].type);
-            B.terminate(`resume { ptr, i32 } ${exception}`);
+            this.declare(UNWIND_RESUME_DECLARATION);
+            B.resumeUnwind(exception);
             B.startBlock(ok);
         }
         else
@@ -4865,7 +5210,8 @@ export class LlEmitter {
         const rw = this.referenceWrites;
         if (rw === null)
             return false;
-        const keys = rw.readKeys(e, (call) => this.borrowedReturnKeys(call.callee));
+        // A checked extraction reads nothing besides the union it narrows.
+        const keys = rw.readKeys(e, (call) => borrowsCheckedNarrow(this, call) ? [] : this.borrowedReturnKeys(call.callee));
         return keys !== null && !rw.conflicts(keys, writes);
     }
     /** A stable binding initialized by a projection can borrow it when the
@@ -5131,7 +5477,25 @@ export class LlEmitter {
             }
             case "fieldGet":
             case "recordGet":
+            case "recordKeyGet":
                 return this.borrowsWithoutOwning(e) && this.unownedWalk(e.obj);
+            // `r[k] ?? inherited(r, k)` whose default is immortal.
+            case "nullish": {
+                const read = borrowedRecordKeyGetOr(this, e);
+                return read !== null && immortalDefault(this, e.right) && this.unownedWalk(read);
+            }
+            case "mapIntrinsic": {
+                // A Map binding's own pointer (maps are not plainReference types).
+                if (!this.borrowsWithoutOwning(e) || e.receiver.kind !== "varRef")
+                    return false;
+                const binding = this.binding(e.receiver.localId);
+                return (binding.kind === "global" ||
+                    (binding.kind === "local" &&
+                        binding.local !== undefined &&
+                        !binding.local.boxed &&
+                        !binding.local.tdz &&
+                        !this.localUnionStorage.has(e.receiver.localId)));
+            }
             case "unionNarrow":
             case "downcast":
             case "upcast":
@@ -5275,8 +5639,11 @@ export class LlEmitter {
         const previous = this.B.debugLocation;
         this.B.debugLocation = this.debug?.location(s.loc, this.debugScope) ?? null;
         const loop = s.kind === "while" || s.kind === "doWhile" || s.kind === "for" || s.kind === "forOf";
-        if (loop)
+        const builder = this.B;
+        if (loop) {
             this.loopDepth++;
+            builder.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;
@@ -5286,8 +5653,10 @@ export class LlEmitter {
         finally {
             this.B.debugLocation = previous;
             this.int32KindResume = kindResume;
-            if (loop)
+            if (loop) {
                 this.loopDepth--;
+                builder.loopDepth--;
+            }
         }
     }
     emitStmtBody(s) {
@@ -5346,6 +5715,7 @@ export class LlEmitter {
                 type: local.type,
                 slot: true,
                 ...(local.boxed ? { boxed: true } : {}),
+                ...(local.arena === true ? { arena: "drop" } : {}),
             });
         }
         return result;
@@ -5728,6 +6098,12 @@ export class LlEmitter {
                 throw new InternalCompilerError(`llvm emitter bug: unknown intrinsic ${e.name}`);
         }
     }
+    /** Arrays of this element type can hold SCR_ARR_FOREIGN elements. */
+    mayHoldForeign(elem) {
+        if (this.foreignElementKeys.size === 0)
+            return false;
+        return this.foreignElementKeys.has("*") || this.foreignElementKeys.has(typeKey(elem));
+    }
     /** Lifetime regions in modules with lifetimeRegions (llvm/regions.ts).
      * Created with the class graph; null elsewhere. */
     regions = null;
@@ -5793,11 +6169,26 @@ export class LlEmitter {
                 const nullable = this.nullableUnions.of(t);
                 return nullable?.repr === "single" ? nullable.arm : null;
             },
-            shapeUnion: (t) => this.nullableUnions.of(t)?.repr === "shapes",
+            pointerTagFn: (t) => {
+                const nullable = this.nullableUnions.of(t);
+                return nullable === null || nullable.repr === "single" ? null : pointerTagFn(nullable);
+            },
             fieldBase: (shapeId) => this.nullableUnions.fieldBase(shapeId),
             classInfo: (className) => {
                 const meta = this.classMetaOf(className);
+                const tail = this.inlineTailOf(className);
+                const tailField = tail === undefined ? undefined : meta.def.fields[tail.field];
                 return {
+                    ...(tail !== undefined && tailField !== undefined
+                        ? {
+                            tail: {
+                                name: tailField.name,
+                                countIndex: meta.compactSlots[tail.field],
+                                offset: tail.tailOffset,
+                                elem: { kind: "object", className: tail.elemClass },
+                            },
+                        }
+                        : {}),
                     def: meta.def,
                     hierarchy: meta.hierarchy,
                     pre: meta.pre,
@@ -5805,8 +6196,9 @@ export class LlEmitter {
                     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)
+                    // Inline scalar-union fields are plain bits: nothing to push. An
+                    // inline array field's elements follow the fixed fields (`tail`).
+                    fields: meta.def.fields.flatMap((f, i) => this.inlineUnions.classField(className, f.name) || tail?.field === i
                         ? []
                         : [
                             {
@@ -5990,6 +6382,12 @@ export class LlEmitter {
     emitReadReceiver(e) {
         return emitReadReceiver(this, e);
     }
+    /** The inline array field of `className`'s instances, where they keep it
+     * inline (LlClassMeta.inlineTail; classes.ts gives their `new` the count). */
+    inlineTailOf(className) {
+        const meta = this.classMeta.get(className);
+        return meta !== undefined && meta.compact && this.compactRegion ? meta.inlineTail : undefined;
+    }
     /** The frame slot a reassigned stack-object local keeps for its value. */
     stackObjectSlot(localId, type) {
         let slot = this.stackObjectSlots.get(localId);
@@ -6157,6 +6555,14 @@ export class LlEmitter {
     canBorrowReceiver(e) {
         return canBorrowReceiver(this, e);
     }
+    /** A read of an inline array field (ir/inline-arrays.ts). It makes a view
+     * of the elements that the read owns: no field holds an array that could
+     * keep a borrowed copy alive. Known before the class layouts are, from
+     * the module's plan; layouts that keep the field an ordinary array only
+     * lose the borrow. */
+    inlineArrayRead(e) {
+        return e.kind === "fieldGet" && this.inlineArrays.classes.get(e.className)?.field === e.field;
+    }
     /** A reference held as one plain pointer that emitReadReceiver can read
      * without owning: class instances, records, arrays, strings, typed arrays
      * and nullable-pointer unions. Tagged union boxes, closures and dynamic
@@ -6191,9 +6597,16 @@ export class LlEmitter {
             return false;
         switch (e.kind) {
             case "fieldGet":
-                return this.nullableFieldGet(e) === null;
+                return this.nullableFieldGet(e) === null && !this.inlineArrayRead(e);
             case "recordGet":
                 return true;
+            // A keyed read whose hits are all the result's own pointer.
+            case "recordKeyGet":
+                return pointerRecordKeyGet(this, e);
+            case "mapIntrinsic":
+                return pointerMapGet(this, e);
+            case "nullish":
+                return borrowedRecordKeyGetOr(this, e) !== null;
             // emitReadReceiver lends a required element of a borrowed array when
             // computing the index removes no edge.
             case "arrayGet":
@@ -6231,10 +6644,7 @@ export class LlEmitter {
             return null;
         if (isUnitType(e.value.type))
             return e.value.kind === "unitLit" ? "unit" : null;
-        const refArm = nullable.repr === "single"
-            ? e.tag === nullable.refTag
-            : nullable.arms.some((arm) => arm.tag === e.tag);
-        return refArm && isRefCounted(e.value.type) ? "ref" : null;
+        return isPayloadTag(nullable, e.tag) && isRefCounted(e.value.type) ? "ref" : null;
     }
     materializeSplitLocal(localId) {
         const span = this.splitSpans.get(localId);
@@ -6242,8 +6652,193 @@ export class LlEmitter {
             materializeSplitPiece(this, localId, span);
     }
     emitExpr(e) {
+        return this.arenas === null ? emitExpr(this, e) : this.emitArenaExpr(e, this.arenas);
+    }
+    /** emitExpr when group arenas are planned. Kept out of emitExpr, whose
+     * frame each level of a nested expression holds while it is emitted. */
+    emitArenaExpr(e, arenas) {
+        if (arenas.groups.calls.has(e)) {
+            // A call region: everything the call allocates dies when it returns.
+            // The statement drops the arena after its temps, which an
+            // arena-aware caller can have allocated in it while evaluating the
+            // arguments; any other caller drops it as soon as the call returns.
+            const slot = this.arenaSlot(e);
+            this.statementFrame().push({ name: slot, type: e.type, slot: true, arena: "drop" });
+            this.B.line(`call ptr @scr_arena_open(ptr ${slot}, i32 ${this.arenaClosed(e)})`);
+            const value = emitExpr(this, e);
+            if (!arenaAware(arenas, this.fnByName.get(this.currentFunctionName)))
+                this.B.line(`call void @scr_arena_drop(ptr ${slot})`);
+            return value;
+        }
+        if (arenas.sites.heapCalls.has(e) && this.arenaSite(null)) {
+            // A call whose value the group does not keep: everything it allocates
+            // takes the heap.
+            const saved = this.suspendArena();
+            const value = emitExpr(this, e);
+            this.resumeArena(saved);
+            return value;
+        }
+        if (this.opensArena(e)) {
+            // A root: its group lives until the scope holding its value exits
+            // (the statement frame for a value used in place).
+            const slot = this.arenaSlot(e);
+            const local = arenas.groups.drops.get(e) ?? null;
+            this.statementFrame().push({
+                name: slot,
+                type: e.type,
+                slot: true,
+                arena: local === null ? "drop" : "close",
+            });
+            const arena = this.B.tmp();
+            this.B.line(`${arena} = call ptr @scr_arena_open(ptr ${slot}, i32 ${this.arenaClosed(e)})`);
+            const value = emitExpr(this, e);
+            this.B.line(`call void @scr_arena_close(ptr ${arena})`);
+            return value;
+        }
         return emitExpr(this, e);
     }
+    /** Group arenas (arenas.ts): the plan, the list slot of each root and
+     * call region, and which locals' scopes drop which roots' arenas. */
+    arenas = null;
+    arenaSlots = new Map();
+    /** The frames emitStmtBody opens for whole statements (arenas only). */
+    statementFrames = new Set();
+    /** The frame of the statement being emitted: a nested frame (call
+     * arguments, branches) ends before the values built in it do. */
+    statementFrame() {
+        for (let i = this.frames.length - 1; i >= 0; i--)
+            if (this.statementFrames.has(this.frames[i]))
+                return this.frames[i];
+        return this.currentFrame();
+    }
+    /** The arena list slot of root or call region `e`: allocated, cleared and
+     * (for a root dropped with a local) owned by that local's scope when the
+     * function starts or the local is declared. */
+    arenaSlot(e) {
+        let slot = this.arenaSlots.get(e);
+        if (slot === undefined) {
+            slot = this.B.tmp();
+            this.B.entryAllocas.push(`${slot} = alloca ptr`, `store ptr null, ptr ${slot}`);
+            this.arenaSlots.set(e, slot);
+            this.declare(`declare ptr @scr_arena_open(ptr, i32)`);
+            this.declare(`declare void @scr_arena_close(ptr)`);
+            this.declare(`declare void @scr_arena_drop(ptr)`);
+        }
+        return slot;
+    }
+    /** Whether emitExpr opens an arena for `e`: a root call or `new` of a
+     * counted value. */
+    opensArena(e) {
+        return (this.arenas !== null &&
+            this.arenas.groups.roots.has(e) &&
+            (e.kind === "call" || e.kind === "new") &&
+            isRefCounted(e.type));
+    }
+    /** 1 when the group of root or call region `e` is closed: its objects
+     * hold only each other and immortal values. */
+    arenaClosed(e) {
+        return this.arenas?.groups.closed.has(e) === true ? 1 : 0;
+    }
+    /** Registers on the innermost scope the arena lists of the roots whose
+     * arenas `localId`'s scope drops. */
+    ownArenasOf(localId) {
+        const roots = this.arenaDropsByLocal.get(localId);
+        if (roots === undefined)
+            return;
+        const scope = this.scopes[this.scopes.length - 1];
+        for (const { root, type } of roots)
+            scope.push({ slot: this.arenaSlot(root), type, arena: true });
+    }
+    /** The roots of the function being emitted, by the local that drops
+     * them; set when a function's emission starts. */
+    arenaDropsByLocal = new Map();
+    /** Starts a function's arena bookkeeping: its roots by dropping local,
+     * with the lists of locals the body never declares (parameters, loop
+     * and catch bindings) owned by the function's own scope. */
+    beginArenaFunction(fn) {
+        this.arenaSlots.clear();
+        this.statementFrames.clear();
+        this.arenaDropsByLocal = new Map();
+        const arenas = this.arenas;
+        if (arenas === null)
+            return;
+        const declared = new Set();
+        const visit = (node) => {
+            if (node.kind === "varDecl")
+                declared.add(node.localId);
+            if (this.opensArena(node)) {
+                const local = arenas.groups.drops.get(node);
+                if (local !== undefined && local !== null) {
+                    const list = this.arenaDropsByLocal.get(local) ?? [];
+                    list.push({ root: node, type: node.type });
+                    this.arenaDropsByLocal.set(local, list);
+                }
+            }
+            const kids = [];
+            children(node, kids);
+            for (const kid of kids)
+                visit(kid);
+        };
+        for (const s of fn.body)
+            visit(s);
+        for (const local of [...this.arenaDropsByLocal.keys()])
+            if (!declared.has(local))
+                this.ownArenasOf(local);
+    }
+    /** Whether allocation site `e` (null: any) in the function being
+     * emitted takes the open arena: the function is arena-aware and the group
+     * keeps the site's value (region-sites.ts). */
+    arenaSite(e) {
+        const arenas = this.arenas;
+        if (!arenaAware(arenas, this.fnByName.get(this.currentFunctionName)))
+            return false;
+        return e === null || arenas.sites.arenaSites.has(e);
+    }
+    /** Stops any arena being the allocation target; returns what restores it. */
+    suspendArena() {
+        const saved = this.B.tmp();
+        const cur = this.B.tmp();
+        const lines = arenaCurrentAddress(this.shapeHost, cur);
+        if (lines === null) {
+            this.declare(`declare ptr @scr_arena_suspend()`);
+            this.B.line(`${saved} = call ptr @scr_arena_suspend()`);
+        }
+        else {
+            for (const line of lines)
+                this.B.line(line);
+            this.B.line(`${saved} = load ptr, ptr ${cur}`);
+            this.B.line(`store ptr null, ptr ${cur}`);
+        }
+        return saved;
+    }
+    /** Makes the arena suspendArena stopped (`saved`) the target again. */
+    resumeArena(saved) {
+        const cur = this.B.tmp();
+        const lines = arenaCurrentAddress(this.shapeHost, cur);
+        if (lines === null) {
+            this.declare(`declare void @scr_arena_resume(ptr)`);
+            this.B.line(`call void @scr_arena_resume(ptr ${saved})`);
+        }
+        else {
+            for (const line of lines)
+                this.B.line(line);
+            this.B.line(`store ptr ${saved}, ptr ${cur}`);
+        }
+    }
+    /** The arena-aware constructor of `newSym` for an allocation of a
+     * record shape or class in the function being emitted, or `newSym`. */
+    allocSym(newSym, e) {
+        const arenas = this.arenas;
+        if (arenas === null)
+            return newSym;
+        const planned = e.type.kind === "record"
+            ? arenas.shapes.has(e.type.shapeId)
+            : e.kind === "new" && arenas.classes.has(e.className);
+        if (!planned)
+            return newSym;
+        const aware = this.arenaSite(e) || arenas.groups.roots.has(e);
+        return aware ? arenaNewSym(newSym) : newSym;
+    }
     /** The helper classification of this module's inline-cache sites. */
     get jsIcSites() {
         return (this.jsIcSitesMemo ??= new JsIcSites(this.mod));
@@ -6308,8 +6903,17 @@ export class LlEmitter {
     wrapEmitterListener(target, adapterFn) {
         return wrapEmitterListener(this, target, adapterFn);
     }
-    unwrapNullableClosure(u, funcTag) {
-        return unwrapNullableClosure(this, u, funcTag);
+    /** ScrClosure.function_kind for a closure over `fn`: its generator,
+     * async and own prototype bits, and RECEIVER_FREE when its body never
+     * observes the ambient receiver, so indirect callers skip the bracket. */
+    closureFunctionKind(fn) {
+        return ((fn.generator ? CLOSURE_KIND.GENERATOR : 0) +
+            (fn.async ? CLOSURE_KIND.ASYNC : 0) +
+            (fn.ownsPrototype ? CLOSURE_KIND.OWN_PROTOTYPE : 0) +
+            (this.receiverReaders.ignores(fn) ? CLOSURE_KIND.RECEIVER_FREE : 0));
+    }
+    unwrapNullableClosure(u, unionId, funcTag) {
+        return unwrapNullableClosure(this, u, unionId, funcTag);
     }
     closeBindThunkFor(cbUnion, retServer) {
         return closeBindThunkFor(this, cbUnion, retServer);
@@ -6441,6 +7045,15 @@ export class LlEmitter {
             return;
         const integer = this.emitToUint32(value.name, expr, value.uint32);
         this.B.line(`store i32 ${integer}, ptr ${slot}`);
+        const orderedSlot = this.orderedViews.get(localId);
+        if (orderedSlot === undefined)
+            return;
+        let ordered = value.ordered;
+        if (ordered === undefined) {
+            ordered = this.B.tmp();
+            this.B.line(`${ordered} = fcmp ord double ${value.name}, 0.0`);
+        }
+        this.B.line(`store i1 ${ordered}, ptr ${orderedSlot}`);
     }
     emitBytesSet(elem, receiver, index, value, indexExpr, expr, inBounds = false, owned = false, scope = "") {
         return emitBytesSet(this, elem, receiver, index, value, indexExpr, expr, inBounds, owned, scope);