@scriptc/compiler 0.4.1 → 0.4.3

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

@@ -1,11 +1,11 @@
 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 DenseArrayLoop } from "./dense-array-loops.js";
-import { findInitializedByteLoopBindings } from "./byte-windows.js";
+import { type RuntimeFeatures } from "../../ir/runtime-features.js";
 import { matchBytesLoopVersion } from "./bytes-loop-versions.js";
-import type { IntegerCountedForLoop } from "../../ir/integer-loops.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 IntegerRange, type IntegerRanges } from "../../ir/integer-ranges.js";
 import { type Int32Slots } from "../../ir/int32-slots.js";
 import { type FinalFields } from "../../ir/final-fields.js";
@@ -23,9 +23,11 @@ import { NullableRefFields, type NullableRefField } from "./nullable-fields.js";
 import { InlineUnionFields } from "./inline-unions.js";
 import { OptionalArrayReads, type LocalArrayRead } from "./local-array-reads.js";
 import { CheckedNarrows } from "./checked-narrows.js";
+import { type ArrayAccess } from "./dense-array-access.js";
 import { type MapReadLifetimes } from "./map-read-lifetimes.js";
 import { type MapEntryFusion } from "./map-entry-fusion.js";
 import { type WalkBorrowHost } from "./walk-borrows.js";
+import { IrNodeIndex } from "../../ir/node-index.js";
 import { ReferenceEffects } from "./reference-effects.js";
 import { ReferenceWrites, type Writes } from "./reference-writes.js";
 import { LlvmDebugInfo } from "./debug-info.js";
@@ -64,9 +66,31 @@ export interface LlScopeEntry {
      * environment, which skip the release call. */
     lazy?: boolean;
 }
