@scriptc/compiler 0.4.5 → 0.4.6

package/dist/backend/llvm/emitter.d.ts

@@ -1,18 +1,24 @@
 import type { TargetCpu } from "../target-cpu.js";
+import type { FunctionLayout } from "./function-layout.js";
+import type { CompilationTiming } from "../../timing.js";
+import { type FrameEscapes } from "./frame-escapes.js";
 import { JsIcSites } from "../../ir/js-ic.js";
 import { type ArraySearchKind } from "./array-search.js";
 import type { IrBytesElem, IrExpr, IrFfiCallbackParam, IrFfiImport, IrFunction, IrGlobal, IrLocal, IrModule, IrRecordShape, IrStmt, IrType, IrUnionDef, SrcLoc } from "../../ir/ir.js";
 import { type RuntimeFeatures } from "../../ir/runtime-features.js";
 import { matchBytesLoopVersion } from "./bytes-loop-versions.js";
+import type { BytesHeaderScope } from "./bytes-headers.js";
 import type { IntegerCountedForLoop, IntegerPairedForLoop } from "../../ir/integer-loops.js";
 import { type SplitSpan, type StoredSplitSnapshot } from "./split-loops.js";
 import { type ChunkResult, EmitJournal } from "./emit-journal.js";
+import { type InlineArrayPlan } from "../../ir/inline-arrays.js";
 import { type IntegerRange, type IntegerRanges } from "../../ir/integer-ranges.js";
 import { type DynamicFieldStores, Int32Slots } from "../../ir/int32-slots.js";
 import { type FinalFields } from "../../ir/final-fields.js";
 import { type Int32Abi } from "./int32-abi.js";
 import { type Int32Local } from "./int32-locals.js";
-import { type IntegerClones } from "./integer-clones.js";
+import { type CloneReferences, type IntegerClones } from "./integer-clones.js";
+import { type HeapCensus } from "./heap-census.js";
 import { findInitializerBindings } from "../../ir/initializer-bindings.js";
 import { type ConstantNumericTable } from "../../ir/constant-tables.js";
 import { type FfiCallbackAdapter } from "../ffi-callbacks.js";
@@ -40,8 +46,10 @@ import { StackCaptures } from "./stack-captures.js";
 import { PublishWalkers } from "./publish.js";
 import { type PublishedTypes } from "../publication.js";
 import { type BytesThunkValue } from "./expr-stream-callbacks.js";
-import { type LlClassMeta } from "./classes.js";
+import { type LlClassMeta, type LlInlineTail } from "./classes.js";
 import { LifetimeRegions } from "./regions.js";
+import { type ArenaPlan } from "./arenas.js";
+import { type Node } from "./region-ir.js";
 import { LlDyn, type DynHost } from "./dyn.js";
 import { LlWalkers } from "./walkers.js";
 import { NullableUnions } from "./nullable-unions.js";