+/** Process primitives for forked emission workers. */
+export interface ForkPrimitives {
+    /** 0 in the worker, the worker's pid in the parent, -1 on failure. */
+    fork(): number;
+    /** Ends the worker without running exit handlers. */
+    exit(code: number): void;
+    /** The worker's exit status, 128 plus a signal number, or -1. */
+    wait(pid: number): number;
+}
 export interface LlvmTargetOptions {
     /** C ABI target; omitted direct emission uses the host ABI. */
     targetTriple?: string;
+    /** Emit the function bodies in this many contiguous ranges, each by its
+     * own emitter, and merge them in function order (emit-journal.ts). The
+     * output is the same as one emitter's. Debug builds (`debugSources`)
+     * emit in one emitter. */
+    functionChunks?: number;
+    /** Emit the function bodies of a large module on this many forked worker
+     * processes at a time (emit-module.ts), forked with `forkPrimitives`. The
+     * output is the same as one emitter's. Debug builds (`debugSources`)
+     * emit in one emitter. */
+    functionWorkers?: number;
+    /** The host's process primitives, where it can fork (the native
+     * compiler's). */
+    forkPrimitives?: ForkPrimitives | undefined;
     /** 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. */
@@ -98,8 +122,22 @@ export interface LlvmTargetOptions {
     /** Translated WebAssembly memories check bounds explicitly instead of
      * relying on guard pages (wasm-modules.ts wasmBoundsChecks). */
     wasmBoundsChecks?: boolean;
+    /** The executable can reserve its program-lifetime region below 32 GiB
+     * (lowRegionTarget): fields that refer to compact class instances then
+     * store the instance's address over 8 in 32 bits (classes.ts
+     * compactRefLoadLines). Elsewhere they keep 8-byte pointers. */
+    lowRegion?: boolean;
 }
+/** LlvmTargetOptions.lowRegion for an executable: Linux targets without
+ * sanitizers, whose address space below 32 GiB is free (ASan keeps its
+ * shadow memory there; other systems map their own images and libraries
+ * there). `platform` is a target platform (`linux`, `darwin`, `win32`,
+ * `wasi`). */
+export declare function lowRegionTarget(platform: string, sanitize: boolean): boolean;
 export declare function emitLlvmModule(input: IrModule, options?: LlvmTargetOptions): string;
+/** emitLlvmModule's text as parts that concatenate to it, without the copy
+ * that joining them makes: a large program's text is 150 MB. */
+export declare function emitLlvmModuleParts(input: IrModule, options?: LlvmTargetOptions): string[];
 /** Keep large translation units below the host's single-string limit. */
 export declare function emitLlvmModuleSource(input: IrModule, options?: LlvmTargetOptions): string | readonly string[];
 export declare function llStrBytes(text: string): string;
@@ -129,6 +167,8 @@ export declare function boxSlotCount(fn: IrFunction): number;
 export declare const MAX_BYTES_LOOP_VERSION_DEPTH = 3;
 export declare class LlEmitter {
     readonly mod: IrModule;
+    /** Per-feature state (emitter-state.ts), indexed by each key's slot. */
+    readonly moduleStates: unknown[];
     localArrayReads: Map<string, LocalArrayRead>;
     loopArrayBorrows: ReadonlySet<IrStmt>;
     scalarStringSlices: Map<string, {
@@ -207,6 +247,15 @@ export declare class LlEmitter {
     integerArrayBindings: Set<string>;
     readonly fieldAliasTags: Map<string, number>;
     readonly fieldPointerTags: Map<string, number>;
+    /** The field pointers (classFieldPtr) of this function whose fields hold
+     * 32-bit references to compact class instances (LlClassMeta.compressed):
+     * loadField/loadRef decode them and storeField/storeRef encode them. */
+    readonly compressedFieldPtrs: Set<string>;
+    /** Compact class instances live in the program-lifetime region below
+     * 32 GiB (LlvmTargetOptions.lowRegion, and the program has compact
+     * classes): main reserves it before compiled code runs (scr_plr_init), and
+     * fields and arrays of compactRefType hold 32-bit references. */
+    compactRegion: boolean;
     /** Native class fields with different property names cannot occupy the
      * same slot of one object. Inherited views of the same property share a
      * tag. Array storage has its own disjoint categories; untagged runtime
@@ -216,9 +265,64 @@ export declare class LlEmitter {
     /** The alias tag of a runtime word that emitted code reads and writes
      * outside every field (the lifetime-region count, owner and cursors). */
     memoryAliasAttachment(category: string): string;
+    /** The current function's int32 array allocations: the array literals
+     * its int32 arrays are written with. They construct SCR_ELEM_I32 arrays. */
+    int32Allocations: Set<IrExpr>;
+    /** The fill temporaries (`new Array(n).fill(v)`) of those allocations:
+     * the same arrays, so int32 too. */
+    int32ArrayTemps: Set<string>;
+    /** The same for the current function's int32 arrays with checked stores,
+     * which are only allocated by fills (ir/int32-arrays.ts
+     * checkableInt32Allocations): their temporaries' literals, with the fill's
+     * length (a literal constructs SCR_ELEM_I32 storage when that length is at
+     * least CHECKED_INT32_MIN_LENGTH, SCR_ELEM_F64 otherwise), and their
+     * temporaries. */
+    checkedAllocations: Map<IrExpr, IrExpr>;
+    checkedArrayTemps: Set<string>;
+    /** The fill calls (`.fill(v)`) of those allocations: a value that is not
+     * an int32 widens the new array first. */
+    checkedFills: Set<IrExpr>;
+    /** Collect the int32 allocations of `fn`, about to be emitted. */
+    findInt32Allocations(fn: IrFunction): void;
+    /** Whether `arr` reads one of the int32 arrays (ir/int32-arrays.ts, kept
+     * by the int32 slot analysis): a local or parameter of the current
+     * function, or a module global. */
+    int32Array(arr: IrExpr): boolean;
+    /** Whether `arr` is one of the current function's int32 arrays with
+     * checked stores: int32 slots until a store widens it to doubles. Every
+     * access tests its kind (emitByElementKind), except in the fast copy of
+     * an int32 kind loop, which reads and writes it as an int32 array. */
+    checkedInt32Array(arr: IrExpr): boolean;
+    /** Whether the local `localId` holds one of the current function's int32
+     * arrays with checked stores. */
+    checkedInt32Local(localId: string): boolean;
+    /** Whether `arr` is an int32 array with checked stores that the fast copy
+     * of the int32 kind loop being emitted holds as an int32 array. */
+    int32KindArray(arr: IrExpr): boolean;
+    /** Before a store of `value` (of `expr`) into `arr`, in the fast copy of
+     * an int32 kind loop: continue when it is an int32 that is not -0, and
+     * otherwise leave for the statement's resume point, where it re-executes
+     * with kind tests. Returns the value as an i32 when it is at hand as an
+     * integer, or null when the store converts the double itself. */
+    emitInt32KindStoreCheck(arr: IrExpr, value: LlValue, expr: IrExpr): string | null;
+    /** Emit an access to the checked int32 array `array` once per element
+     * kind: `arm("i32", widened)` while it holds int32 slots and
+     * `arm("f64", widened)` after it widened, joined after both. `widened` is
+     * the label of the double arm, where an int32 arm's store of a value that
+     * is not an int32 continues after widening the array. Returns the phi of
+     * the arms' results (of LLVM type `ty`), or null when `ty` is null. */
+    emitByElementKind(array: string, ty: string | null, arm: (acc: "i32" | "f64", widened: string) => string | null): string | null;
+    /** Before storing the double `value` (of `expr`) into an int32 arm
+     * (emitByElementKind) of the checked int32 array `array`: continue in this
+     * arm when it is an int32 that is not -0, or widen the array and continue
+     * at `widened`. A value proven an int32 needs no test. */
+    emitCheckedInt32Store(array: string, value: string, expr: IrExpr, widened: string): void;
+    /** The access an element operation on `arr` (of element type `elem`)
+     * takes: int32 arrays read and write their 4-byte slots. */
+    arrayAccess(arr: IrExpr, elem: IrType): ArrayAccess;
     /** Whether an element access at `index` of `arr` lies in the hole-free
-     * prefix: the counter of a dense array loop's fast copy indexing one of
-     * the arrays its entry test covered. */
+     * prefix: a counter of a dense array loop's fast copy indexing one of the
+     * arrays its entry test covered. */
     provenDenseIndex(arr: IrExpr, index: IrExpr): boolean;
     fieldAliasAttachment(ptr: string): string;
     fieldAliasMetadata(): string[];
@@ -322,6 +426,10 @@ export declare class LlEmitter {
     }>;
     /** Interned ScrMapOps descriptors (scr_map.h): initializer → symbol. */
     readonly mapOpsConsts: Map<string, string>;
+    /** Method-id slots of checked-dynamic method calls
+     * (scr_dyn_invoke_prepared_id): method name → symbol of an i32 the
+     * runtime fills with the name's id on the first call. */
+    readonly methodIdSlots: Map<string, string>;
     /** Type-directed walker functions (JSON serializers, the indent
      * rewriter, union ToString/join) — interned per typeKey/unionId, defs
      * flushed with the shape helpers. */
@@ -370,6 +478,15 @@ export declare class LlEmitter {
     readonly callLifetimes: CallLifetimes;
     readonly constantCallbacks: Map<string, Map<string, string>>;
     currentConstantCallbacks: ReadonlyMap<string, string>;
+    /** The current function's running maximum and minimum updates, whose
+     * branches are weighted as rarely taken (running-extrema.ts). */
+    runningExtrema: ReadonlySet<IrStmt>;
+    /** Callback bindings whose closures an enclosing callback loop version
+     * proved to hold their known function: calls take the direct entry with
+     * no fallback (emitCallbackVersionedLoop). */
+    knownCallbacks: Set<string>;
+    readonly callbackVersioning: Set<IrStmt>;
+    callbackVersionsEnabled: boolean;
     readonly stackCallbacks: StackCallbacks;
     readonly receiverReaders: AmbientReceiverReaders;
     readonly stackCaptures: StackCaptures;
@@ -412,6 +529,9 @@ export declare class LlEmitter {
     /** Module constants that keep one value once initialized
      * (immutability.ts stableGlobals). */
     stableGlobals: ReadonlySet<string>;
+    /** Every function body's nodes in walk order (ir/node-index.ts), for the
+     * constructor's analyses. */
+    readonly nodeIndex: IrNodeIndex;
     private readonly tdzGlobals;
     readonly constantNumericTables: ReadonlyMap<string, ConstantNumericTable>;
     /** Constant-key reads on checked-dynamic objects, each with its own
@@ -451,9 +571,15 @@ export declare class LlEmitter {
     /** Fiberless async functions a stackless coroutine body awaits directly;
      * each gets an inline await entry (emitCoroInlineAwait). */
     readonly inlineAwaitCallees: Set<string>;
+    /** Stackless async functions some coroutine body awaits directly: each
+     * gets a direct spawn entry (emitCoroDirectAwait). */
+    readonly directAwaitCallees: Set<string>;
     /** The async functions whose bodies never suspend and that a direct
      * await may enter in place (selectStacklessAsync). */
     private inlineAwaitable;
+    /** Locals whose array literal emitStmts left for the `await Promise.all`
+     * that reads them (deferredPromiseAllLocal). */
+    private readonly deferredPromiseAllEntries;
     /** The promise a `return` emitted past its finally regions already
      * produced for its adopting await (borrowed from the return's parked
      * slot); that await takes it instead of evaluating its operand. */
@@ -465,7 +591,10 @@ export declare class LlEmitter {
     /** The program calls mock.timers members (moduleUsesMockTimers): timer
      * calls emit scr_test.c's mock-aware entry points. */
     readonly mockTimers: boolean;
-    private schedulesInContextValue;
+    private runtimeFeaturesValue;
+    /** The module's runtime features (moduleRuntimeFeatures), found with one
+     * walk of the module the first time any of them is read. */
+    get runtimeFeatures(): RuntimeFeatures;
     /** Whether timer and tick scheduling goes through the *_als entry
      * points (RuntimeFeatures asyncContext). */
     get schedulesInContext(): boolean;
@@ -483,9 +612,11 @@ export declare class LlEmitter {
     /** Identity-preserving static→dyn capsules for program classes and Web
      * APIs whose values remain directly observable. */
     readonly liveDynRefAdapters: Map<string, LlStreamTypedRefAdapter>;
-    private dynBuiltinStreamUse;
     /** See moduleUsesDynBuiltinStream. */
     get usesDynBuiltinStream(): boolean;
+    /** A checked-dynamic for-await may hold a native stream: the program
+     * links the stream unit (and the dyn-async one the loop needs). */
+    get dynForAwaitStreams(): boolean;
     /** Runtime-arm dispatchers for live union values. */
     readonly liveDynUnionRefAdapters: Map<string, string>;
     readonly dynPromiseAdapters: Map<string, string>;
@@ -607,14 +738,6 @@ export declare class LlEmitter {
      * immortal from construction (classes.ts programLifetimeClass). */
     readonly programLifetime: ReadonlySet<string>;
     numericLocals: Map<string, IrLocal>;
-    /** Local arrays of the current function that no other binding can hold
-     * (ir/array-length-stability.ts). */
-    unaliasedArrays: ReadonlySet<string>;
-    /** Dense array loops (dense-array-loops.ts) run in this function. */
-    denseLoopsEnabled: boolean;
-    denseLoopEntries: ReturnType<typeof findInitializedByteLoopBindings>;
-    /** The fast copy of a dense array loop being emitted. */
-    denseLoop: DenseArrayLoop | null;
     captureIds: Set<string>;
     /** Active induction bindings retain their width independently of size_t. */
     integerLoopBindings: Map<string, {
@@ -626,7 +749,19 @@ export declare class LlEmitter {
             max: number;
         };
     }>;
-    countedLoopsEnabled: boolean;
+    /** Constant number locals whose latest emitted declaration stored an
+     * exact integer beside the double, such as `const j = i * 4` in a
+     * typed-array loop version: an i64 slot and the integer's range. */
+    integerTemps: Map<string, {
+        slot: string;
+        type: "i64";
+        signed: true;
+        range: IntegerRange;
+    }>;
+    /** Integer temps are kept only in optimized synchronous functions: an
+     * async or generator body resumes with its locals in its frame, which
+     * an entry alloca is not part of. */
+    integerTempsEnabled: boolean;
     /** Speculative integer loops (speculative-integers.ts) run in this function. */
     speculativeLoopsEnabled: boolean;
     /** The fast copy of a speculative integer loop being emitted: its
@@ -636,12 +771,35 @@ export declare class LlEmitter {
         resume: Map<IrStmt, string>;
         /** Globals whose double is written back only when the copy is left. */
         deferred: Set<string>;
+        /** The loop site's count of bailing entries in a row (a global), and
+         * whether this entry completed a speculated write (a slot). A proven
+         * integer loop has neither. */
+        bails?: string;
+        ran?: string;
     } | null;
+    /** Speculative loop sites numbered so far in the module. */
+    speculativeLoopSites: number;
     /** The ordinary copy being emitted: resume labels still to place. */
     speculationResume: Map<IrStmt, {
         label: string;
         placed: boolean;
     }> | null;
+    /** Run once at the top of the next loop copy's header
+     * (`enterLoopHeader`): records the ordinary copy's header, or sends the
+     * third copy's header there. */
+    speculationHeader: ((header: string) => void) | null;
+    /** A copy of an int32 kind loop (int32-kind-loops.ts) being emitted: the
+     * int32 arrays with checked stores it reads and writes as int32 arrays
+     * (the fast copy) or as double arrays (an ordinary copy entered only
+     * after they widened), as `function\0local` keys, and where each of the
+     * fast copy's writes resumes in the third copy. */
+    int32Kinds: {
+        int32: Set<string>;
+        wide: Set<string>;
+        resume: Map<IrStmt, string>;
+    } | null;
+    /** The resume label of the fast-copy write being emitted. */
+    int32KindResume: string | null;
     /** The function being emitted, for speculative globals. */
     speculativeFunction: string;
     /** Every function that writes each number global (computed on demand). */
@@ -659,20 +817,17 @@ export declare class LlEmitter {
     int32Elements: ((arr: IrExpr) => boolean) | null;
     /** Sums whose result only feeds 32-bit conversions (wrapping-sums.ts). */
     wrappingSums: Set<IrExpr>;
-    byteWindowsEnabled: boolean;
-    byteWindowEntries: ReturnType<typeof findInitializedByteLoopBindings>;
-    /** Typed-array loop versioning (bytes-loop-versions.ts) for the current
-     * function: off in debug and suspending functions and inside a copy. */
-    bytesLoopVersionsEnabled: boolean;
-    /** Loops being versioned around the statement being emitted: a loop is
-     * never versioned inside its own copies, and versions nest boundedly. */
-    readonly bytesLoopVersioning: Set<IrStmt>;
-    bytesLoopEntries: ReturnType<typeof findInitializedByteLoopBindings> | null;
-    bytesLoopFunction: IrFunction | null;
-    /** Counted loops whose integer-form safety test an enclosing version
-     * guard already passed. */
-    readonly provenCountedGuards: Set<IrStmt>;
+    /** Number locals of the current function that hold exact integers or NaN
+     * (findIntegerOrNaNLocals in wrapping-sums.ts). */
+    integerOrNaNLocals: ReadonlyMap<string, IntegerRange>;
     bytesBounds: ReadonlySet<IrExpr | IrStmt>;
+    /** The charCodeAt reads standing for charAt reads the emitter rewrote
+     * (one-unit tests and switches, charAtUnitRead), with the charAt each
+     * stands for: a loop version's proof for the charAt covers its read. */
+    readonly charAtUnitReads: Map<IrExpr, IrExpr>;
+    /** Worker programs: typed-array accesses whose views an enclosing version
+     * guard proved thread-owned. */
+    bytesOwned: ReadonlySet<IrExpr | IrStmt>;
     integerViews: Map<string, string>;
     /** Module globals the current function owns outright (initializer
      * bindings): their function-local slot, which stands in for the global. */
@@ -748,9 +903,17 @@ export declare class LlEmitter {
     readonly chainSlots: Map<string, LlValue>;
     logArgSlots: number;
     readonly stackTraces: boolean;
+    /** The options this emitter was built with (chunk emitters reuse them). */
+    readonly targetOptions: LlvmTargetOptions;
+    /** Records the module-level effects of emitting a range of functions,
+     * which the emitter that merges the range replays (emit-journal.ts). Null
+     * when this emitter emits the whole module itself. */
+    journal: EmitJournal | null;
+    /** The emitter's hosts forward to `journal` (journal set, or workers). */
+    private readonly journaled;
     /** Stack-trace mode: functions no capture can include (no frame push). */
     readonly unframedFunctions: ReadonlySet<string>;
-    constructor(mod: IrModule, options: LlvmTargetOptions);
+    constructor(mod: IrModule, options: LlvmTargetOptions, journal?: EmitJournal | null);
     /** The borrowed parameters of a hierarchy's vtable slot (empty: owned). */
     virtualSlotBorrowed(rootName: string, slotIndex: number): ReadonlySet<number>;
     /** Optimized emission: no debug-info (dev) posture. */
@@ -808,10 +971,19 @@ export declare class LlEmitter {
      * fiberless, and module evaluation bodies and `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
+     * frame chain, which only stack-observing programs push, as a fresh fiber
+     * would. Other programs run the body with a plain call. The body runs in
+     * its caller's AsyncLocalStorage context either way, as Node runs an async
+     * body up to its first await. The frame also counts the bodies running on
+     * a fiber's stack for the runtime's trap on a fiberless body that
+     * suspends. */
+    get fiberlessFrames(): boolean;
     /** The spawn wrapper of a fiberless async function: runs the body on the
-     * caller's stack between scr_async_inline_enter/leave and settles the
-     * fresh promise from its outcome — the fiber trampoline's epilogue,
-     * without the fiber. */
+     * caller's stack (between scr_async_inline_enter/leave when
+     * fiberlessFrames) and settles a fresh promise from its outcome — the
+     * fiber trampoline's epilogue, without the fiber. */
     emitFiberlessAsyncSpawn(fn: IrFunction, spawnParams: string[]): string[];
     /** Whether `await f(...)` may enter f through its await-call entry. The
      * entry's result is the awaited value of f's own body type; direct calls
@@ -821,10 +993,23 @@ export declare class LlEmitter {
      * place (emitCoroInlineAwait): f never suspends, and its direct call is
      * one an await-call entry could take. */
     inlineAwaitEligible(fnName: string): boolean;
+    /** Whether a stackless coroutine body's `await f(...)` may await f's
+     * fiber record instead of its promise (emitCoroDirectAwait): f is a
+     * stackless async function whose direct call an await-call entry could
+     * take. The await consumes the promise, so nothing else can observe it.
+     * Worker programs keep the promise for their stop checkpoint. */
+    directAwaitEligible(fnName: string): boolean;
+    /** A stackless coroutine body's `await f(...)` of a stackless f, without
+     * f's promise object: f's prefix runs as the spawn of a fiber record that
+     * keeps the promise inside. A body still running wakes this coroutine
+     * when it finishes, where its promise's settlement would wake its one
+     * waiter; a finished one takes the settled await's turn. The result (or
+     * the rejection, re-thrown) comes out of the record, which goes. */
+    emitCoroDirectAwait(call: ExprOf<"call">, type: IrType): LlValue;
     /** The inline await entry of a fiberless async function (`sc_ai_*`): its
-     * body on the caller's stack between scr_async_inline_enter/exit, as in
-     * its spawn wrapper, returning the result and leaving a throw pending for
-     * the awaiting coroutine (emitCoroInlineAwait). */
+     * body on the caller's stack (between scr_async_inline_enter/exit when
+     * fiberlessFrames), as in its spawn wrapper, returning the result and
+     * leaving a throw pending for the awaiting coroutine (emitCoroInlineAwait). */
     emitAsyncInlineAwaitCall(fn: IrFunction): string[];
     /** A stackless coroutine body's `await f(...)` of a fiberless f, the
      * await-call entry's turns without its promise: the body runs in place,
@@ -833,6 +1018,32 @@ export declare class LlEmitter {
      * the spawn wrapper's promise would. An adopting await (`return f(...)`)
      * first takes the adoption's then-job turn either way. */
     emitCoroInlineAwait(call: ExprOf<"call">, adopt: boolean): LlValue;
+    /** The entries of `Promise.all(arg)` that a stackless coroutine body's
+     * await may run in place (emitCoroInlinePromiseAll): `arg` is a non-empty
+     * array literal, or the local whose declaration emitStmts deferred to this
+     * await (deferredPromiseAllEntries), whose every entry is a call to a
+     * never-suspending async function, and the result is an array. Null
+     * otherwise. Consumes a deferred local's entries. */
+    inlinePromiseAllEntries(all: ExprOf<"intrinsic">): ExprOf<"arrayLit"> | null;
+    /** Whether every entry of `entries` is a call an await could run in place
+     * (inlineAwaitEligible) that yields its promise's inner type. */
+    private promiseAllInlineable;
+    /** Whether `stmts[i]` declares a local holding an array literal that only
+     * `stmts[i + 1]` reads, as the operand of `await Promise.all(local)` that
+     * runs first in that statement and may run its entries in place. Nothing
+     * runs between the literal and the await, so the await evaluates the
+     * literal itself (inlinePromiseAllEntries). Debug builds keep the local. */
+    deferredPromiseAllLocal(stmts: readonly IrStmt[], i: number): ExprOf<"arrayLit"> | null;
+    /** A stackless coroutine body's `await Promise.all([f(...), ...])` of
+     * never-suspending calls, with Promise.all's turns and without its
+     * promises: the entries run in place in order and their values fill the
+     * result array. Promise.all queues one reaction job per entry, back to
+     * back, and the last of them settles the result, whose await then takes a
+     * turn: here one turn stands for the entries' jobs and a second for the
+     * await. A throwing entry becomes the rejection the await re-throws from
+     * its turn; the remaining entries still run, and later throws are handled
+     * rejections, as Promise.all's subscriptions make them. */
+    emitCoroInlinePromiseAll(entries: ExprOf<"arrayLit">, type: IrType): LlValue;
     emitAsyncAwaitCall(fn: IrFunction, argPackLines: string[] | null, adopt?: boolean): string[];
     emitAsyncScaffolding(): string[];
     /** Whether `fn`'s body is emitted as an LLVM switched coroutine: every
@@ -858,6 +1069,8 @@ export declare class LlEmitter {
     /** Interned NUL-terminated C-string constant (the scr_jb_puts /
      * stringify-indent currency) — `@`-ref, first-use order. */
     cstr(text: string): string;
+    /** The method-id slot for a constant method name (methodIdSlots). */
+    methodIdSlot(name: string): string;
     needBadTag(): void;
     /** The ScrMapOps descriptor holding these operands (ShapeHost.mapOps). */
     mapOps(operands: readonly string[]): string;
@@ -975,11 +1188,13 @@ export declare class LlEmitter {
      * releases the dummy (NULL for refcounted kinds) harmlessly. A scalar
      * call result of the function's return type may be passed as the unwind's
      * dummy value (see emitUnwind). `poll` marks a worker termination poll
-     * (function entry or loop budget), whose test must stay ordered. */
+     * (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?: {
         name: string;
         type: IrType;
-    }, poll?: boolean): void;
+    }, poll?: boolean, guard?: string): 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
@@ -1068,11 +1283,25 @@ export declare class LlEmitter {
      * 1 on hierarchy members, then the flattened field list. Runtime error
      * classes GEP through %ScrError (their structs live in the runtime; the
      * def's [name, message, %code, %cause] order matches the layout). */
-    classFieldPtr(objName: string, className: string, field: string): {
+    classFieldPtr(objName: string, className: string, field: string, refs?: "pointer" | "compressed"): {
         ptr: string;
         type: IrType;
         inline: boolean;
+        compressed: boolean;
     };
+    /** Whether values of `t` are NULL or a compact class instance: `C`,
+     * `C | undefined` or `C | null` for a compact class `C`. `C | null |
+     * undefined` is not: its null is a sentinel outside the region. */
+    compactRefType(t: IrType, isCompact?: (className: string) => boolean): boolean;
+    /** Whether arrays of `elem` hold 32-bit references (SCR_ELEM_CREF). */
+    compactArrayElem(elem: IrType): boolean;
+    /** Loads the reference a field pointer addresses: a pointer, or the
+     * decoded 32-bit reference of a compressed field (compressedFieldPtrs).
+     * `tagged`: the load carries the field's alias tags. */
+    loadRef(ptr: string, tagged?: boolean): string;
+    /** Stores `value` (a pointer) through a field pointer: as is, or encoded
+     * as the 32-bit reference of a compressed field. */
+    storeRef(ptr: string, value: string): void;
     /** The dynamic class's preorder number (borrowed object; the static class
      * names the struct spelling and where the number is, classPreLines). */
     loadVtPre(objName: string, staticClassName: string): string;
@@ -1126,8 +1355,8 @@ export declare class LlEmitter {
     /** A binding's storage: a module global, a plain local slot, or a boxed
      * local (the slot holds the capture BOX; access goes through it). */
     matchBytesLoopVersion(s: IrStmt & {
-        kind: "for";
-    }, counted: IntegerCountedForLoop | null): ReturnType<typeof matchBytesLoopVersion>;
+        kind: "for" | "while";
+    }, counted: IntegerCountedForLoop | null, paired?: IntegerPairedForLoop | null): ReturnType<typeof matchBytesLoopVersion>;
     /** The alias tag of a whole-slot load of a binding (module globals only). */
     slotAlias(id: string): string;
     binding(id: string): {
@@ -1139,6 +1368,13 @@ export declare class LlEmitter {
     emitDebugLocal(local: IrLocal, slot: string, arg?: number, captured?: boolean): void;
     /** Loads a boxed binding's box pointer out of its slot. */
     loadBox(slot: string): string;
+    /** The function a call through `callee` is known to reach (a literal
+     * closure, or a binding the constant-callback census resolves) and the
+     * entry it calls directly. Async and generator functions stay indirect. */
+    knownCallbackTarget(callee: IrExpr): {
+        known: IrFunction;
+        direct: string;
+    } | undefined;
     /** The payload slot of a capture box (ScrBox.slot, field 5). */
     boxSlot(box: string): string;
     boxGet(box: string, t: IrType): string;
@@ -1218,6 +1454,26 @@ export declare class LlEmitter {
      * parameter, at the top of the body. */
     doubleCopies(fn: IrFunction): string[];
     emitFunction(fn: IrFunction): string;
+    /** What this range emitter (chunkEmitter) hands the merging emitter, as
+     * plain data a worker process can write: its journal and the sets and
+     * flags its functions set. */
+    chunkResult(): ChunkResult;
+    /** Merges a range emitter's result (chunkResult) into this emitter, in
+     * the range's order, and answers the rename of the range's text to this
+     * emitter's numbered helpers. Ranges merge in function order. */
+    mergeChunk(chunk: ChunkResult): (text: string) => string;
+    /** Adds a content-named constant a chunk interned. Its symbol is this
+     * emitter's own: a digest collision retries in first-use order, which a
+     * chunk alone does not know. */
+    private addContentEntry;
+    /** Applies a chunk's table entry (EmitJournal.entry) at its place in the
+     * chunk's order: a key this emitter lacks is added, numbered after its
+     * own entries where the table numbers them, and the chunk's name for it
+     * is renamed to this emitter's. */
+    applyJournalEntry(table: string, key: string, value: unknown, names: Map<string, string>, tags: Map<number, number>): void;
+    /** An emitter for a range of this module's functions: the same facts,
+     * empty module-level tables, and a journal of what the range adds. */
+    chunkEmitter(): LlEmitter;
     /** The double-ABI entry of a function with an i32 entry: every caller
      * that is not a direct call (closures, dispatch, adapters, the runtime)
      * enters here. A pending exception passes through to its caller. */
@@ -1454,9 +1710,15 @@ export declare class LlEmitter {
     private emitPublish;
     /** Branches on "`obj` is published" (rc == SIZE_MAX, or a count of
      * UINT32_MAX in the low half for `count` i32: classes.ts
-     * LlClassMeta.idInRc); leaves the builder in the cold block and answers
-     * the continuation label. */
+     * LlClassMeta.idInRc, or the top bit of a compact header word for
+     * "compact": classes.ts COMPACT_PUBLISHED); leaves the builder in the cold
+     * block and answers the continuation label. */
     private emitPublishedTest;
+    /** Branches on "the array `arr` is frozen" (SCR_ARR_FROZEN in its storage
+     * flags, scr_array.h), or published too when `published`; like
+     * emitPublishedTest, leaves the builder in the cold block and answers the
+     * continuation label. */
+    private emitFrozenArrayTest;
     private publishedNamesSym;
     /** The class-name table the hierarchy field guards index by preorder. */
     publishedClassNamesDefs(): string[];
@@ -1471,7 +1733,7 @@ export declare class LlEmitter {
     emitPublishedFieldGuard(obj: string, className: string | null, field: string): void;
     /** The frozen-array guard (scr_throw_published_array's ops): `index` and
      * `count` are doubles (the written index, the argument count). */
-    emitPublishedArrayGuard(arr: string, arrType: IrType, op: number, index?: string, count?: string): void;
+    emitPublishedArrayGuard(arr: string, arrType: IrType, op: number, index?: string, count?: string, third?: string | null): void;
     /** The published Map/Set guard: "Cannot modify a published Map/Set". */
     emitPublishedCollectionGuard(m: string, t: IrType): void;
     emitSerializationExpr(e: ExprOf<"jsonStringify" | "dynCheck">): LlValue;
@@ -1547,6 +1809,9 @@ export declare class LlEmitter {
     jsIcSite(): string;
     /** A fresh read-site cache for one constant-key dyn read. */
     dynReadIcSite(): string;
+    /** A fresh speculative loop site: the global that counts its bailing
+     * entries in a row. */
+    speculativeLoopSite(): string;
     dynKind(d: string): string;
     raceAdapterFor(from: IrType, to: IrType): string;
     genResultThunkFor(genT: IrType & {
@@ -1586,7 +1851,7 @@ export declare class LlEmitter {
     streamDataAdapter(cbT: IrType & {
         kind: "func";
     }): string;
-    streamDoneFnFor(kind: "w" | "f" | "d" | "t" | "l", doneT: IrType & {
+    streamDoneFnFor(kind: "w" | "f" | "d" | "t" | "l" | "c", doneT: IrType & {
         kind: "func";
     }): string;
     fsRenameThunkFor(cbT: IrType & {
@@ -1601,10 +1866,10 @@ export declare class LlEmitter {
     zlibBytesThunkFor(cbT: IrType & {
         kind: "func";
     }): string;
-    streamCbThunkFor(kind: "r" | "w" | "f" | "d" | "t" | "l" | "e", cbT: IrType): string;
+    streamCbThunkFor(kind: "r" | "w" | "f" | "d" | "t" | "l" | "e" | "c" | "v", cbT: IrType): string;
     resolveThunkFor(inner: IrType): string;
     tagInSet(uName: string, unionId: string, tags: number[]): string;
-    arrPush(arr: string, acc: "f64" | "bool" | "ref", value: string): string;
+    arrPush(arr: string, acc: ArrayAccess, value: string, element: IrType | null): string;
     emitArrayCopyLoop(dst: string, src: string, acc: "f64" | "bool" | "ref"): void;
     emitStrIntrinsic(e: IrExpr & {
         kind: "strIntrinsic";
@@ -1630,7 +1895,7 @@ export declare class LlEmitter {
     emitBytesIndex(receiver: string, index: LlValue, expr?: IrExpr, inBounds?: boolean): string;
     emitBytesData(receiver: string): string;
     emitBytesLength(elem: IrBytesElem, receiver: string, bytes: boolean): LlValue;
-    emitBytesGet(elem: IrBytesElem, receiver: string, index: LlValue, expr?: IrExpr, inBounds?: boolean, invalidNaN?: boolean): LlValue;
+    emitBytesGet(elem: IrBytesElem, receiver: string, index: LlValue, expr?: IrExpr, inBounds?: boolean, invalidNaN?: boolean, owned?: boolean): LlValue;
     emitToUint32(value: string, expr?: IrExpr, uint32?: string): string;
     /** Stores a number into its int32-stored local, when it is one. The
      * value is proven to be in the local's range, so its low 32 bits are the
@@ -1641,7 +1906,7 @@ export declare class LlEmitter {
      * as its incoming double, which is the same number. */
     int32LocalValue(localId: string, bits: string, type: IrType): LlValue;
     storeIntegerView(localId: string, value: LlValue, expr?: IrExpr): void;
-    emitBytesSet(elem: IrBytesElem, receiver: string, index: LlValue, value: LlValue, indexExpr?: IrExpr, expr?: IrExpr, inBounds?: boolean): void;
+    emitBytesSet(elem: IrBytesElem, receiver: string, index: LlValue, value: LlValue, indexExpr?: IrExpr, expr?: IrExpr, inBounds?: boolean, owned?: boolean): void;
     emitBytesIntrinsic(e: IrExpr & {
         kind: "bytesIntrinsic";
     }): LlValue;