@@ -64,6 +72,9 @@ export interface LlScopeEntry {
     slot: string;
     type: IrType;
     boxed?: boolean;
+    /** A group arena list slot (arenas.ts), dropped after the scope's other
+     * entries. */
+    arena?: boolean;
     /** A lazily created box: the slot stays null on paths that build no
      * environment, which skip the release call. */
     lazy?: boolean;
@@ -76,6 +87,10 @@ export interface ForkPrimitives {
     exit(code: number): void;
     /** The worker's exit status, 128 plus a signal number, or -1. */
     wait(pid: number): number;
+    /** The pid of a child process that has ended, waiting for one if none
+     * has, or -1, without reaping it. Without it, workers are waited for in
+     * order. */
+    exited?(): number;
 }
 export interface LlvmTargetOptions {
     /** C ABI target; omitted direct emission uses the host ABI. */
@@ -98,10 +113,21 @@ export interface LlvmTargetOptions {
     /** The host's process primitives, where it can fork (the native
      * compiler's). */
     forkPrimitives?: ForkPrimitives | undefined;
+    /** Functions to write first, by tier (function-layout.ts). */
+    functionLayout?: FunctionLayout;
+    /** Marks emission's serial steps: `llvm-emit-rewrites` after the module
+     * passes, `llvm-emit-int32` after int32 selection, and
+     * `llvm-emit-analyses` after the emitter's whole-program analyses. The
+     * caller's next phase is the function bodies. */
+    timing?: CompilationTiming;
     /** Exact frontend sources for dev-build locations and variable metadata. */
     debugSources?: ReadonlyMap<string, string>;
     /** Pointer width of the target C ABI. Native targets are 64-bit today. */
     pointerBits?: 32 | 64;
+    /** Unions emitted as tagged boxes whatever their arms, for tests of the
+     * box paths: in a program, a union that has a pointer representation
+     * (nullable-unions.ts) never holds a box. */
+    boxedUnions?: ReadonlySet<string>;
     /** Select the WASI libc entry-point convention. */
     wasi?: boolean;
     /** Library archive assembly may move the volatile identity getters into a
@@ -122,10 +148,22 @@ export interface LlvmTargetOptions {
     inlineRc?: InlineRcMode;
     /** Define the inline RC fast-path helpers `noinline` (sanitized builds). */
     rcHelpersNoinline?: boolean;
+    /** Mark every emitted function `sanitize_address`, which the sanitized
+     * lane's `-fsanitize=address` link needs to instrument it. Without a
+     * sanitizer pass the attribute still turns off shrink-wrapping and
+     * speculative loads, so plain builds pass false. Defaults to true for
+     * direct emission. */
+    sanitizeAttributes?: boolean;
     /** Define `scr_detached_exit` so the Linux runtime hands the address-space
      * teardown after `process.exit` to a helper process (`--detached-exit`).
      * Executables only; the runtime's weak default keeps it off. */
     detachedExit?: boolean;
+    /** The files of the program's Node island module tree, in manifest order
+     * (node-islands/modules.ts), when the executable carries the tree. */
+    nodeIslandModuleData?: Uint8Array;
+    /** The program throws rarely (`--exceptions=rare`): recursive functions
+     * and those near a `throw` also unwind (unwindAbiFunctions). */
+    rareExceptions?: boolean;
     /** Translated WebAssembly memories check bounds explicitly instead of
      * relying on guard pages (wasm-modules.ts wasmBoundsChecks). */
     wasmBoundsChecks?: boolean;
@@ -138,6 +176,11 @@ export interface LlvmTargetOptions {
      * every emitted function carries it as its `target-cpu`. Unset, code
      * runs on any x86-64 CPU. */
     targetCpu?: TargetCpu;
+    /** Give an x86-64 executable without a `targetCpu` an x86-64-v3 copy of
+     * each program function, which it runs on CPUs at that level
+     * (cpu-dispatch.ts). Ignored for other targets, libraries and builds
+     * with debug information. */
+    cpuDispatch?: boolean;
 }
 /** LlvmTargetOptions.lowRegion for an executable: Linux targets without
  * sanitizers, whose address space below 32 GiB is free (ASan keeps its
@@ -163,7 +206,10 @@ export declare function emitLlvmModuleParts(input: IrModule, options?: LlvmTarge
 export declare function emitLlvmModuleSource(input: IrModule, options?: LlvmTargetOptions): string | readonly string[];
 export declare function llStrBytes(text: string): string;
 /** Runtime entry points (and await-call entries) that may park the running
- * execution context, as they appear in emitted function text. */
+ * 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 declare const SUSPENDS: RegExp;
 /** Captured bindings (boxes a body declares or receives) from which a
  * function compiles without LLVM optimization (see boxSlotCount). */
@@ -365,11 +411,13 @@ export declare class LlEmitter {
      * generator stacks) and so do debug builds (the debugger reads locals
      * from the native frame). */
     private stacklessGenerators;
-    /** 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. */
     private stacklessAsyncAllowed;
-    /** The async functions selectStacklessAsync lowered as coroutines. */
+    /** The async functions and async generators selectStacklessAsync lowered
+     * as coroutines. */
     readonly stacklessAsync: Set<string>;
     /** Some function in the module is lowered as a coroutine. */
     usesCoroutines: boolean;
@@ -389,7 +437,12 @@ export declare class LlEmitter {
     readonly emitLibraryIdentity: boolean;
     readonly runtimeAbiMarker: boolean;
     readonly detachedExit: boolean;
+    readonly nodeIslandModuleData: Uint8Array | null;
     readonly targetCpu: TargetCpu | undefined;
+    /** Emitted functions carry `sanitize_address` (LlvmTargetOptions). */
+    readonly sanitizeAttributes: boolean;
+    /** LlvmTargetOptions.cpuDispatch, where it applies. */
+    readonly cpuDispatch: boolean;
     readonly wasmBoundsChecks: boolean;
     /** Interned string literals: UTF-8 text → { symbol, byte length } —
      * first-use order, the runtime ABI’s determinism discipline. */
@@ -433,6 +486,14 @@ export declare class LlEmitter {
         pattern: string;
         flags: string;
     }>;
+    /** Build-time replacers: one per (pattern, flags, replacement) of a
+     * global substitution with a literal replacement (regex-matchers.ts). */
+    readonly regexReplacers: Map<string, {
+        sym: string;
+        pattern: string;
+        flags: string;
+        replacement: string;
+    }>;
     /** 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
@@ -462,6 +523,8 @@ export declare class LlEmitter {
     readonly dyn: LlDyn;
     /** Explicit callback boundary for standalone layout and walker stages. */
     readonly shapeHost: DynHost;
+    /** The record view plan's target set (record-views.ts), shared by reference. */
+    private recordViewTargets;
     /** External declarations, in first-use order. */
     readonly decls: Set<string>;
     /** Declared functions referenced as values: each needs an env-signature
@@ -510,6 +573,9 @@ export declare class LlEmitter {
     /** The current function's fused string-key Map get-then-set pairs (map-entry-fusion.ts). */
     mapEntryFusion: MapEntryFusion | null;
     readonly callLifetimes: CallLifetimes;
+    /** The locals whose value never leaves its frame (frame-escapes.ts), for
+     * class instances with reference fields in frame storage. */
+    frameEscapes: FrameEscapes | null;
     readonly constantCallbacks: Map<string, Map<string, string>>;
     currentConstantCallbacks: ReadonlyMap<string, string>;
     /** The current function's running maximum and minimum updates, whose
@@ -587,6 +653,9 @@ export declare class LlEmitter {
     /** Functions that check the native stack guard on entry
      * (stackCheckedFunctions); null where the runtime has no guard. */
     readonly stackChecks: ReadonlySet<string> | null;
+    /** Small leaf functions called only from loops, whose direct calls are
+     * `alwaysinline` (loop-callees.ts). */
+    readonly loopCallees: ReadonlySet<string>;
     /** Static types whose values can be published (@scriptc/threads): their
      * stores carry the frozen-object guard. Null without publish calls. */
     readonly publishedTypes: PublishedTypes | null;
@@ -640,6 +709,10 @@ export declare class LlEmitter {
     /** setTimeout and friends appeared somewhere: main must run the event
      * loop even in programs with no async functions. */
     usesTimers: boolean;
+    /** 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: boolean;
     /** The program calls mock.timers members (moduleUsesMockTimers): timer
      * calls emit scr_test.c's mock-aware entry points. */
     readonly mockTimers: boolean;
@@ -677,6 +750,8 @@ export declare class LlEmitter {
     readonly inlineUnions: InlineUnionFields;
     /** Unions whose values are nullable arm pointers (nullable-unions.ts). */
     readonly nullableUnions: NullableUnions;
+    /** The counters of a build instrumented for the heap census, or null. */
+    readonly heapCensus: HeapCensus | null;
     /** The union table without nullable unions: the stack-box analyses. */
     readonly boxedUnionsById: Map<string, IrUnionDef>;
     readonly recordsById: Map<string, IrRecordShape>;
@@ -781,6 +856,11 @@ export declare class LlEmitter {
      * commit back into their objects. Library builds keep their commits:
      * their values cross a native boundary. */
     readonly liveViewsReadOnly: boolean;
+    /** IrModule.sloppyDynWrites: untyped writes in sloppy-mode code. */
+    readonly sloppyDynWrites: ReadonlySet<string>;
+    /** IrModule.foreignElementKeys: element keys whose arrays can hold
+     * SCR_ARR_FOREIGN elements. */
+    readonly foreignElementKeys: ReadonlySet<string>;
     /** 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. */
@@ -789,6 +869,8 @@ export declare class LlEmitter {
     readonly int32Abis: ReadonlyMap<string, Int32Abi>;
     /** Pure number functions with speculative integer clones. */
     readonly integerClones: IntegerClones;
+    /** The records integer clones read (64-bit layouts). */
+    readonly cloneReferences: CloneReferences | undefined;
     /** The IR function being emitted. */
     currentFunctionName: string;
     integerParamRange(fnName: string, localId: string): IntegerRange | null;
@@ -798,6 +880,9 @@ export declare class LlEmitter {
     /** ProgramLifetime hierarchy roots (contract types): their instances are
      * immortal from construction (classes.ts programLifetimeClass). */
     readonly programLifetime: ReadonlySet<string>;
+    /** Inline array fields this emission may keep inline (ir/inline-arrays.ts);
+     * the classes that do have LlClassMeta.inlineTail. */
+    readonly inlineArrays: InlineArrayPlan;
     numericLocals: Map<string, IrLocal>;
     captureIds: Set<string>;
     /** Active induction bindings retain their width independently of size_t. */
@@ -842,6 +927,9 @@ export declare class LlEmitter {
         ran?: string;
         /** Writes that speculate a rewritten value (rewriteSpeculable). */
         values?: ReadonlyMap<IrStmt, SpeculativeValue>;
+        /** A proven integer loop's expression-position `++`/`--` of its
+         * shadowed bindings (ProvenLoopPlan.increments). */
+        increments?: ReadonlySet<IrExpr>;
     } | null;
     /** Speculative loop sites numbered so far in the module. */
     speculativeLoopSites: number;
@@ -910,15 +998,33 @@ export declare class LlEmitter {
     /** Worker programs: typed-array accesses whose views an enclosing version
      * guard proved thread-owned. */
     bytesOwned: ReadonlySet<IrExpr | IrStmt>;
+    /** 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: {
+        counter: string;
+        target: LlEmitter["jumpTargets"][number];
+        depth: number;
+    } | 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: ReadonlyMap<IrExpr | IrStmt, string>;
     bytesAccessScope: string;
+    /** Header fields a speculative loop's entry read for its views
+     * (bytes-headers.ts), while its copies are emitted. */
+    bytesHeaders: BytesHeaderScope | null;
+    /** The parameters of the function being emitted. */
+    currentParameters: ReadonlySet<string>;
     /** Loop versions with alias scopes in the current function; it names
      * their scopes. */
     aliasScopedVersions: number;
     integerViews: Map<string, string>;
+    /** 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: Map<string, string>;
     /** Module globals the current function owns outright (initializer
      * bindings): their function-local slot, which stands in for the global. */
     privateGlobalSlots: Map<string, string>;
@@ -963,9 +1069,12 @@ export declare class LlEmitter {
     currentUnionResult: boolean;
     /** 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: {
         kind: "async" | "generator";
+        /** The body awaits: an async function or an async generator. */
+        awaits: boolean;
         id: string;
         handle: string;
         self: string;
@@ -1053,19 +1162,21 @@ export declare class LlEmitter {
     private mangledFunctions;
     /** The module functions whose ordinary or borrowed body `text` mentions. */
     mentionedFunctions(text: string): Generator<string>;
-    /** 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: string[]): void;
     /** Whether a fiberless body running on its caller's stack needs the
      * frame scr_async_inline_enter/exit keep: it isolates the Error.stack
@@ -1147,12 +1258,13 @@ export declare class LlEmitter {
      * native async bodies selectStacklessAsync chose. */
     coroLowered(fn: IrFunction): boolean;
     emitGenScaffolding(): string[];
-    /** 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. */
-    private contentSymbol;
+    /** 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: string, text: string): string;
     internLiteral(text: string): string;
     /** The inline equality test against one string literal (an
      * `i1 (ptr)` helper LLVM inlines at each site), by literal symbol. */
@@ -1205,7 +1317,7 @@ export declare class LlEmitter {
     own(v: LlValue): LlValue;
     /** Registers a SLOT whose current contents the frame owns (conditional
      * results: optional chains, branch joins that park ownership). */
-    ownSlot(slot: string, type: IrType): void;
+    ownSlot(slot: string, type: IrType, rarelyFilled?: boolean): void;
     /** The innermost lexical scope releases a frame object's reference
      * fields when it exits, as it releases its bindings. */
     ownScopeFields(fields: readonly StackObjectField[]): void;
@@ -1290,7 +1402,10 @@ export declare class LlEmitter {
     emitPendingCheck(passThrough?: {
         name: string;
         type: IrType;
-    }, poll?: boolean, guard?: string): void;
+    }, poll?: boolean, guard?: string, 
+    /** Runs at the start of the cold unwind block, before the unwind (a
+     * package-declared check's origin note). */
+    onUnwind?: () => void): void;
     /** After a runtime call that ALWAYS leaves an exception pending (the
      * compiler-resolved Node throws): the pending test would always answer
      * true, so unwind unconditionally. Emission continues in a block with no
@@ -1322,6 +1437,13 @@ export declare class LlEmitter {
     workerLoopPolls(loop: Extract<IrStmt, {
         kind: "while" | "doWhile" | "for" | "forOf";
     }>): boolean;
+    /** 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: Extract<IrStmt, {
         kind: "while" | "doWhile" | "for" | "forOf";
     }>): string | null;
@@ -1353,9 +1475,9 @@ export declare class LlEmitter {
      * stay in the loop. */
     emitWorkerLoopCheck(slot: string | null): void;
     /** 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(): void;
     /** Moves an already-evaluated value into the runtime's exception cell —
      * the `throw` statement's kind dispatch (stmts.ts's), shared with
@@ -1444,6 +1566,11 @@ export declare class LlEmitter {
     unionNoneRef(): string;
     /** 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. */
+    private recordCloneReferences;
     recordFieldPtr(objName: string, shapeId: string, field: string): {
         ptr: string;
         type: IrType;
@@ -1826,6 +1953,8 @@ export declare class LlEmitter {
      * table neither retains nor releases. Lookups and inserts of array keys
      * throw a TypeError for keys longer than a table accepts. */
     private emitInternTableIntrinsic;
+    /** Arrays of this element type can hold SCR_ARR_FOREIGN elements. */
+    mayHoldForeign(elem: IrType): boolean;
     /** Lifetime regions in modules with lifetimeRegions (llvm/regions.ts).
      * Created with the class graph; null elsewhere. */
     regions: LifetimeRegions | null;
@@ -1870,6 +1999,9 @@ export declare class LlEmitter {
     emitSerializationExpr(e: ExprOf<"jsonStringify" | "dynCheck">): LlValue;
     emitAsyncExpr(e: ExprOf<"yieldExpr" | "genResume" | "awaitExpr" | "awaitUnionExpr" | "newPromise" | "promiseWithResolvers">): LlValue;
     emitReadReceiver(e: IrExpr): LlValue;
+    /** The inline array field of `className`'s instances, where they keep it
+     * inline (LlClassMeta.inlineTail; classes.ts gives their `new` the count). */
+    inlineTailOf(className: string): LlInlineTail | undefined;
     /** The frame slot a reassigned stack-object local keeps for its value. */
     stackObjectSlot(localId: string, type: IrType): string;
     canStackReceiver(e: IrExpr): boolean;
@@ -1915,6 +2047,12 @@ export declare class LlEmitter {
     /** The instance of a capsule known to hold exactly this class (borrowed). */
     emitExactCapsuleObject(value: IrExpr, type: IrType): LlValue;
     canBorrowReceiver(e: IrExpr): boolean;
+    /** 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: IrExpr): boolean;
     /** 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
@@ -1935,6 +2073,54 @@ export declare class LlEmitter {
     borrowableNullableWrap(e: IrExpr): "unit" | "ref" | null;
     materializeSplitLocal(localId: string): void;
     emitExpr(e: IrExpr): LlValue;
+    /** emitExpr when group arenas are planned. Kept out of emitExpr, whose
+     * frame each level of a nested expression holds while it is emitted. */
+    private emitArenaExpr;
+    /** Group arenas (arenas.ts): the plan, the list slot of each root and
+     * call region, and which locals' scopes drop which roots' arenas. */
+    arenas: ArenaPlan | null;
+    private arenaSlots;
+    /** The frames emitStmtBody opens for whole statements (arenas only). */
+    readonly statementFrames: Set<LlValue[]>;
+    /** The frame of the statement being emitted: a nested frame (call
+     * arguments, branches) ends before the values built in it do. */
+    statementFrame(): LlValue[];
+    /** 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: Node): string;
+    /** Whether emitExpr opens an arena for `e`: a root call or `new` of a
+     * counted value. */
+    opensArena(e: Node): e is Extract<IrExpr, {
+        kind: "call" | "new";
+    }>;
+    /** 1 when the group of root or call region `e` is closed: its objects
+     * hold only each other and immortal values. */
+    arenaClosed(e: Node): number;
+    /** Registers on the innermost scope the arena lists of the roots whose
+     * arenas `localId`'s scope drops. */
+    ownArenasOf(localId: string): void;
+    /** The roots of the function being emitted, by the local that drops
+     * them; set when a function's emission starts. */
+    arenaDropsByLocal: Map<string, {
+        root: Node;
+        type: IrType;
+    }[]>;
+    /** 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: IrFunction): void;
+    /** 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: IrExpr | null): boolean;
+    /** Stops any arena being the allocation target; returns what restores it. */
+    suspendArena(): string;
+    /** Makes the arena suspendArena stopped (`saved`) the target again. */
+    resumeArena(saved: string): void;
+    /** The arena-aware constructor of `newSym` for an allocation of a
+     * record shape or class in the function being emitted, or `newSym`. */
+    allocSym(newSym: string, e: IrExpr): string;
     /** The helper classification of this module's inline-cache sites. */
     get jsIcSites(): JsIcSites;
     jsIcSite(): string;
@@ -1976,7 +2162,11 @@ export declare class LlEmitter {
         shim: string;
     };
     wrapEmitterListener(target: string, adapterFn: string): string;
-    unwrapNullableClosure(u: string, funcTag: number): string;
+    /** 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: IrFunction): number;
+    unwrapNullableClosure(u: string, unionId: string, funcTag: number): string;
     closeBindThunkFor(cbUnion: IrType, retServer: boolean): string;
     closeOverrideWrapFor(cbUnion: IrType, retServer: boolean): string;
     streamDataAdapter(cbT: IrType & {