@scriptc/compiler 0.3.6 → 0.4.1

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

@@ -1,15 +1,23 @@
+import { JsIcSites } from "../../ir/js-ic.js";
 import { type ArraySearchKind } from "./array-search.js";
-import type { IrBytesElem, IrExpr, IrFfiImport, IrFunction, IrLocal, IrModule, IrRecordShape, IrStmt, IrType, IrUnionDef, SrcLoc } from "../../ir/ir.js";
-import { type SplitSpan } from "./split-loops.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 { matchBytesLoopVersion } from "./bytes-loop-versions.js";
+import type { IntegerCountedForLoop } from "../../ir/integer-loops.js";
+import { type SplitSpan, type StoredSplitSnapshot } from "./split-loops.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";
 import { type Int32Abi } from "./int32-abi.js";
 import { type Int32Local } from "./int32-locals.js";
 import { type IntegerClones } from "./integer-clones.js";
+import { findInitializerBindings } from "../../ir/initializer-bindings.js";
 import { type ConstantNumericTable } from "../../ir/constant-tables.js";
 import { type FfiCallbackAdapter } from "../ffi-callbacks.js";
 import { type CallLifetimes } from "./call-lifetimes.js";
-import { type UnionSources } from "./local-union-storage.js";
+import { type StackObjectField } from "./stack-objects.js";
+import { type LocalUnionStorageProof, type LocalUnionStorage, type UnionSources } from "./local-union-storage.js";
 import { BlockBuilder } from "./blocks.js";
 import { NullableRefFields, type NullableRefField } from "./nullable-fields.js";
 import { InlineUnionFields } from "./inline-unions.js";
@@ -17,20 +25,45 @@ import { OptionalArrayReads, type LocalArrayRead } from "./local-array-reads.js"
 import { CheckedNarrows } from "./checked-narrows.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 { ReferenceEffects } from "./reference-effects.js";
 import { ReferenceWrites, type Writes } from "./reference-writes.js";
+import { LlvmDebugInfo } from "./debug-info.js";
 import { StackCallbacks } from "./stack-callbacks.js";
 import { AmbientReceiverReaders } from "./constant-callbacks.js";
-import { type StringSliceSnapshot } from "./string-slices.js";
+import { type LentStringParameters, type StringSliceSnapshot } from "./string-slices.js";
+import { LazyCaptures } from "./lazy-captures.js";
+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 { LifetimeRegions } from "./regions.js";
 import { LlDyn, type DynHost } from "./dyn.js";
 import { LlWalkers } from "./walkers.js";
 import { NullableUnions } from "./nullable-unions.js";
 import { type InlineRcMode, type MapKeyAccess } from "./shapes.js";
 import type { ExprOf, LibCallExpr, LlStreamTypedRefAdapter, LlValue } from "./expr-context.js";
 export { LlvmUnsupportedError } from "./unsupported.js";
+export interface LlArgPackAndTrampolinePrologue {
+    definitions: string[];
+    pack: string;
+    lifted: boolean;
+    fieldTys: string[];
+    ret: IrType;
+    tr: string[];
+    spawnParams: string[];
+    argPackLines: string[];
+}
+export declare function ffiCallbackDummyLl(callback: IrFfiCallbackParam["callback"]): string;
+export interface LlScopeEntry {
+    slot: string;
+    type: IrType;
+    boxed?: boolean;
+    /** A lazily created box: the slot stays null on paths that build no
+     * environment, which skip the release call. */
+    lazy?: boolean;
+}
 export interface LlvmTargetOptions {
     /** C ABI target; omitted direct emission uses the host ABI. */
     targetTriple?: string;
@@ -62,26 +95,118 @@ export interface LlvmTargetOptions {
      * teardown after `process.exit` to a helper process (`--detached-exit`).
      * Executables only; the runtime's weak default keeps it off. */
     detachedExit?: boolean;
+    /** Translated WebAssembly memories check bounds explicitly instead of
+     * relying on guard pages (wasm-modules.ts wasmBoundsChecks). */
+    wasmBoundsChecks?: boolean;
 }
 export declare function emitLlvmModule(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;
+/** Runtime entry points (and await-call entries) that may park the running
+ * execution context, as they appear in emitted function text. */
+export declare const SUSPENDS: RegExp;
+/** Captured bindings (boxes a body declares or receives) from which a
+ * function compiles without LLVM optimization (see boxSlotCount). */
+export declare const UNOPTIMIZED_BOX_SLOTS = 512;
+/** The capture boxes `fn` holds: its boxed bindings and the bindings its
+ * environment brings in. Each box pointer is a value from its binding (or
+ * function entry) to its last use, and every one of them crosses the calls
+ * in between. With thousands of them in one body, as in a factory whose
+ * returned methods share a large environment, LLVM's inliner, instruction
+ * selection and register allocation grow quadratically and take minutes.
+ * Past UNOPTIMIZED_BOX_SLOTS, which ordinary functions stay far below, the
+ * body is compiled `optnone` (nothing inlines into it and code generation
+ * takes its fast paths) and its box slots are accessed volatile, so no
+ * pass promotes them to values even where a pipeline runs IR passes over
+ * optnone bodies, as the native helper's does. Each use reloads its box
+ * pointer and code generation stays linear. Semantics, boxes and
+ * environments are unchanged; only that body's machine code is slower. */
+export declare function boxSlotCount(fn: IrFunction): number;
+/** Whether any node of `e` names the local (reads, writes, declarations,
+ * captures). */
+/** Typed-array loop versions nest at most this deep (each doubles a body). */
+export declare const MAX_BYTES_LOOP_VERSION_DEPTH = 3;
 export declare class LlEmitter {
     readonly mod: IrModule;
     localArrayReads: Map<string, LocalArrayRead>;
-    private loopArrayBorrows;
-    private scalarStringSlices;
+    loopArrayBorrows: ReadonlySet<IrStmt>;
+    scalarStringSlices: Map<string, {
+        kind: "strIntrinsic";
+        method: import("../../ir/ir.js").IrStrIntrinsicMethod;
+        receiver: IrExpr;
+        args: IrExpr[];
+        type: IrType;
+        loc: SrcLoc;
+    } & {
+        kind: "strIntrinsic";
+    }>;
     readonly stringSlices: Map<string, StringSliceSnapshot>;
-    private localStackUnions;
-    private localStackObjects;
-    private reassignedStackObjects;
+    /** Slices written into stack buffers (findScratchStringSlices). */
+    scratchStringSlices: ReadonlySet<IrExpr>;
+    /** String parameters a caller may lend scratch slices to. */
+    lentStringParameters: LentStringParameters;
+    localStackUnions: Map<string, {
+        kind: "unionWrap";
+        unionId: string;
+        tag: number;
+        value: IrExpr;
+        type: IrType;
+        loc: SrcLoc;
+    } & {
+        kind: "unionWrap";
+    }>;
+    localStackObjects: Map<string, ({
+        kind: "call";
+        callee: string;
+        args: IrExpr[];
+        type: IrType;
+        loc: SrcLoc;
+    } & {
+        kind: "recordLit" | "recordClone" | "new" | "call";
+    }) | ({
+        kind: "new";
+        className: string;
+        args: IrExpr[];
+        type: IrType;
+        loc: SrcLoc;
+    } & {
+        kind: "recordLit" | "recordClone" | "new" | "call";
+    }) | ({
+        kind: "recordLit";
+        fields: {
+            name: string;
+            value: IrExpr;
+            overflow?: true;
+        }[];
+        nullProto?: true;
+        type: IrType;
+        loc: SrcLoc;
+    } & {
+        kind: "recordLit" | "recordClone" | "new" | "call";
+    }) | ({
+        kind: "recordClone";
+        source: IrExpr;
+        overrides: {
+            name: string;
+            value: IrExpr;
+        }[];
+        type: IrType;
+        loc: SrcLoc;
+    } & {
+        kind: "recordLit" | "recordClone" | "new" | "call";
+    })>;
+    reassignedStackObjects: Set<string>;
     /** The binding slot of each reassigned stack-object local. */
-    private stackObjectSlots;
-    private localUnionStorageProofs;
-    private localUnionStorage;
+    stackObjectSlots: Map<string, string>;
+    /** Entry-block pointers to the reference fields of each frame object
+     * slot (stack-objects.ts stackObjectFields). */
+    stackObjectFieldPtrs: Map<string, readonly StackObjectField[]>;
+    localUnionStorageProofs: Map<string, LocalUnionStorageProof>;
+    localUnionStorage: Map<string, LocalUnionStorage>;
     integerArrayBindings: Set<string>;
-    private readonly fieldAliasTags;
-    private readonly fieldPointerTags;
+    readonly fieldAliasTags: Map<string, number>;
+    readonly fieldPointerTags: Map<string, number>;
     /** 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
@@ -91,16 +216,16 @@ 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 `!range` attachment of an array length load: a length is at most
-     * 2^32 - 1 (the runtime's SCR_ARR_MAX_LENGTH), so conversions to double
-     * and back fold. 32-bit targets load the full range anyway. */
-    get arrayLengthRange(): string;
+    /** 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. */
+    provenDenseIndex(arr: IrExpr, index: IrExpr): boolean;
     fieldAliasAttachment(ptr: string): string;
-    private fieldAliasMetadata;
-    private readonly debug;
+    fieldAliasMetadata(): string[];
+    readonly debug: LlvmDebugInfo | null;
     /** Projection-only scalar objects may live in frame storage (stack-objects.ts). */
     readonly stackObjects: boolean;
-    private debugScope;
+    debugScope: string | null;
     readonly sizeType: "i32" | "i64";
     readonly ffiExtendNarrowIntegers: boolean;
     readonly cycleBufOffset: number;
@@ -114,47 +239,60 @@ 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. */
+    private stacklessAsyncAllowed;
+    /** The async functions selectStacklessAsync lowered as coroutines. */
+    readonly stacklessAsync: Set<string>;
     /** Some function in the module is lowered as a coroutine. */
-    private usesCoroutines;
+    usesCoroutines: boolean;
     /** The target lacks a rounding instruction at its baseline CPU (x86-64
      * before SSE4.1), so `llvm.trunc` would lower to a libm call: emit
      * truncation inline through an integer round trip instead. */
     readonly inlineTrunc: boolean;
     /** ELF worker executables give thread-locals the executable TLS models. */
-    private readonly executableTls;
+    readonly executableTls: boolean;
     /** Source loops enclosing the statement being emitted in the current
      * function body. */
-    private loopDepth;
+    loopDepth: number;
     /** Darwin worker executables read the stack guard from a pthread
      * thread-specific-data slot off the thread pointer (scr_runtime.h's
      * SCR_STACK_GUARD_TSD): the architecture names the access sequence. */
     private readonly stackGuardTsd;
-    private readonly emitLibraryIdentity;
-    private readonly runtimeAbiMarker;
-    private readonly detachedExit;
+    readonly emitLibraryIdentity: boolean;
+    readonly runtimeAbiMarker: boolean;
+    readonly detachedExit: boolean;
+    readonly wasmBoundsChecks: boolean;
     /** Interned string literals: UTF-8 text → { symbol, byte length } —
      * first-use order, the runtime ABI’s determinism discipline. */
-    private readonly literals;
+    readonly literals: Map<string, {
+        sym: string;
+        len: number;
+    }>;
     /** Literal equality helpers: literal text → helper symbol (literalEquals). */
-    private readonly literalEqualities;
+    readonly literalEqualities: Map<string, string>;
     /** Interned bigint literals: hex magnitude with sign → { symbol, value }. */
-    private readonly bigintLiterals;
+    readonly bigintLiterals: Map<string, {
+        sym: string;
+        value: bigint;
+    }>;
     /** Symbols of interned constant data, named by content (contentSymbol). */
     private readonly contentSymbols;
     /** Interned unit-armed union instances: "unionId:tag" → symbol — one
      * immortal (rc == SIZE_MAX) static per (union, unit tag).
      * RC entry points and the collector skip immortals. */
-    private readonly unitInstances;
+    readonly unitInstances: Map<string, string>;
     /** unionId → symbol of the union's immortal ABSENT field-slot instance. */
-    private readonly absentInstances;
+    readonly absentInstances: Map<string, string>;
     /** The zeroed box an inline store reads for a NULL union dummy. */
-    private needsUnionNone;
+    needsUnionNone: boolean;
     /** unionId → symbol of a flag set once a checked-dynamic cast caches one
      * of the union's boxes. A cached box is refreshed in place, possibly with
      * a tag that another union numbers apart, so it is never shared. */
-    private readonly retypeGuards;
+    readonly retypeGuards: Map<string, string>;
     /** The nullable-union ABSENT sentinel was referenced (absentInstanceRef). */
-    private needsNullableAbsent;
+    needsNullableAbsent: boolean;
     private readonly immortalValues;
     /** Regex literal templates: "<flags>/<pattern>" → { symbol, interned
      * source/flags literal refs } — one immortal ScrRegex template per distinct
@@ -178,9 +316,12 @@ export declare class LlEmitter {
     }>;
     /** Interned NUL-terminated C-string constants (scr_jb_puts labels, the
      * stringify indent text): UTF-8 text → { symbol, byte length }. */
-    private readonly cstrs;
+    readonly cstrs: Map<string, {
+        sym: string;
+        len: number;
+    }>;
     /** Interned ScrMapOps descriptors (scr_map.h): initializer → symbol. */
-    private readonly mapOpsConsts;
+    readonly mapOpsConsts: 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. */
@@ -191,17 +332,17 @@ export declare class LlEmitter {
     /** Explicit callback boundary for standalone layout and walker stages. */
     readonly shapeHost: DynHost;
     /** External declarations, in first-use order. */
-    private readonly decls;
+    readonly decls: Set<string>;
     /** Declared functions referenced as values: each needs an env-signature
      * wrapper + an interned immortal closure (so `f === f` holds). */
     readonly fnValues: Set<string>;
-    private needsOom;
+    needsOom: boolean;
     needsBadTag: boolean;
     needsBadKey: boolean;
-    private needsRetainBox;
+    needsRetainBox: boolean;
     /** Inline RC fast-path helpers requested by call sites (shapes.ts); null
      * when inline RC is off. */
-    private readonly rcHelpers;
+    readonly rcHelpers: Set<string> | null;
     private readonly rcMode;
     private readonly rcHelpersNoinline;
     readonly fnByName: Map<string, IrFunction>;
@@ -209,11 +350,11 @@ export declare class LlEmitter {
     appendedArrayLiterals: ReadonlySet<IrExpr>;
     /** Emitted LLVM text of every IR function body, by function name: the
      * fiberless-async analysis scans it for suspension entry points. */
-    private readonly fnDefText;
+    readonly fnDefText: Map<string, string>;
     readonly referenceEffects: ReferenceEffects;
     /** Field-sensitive reference writes (null in debug builds). */
     referenceWrites: ReferenceWrites | null;
-    private readonly borrowedReturnKeyCache;
+    readonly borrowedReturnKeyCache: Map<string, string[]>;
     /** The statement list being emitted and the current index, for blocks
      * whose bindings end with the list (emitBlock and function bodies). */
     private stmtCursor;
@@ -231,61 +372,63 @@ export declare class LlEmitter {
     currentConstantCallbacks: ReadonlyMap<string, string>;
     readonly stackCallbacks: StackCallbacks;
     readonly receiverReaders: AmbientReceiverReaders;
-    private readonly stackCaptures;
-    private readonly lazyCaptures;
+    readonly stackCaptures: StackCaptures;
+    readonly lazyCaptures: LazyCaptures;
     /** Unchanged captured parameters of the current function: each maps to
      * the slot caching its box, NULL until the first closure needs it. */
-    private readonly lazyCaptureBoxes;
-    private readonly lazyStackBoxes;
-    private borrowedParameters;
+    readonly lazyCaptureBoxes: Map<string, string>;
+    readonly lazyStackBoxes: Map<string, string>;
+    borrowedParameters: Set<string>;
     /** Captures of the current closure body that its environment holds
      * unchanged for the closure's whole life (LazyCaptures.stableCaptures). */
-    private stableCaptureIds;
+    stableCaptureIds: ReadonlySet<string>;
     /** Parameters proven projection-only: callers may pass stack boxes. */
-    private projectedParameters;
-    private stableCallBindings;
+    projectedParameters: Set<string>;
+    stableCallBindings: ReadonlySet<string>;
     /** Locals and rebound parameters holding borrowed pointers for their
      * whole lifetime (walk-borrows.ts), per function and for the current one. */
-    private readonly walkBorrowsByFunction;
-    private walkBorrows;
+    readonly walkBorrowsByFunction: Map<string, ReadonlySet<string>>;
+    walkBorrows: ReadonlySet<string>;
     /** Functions whose borrowing body returns its result without a reference
      * (analyzeBorrowedReturns), and whether the current body is one. */
     readonly borrowedReturns: Set<string>;
     /** Rebound parameters that keep the borrowed convention with an owner
      * slot (rebound-parameters.ts), per function, and the current owner slots. */
-    private readonly reboundByFunction;
-    private readonly reboundOwnerSlots;
-    private currentBorrowedReturn;
+    readonly reboundByFunction: Map<string, ReadonlySet<string>>;
+    readonly reboundOwnerSlots: Map<string, string>;
+    currentBorrowedReturn: boolean;
     /** Manifest-bound native imports, used by ffiCall emission. */
     readonly ffiByName: Map<string, IrFfiImport>;
     /** C-ABI callback trampolines and (for raw/no-userdata callbacks) their
      * distinct call-scoped TLS closure slots. */
-    private readonly ffiCallbackAdapters;
+    readonly ffiCallbackAdapters: Map<string, FfiCallbackAdapter>;
     /** Module-level constant consulted per ffiCall: with a retained
      * descriptor anywhere in the manifest, every native call is a
      * pending-exception checkpoint (may-throw derives the same fact from
      * the same helper). */
     readonly ffiHasRetainedCallback: boolean;
-    private readonly ffiHasForeignCallback;
+    readonly ffiHasForeignCallback: boolean;
     private readonly globalTypes;
     /** Module constants that keep one value once initialized
      * (immutability.ts stableGlobals). */
-    private stableGlobals;
+    stableGlobals: ReadonlySet<string>;
     private readonly tdzGlobals;
     readonly constantNumericTables: ReadonlyMap<string, ConstantNumericTable>;
     /** Constant-key reads on checked-dynamic objects, each with its own
      * zero-initialized ScrDynReadIc (scr_runtime.h). */
-    private dynReadIcSites;
+    dynReadIcSites: number;
+    /** ThreadSlots blocks by family name (thread-slots.ts). */
+    readonly threadSlotsBlocks: Map<string, string>;
     /** May-throw analysis (computeMayThrow): pending
      * checks are emitted only after calls that can actually raise. */
     readonly mayThrow: Set<string>;
     readonly indirectMayThrow: boolean;
     /** Worker programs: the functions that poll for termination on entry
      * (workerTerminationPolls); null outside worker programs. */
-    private readonly workerEntryPolls;
+    readonly workerEntryPolls: ReadonlySet<string> | null;
     /** Functions that check the native stack guard on entry
      * (stackCheckedFunctions); null where the runtime has no guard. */
-    private readonly stackChecks;
+    readonly stackChecks: ReadonlySet<string> | null;
     /** Static types whose values can be published (@scriptc/threads): their
      * stores carry the frozen-object guard. Null without publish calls. */
     readonly publishedTypes: PublishedTypes | null;
@@ -294,8 +437,8 @@ export declare class LlEmitter {
     private readonly immutableFields;
     /** Constructor function names: their bodies may still write their own
      * `this`'s construction-only fields. */
-    private readonly constructorFunctions;
-    private inConstructor;
+    readonly constructorFunctions: ReadonlySet<string>;
+    inConstructor: boolean;
     /** Method names with at least one may-throw implementation — the
      * virtualCall pending check's key. */
     readonly mayThrowMethods: Set<string>;
@@ -305,6 +448,12 @@ export declare class LlEmitter {
     /** Async functions returned directly at some `return f(...)` site of an
      * async function; each gets an adopting entry (emitAsyncAwaitCall). */
     readonly adoptCallees: Set<string>;
+    /** Fiberless async functions a stackless coroutine body awaits directly;
+     * each gets an inline await entry (emitCoroInlineAwait). */
+    readonly inlineAwaitCallees: Set<string>;
+    /** The async functions whose bodies never suspend and that a direct
+     * await may enter in place (selectStacklessAsync). */
+    private inlineAwaitable;
     /** 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. */
@@ -313,6 +462,13 @@ export declare class LlEmitter {
     /** setTimeout and friends appeared somewhere: main must run the event
      * loop even in programs with no async functions. */
     usesTimers: boolean;
+    /** The program calls mock.timers members (moduleUsesMockTimers): timer
+     * calls emit scr_test.c's mock-aware entry points. */
+    readonly mockTimers: boolean;
+    private schedulesInContextValue;
+    /** Whether timer and tick scheduling goes through the *_als entry
+     * points (RuntimeFeatures asyncContext). */
+    get schedulesInContext(): boolean;
     /** Emitted ref-kind resolve thunks for new Promise, interned per inner
      * typeKey → thunk symbol. */
     readonly resolveThunks: Map<string, string>;
@@ -327,6 +483,9 @@ 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;
     /** Runtime-arm dispatchers for live union values. */
     readonly liveDynUnionRefAdapters: Map<string, string>;
     readonly dynPromiseAdapters: Map<string, string>;
@@ -341,6 +500,12 @@ export declare class LlEmitter {
     readonly recordCloneShapes: Set<string>;
     readonly tracedShapes: Set<string>;
     readonly tracedUnions: Set<string>;
+    /** Inline-cache sites of dynamic-tier functions (js-ic.ts): one
+     * zero-initialized ScrJsIc per site (scr_js.h). */
+    jsIcSiteCount: number;
+    private jsIcSitesMemo;
+    /** The tier of the function being emitted. */
+    currentTier: IrFunction["tier"];
     /** The class graph (buildClassGraph): preorder numbering, hierarchy
      * membership, virtual slot lists. */
     readonly classMeta: Map<string, LlClassMeta>;
@@ -349,28 +514,47 @@ export declare class LlEmitter {
     /** Class objects (classes as first-class values): className → the
      * interned .name literal ref — registered during body emission, the
      * statics and construct thunks assemble around the bodies. */
-    private readonly classObjs;
+    readonly classObjs: Map<string, {
+        nameSym: string;
+    }>;
     private readonly unionFieldReadGroups;
     /** Preorder intervals of the runtime error classes under THIS module's
      * class-forest numbering (main() stamps scr_error_vts with them, exactly
      * like the runtime ABI’s errorVtStampLines). */
-    private readonly errorIntervals;
+    readonly errorIntervals: {
+        kind: number;
+        pre: number;
+        post: number;
+        lib: string;
+    }[];
     /** The runtime emitter vtable's preorder interval, when the program
      * touches node:events (the class def rides the module exactly then) —
      * main() stamps scr_emitter_vt with it (emitterVtStampLines, ported). */
-    private emitterInterval;
+    emitterInterval: {
+        pre: number;
+        post: number;
+    } | null;
     /** The runtime stream vtables' preorder intervals (streamVtStampLines,
      * ported): the defs ride every emitter-touching module (the frontend
      * collects the whole emitter-rooted tree), and scr_stream.c links on
      * the same predicate, so the stamps always have their globals. */
-    private readonly streamIntervals;
+    readonly streamIntervals: {
+        vt: string;
+        pre: number;
+        post: number;
+        lib: string;
+    }[];
     B: BlockBuilder;
     frames: LlValue[][];
-    private scopes;
+    scopes: LlScopeEntry[][];
     /** Scope slots dominate every throw site. Share their exceptional cleanup
      * for identical live bindings and handlers; statement temporaries stay at
      * their own throw sites because their SSA values are path-dependent. */
-    private readonly unwindCleanups;
+    readonly unwindCleanups: Map<string, {
+        label: string;
+        entries: LlScopeEntry[];
+        terminator: string;
+    }>;
     /** Enclosing break/continue targets. `kind` separates loops from
      * switches and labeled blocks: an unlabeled break binds to the innermost
      * NON-BLOCK entry (loop or switch — blocks only enter the stack when
@@ -378,13 +562,30 @@ export declare class LlEmitter {
      * continue binds to the innermost LOOP; a labeled jump binds to the
      * entry whose `labels` contains its label. `contLabel` is null exactly
      * for blocks and switches. */
-    private jumpTargets;
-    private currentLocals;
-    private privateSplitLocals;
+    jumpTargets: {
+        kind: "loop" | "block" | "switch";
+        brkLabel: string;
+        contLabel: string | null;
+        labels?: string[] | undefined;
+        frameDepth: number;
+        scopeDepth: number;
+        finallyDepth: number;
+    }[];
+    currentLocals: Map<string, IrLocal>;
+    privateSplitLocals: Map<string, {
+        kind: "strIntrinsic";
+        method: import("../../ir/ir.js").IrStrIntrinsicMethod;
+        receiver: IrExpr;
+        args: IrExpr[];
+        type: IrType;
+        loc: SrcLoc;
+    } & {
+        kind: "strIntrinsic";
+    }>;
     readonly splitSpans: Map<string, SplitSpan>;
-    private storedSplits;
-    private streamingSplitsEnabled;
-    private readonly initializerBindings;
+    storedSplits: Map<string, StoredSplitSnapshot>;
+    streamingSplitsEnabled: boolean;
+    readonly initializerBindings: ReturnType<typeof findInitializerBindings>;
     /** Whole-program int32 storage and parameter/result facts. */
     readonly int32Slots: Int32Slots;
     /** The program has no runtime store into a checked-dynamic value
@@ -405,8 +606,16 @@ export declare class LlEmitter {
     /** ProgramLifetime hierarchy roots (contract types): their instances are
      * immortal from construction (classes.ts programLifetimeClass). */
     readonly programLifetime: ReadonlySet<string>;
-    private numericLocals;
-    private captureIds;
+    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, {
         slot: string;
@@ -417,33 +626,57 @@ export declare class LlEmitter {
             max: number;
         };
     }>;
-    private countedLoopsEnabled;
+    countedLoopsEnabled: boolean;
     /** Speculative integer loops (speculative-integers.ts) run in this function. */
-    private speculativeLoopsEnabled;
+    speculativeLoopsEnabled: boolean;
     /** The fast copy of a speculative integer loop being emitted: its
      * integer-computed writes and where each resumes in the ordinary copy. */
-    private speculation;
+    speculation: {
+        writes: Set<IrStmt>;
+        resume: Map<IrStmt, string>;
+        /** Globals whose double is written back only when the copy is left. */
+        deferred: Set<string>;
+    } | null;
     /** The ordinary copy being emitted: resume labels still to place. */
-    private speculationResume;
+    speculationResume: Map<IrStmt, {
+        label: string;
+        placed: boolean;
+    }> | null;
     /** The function being emitted, for speculative globals. */
-    private speculativeFunction;
+    speculativeFunction: string;
     /** Every function that writes each number global (computed on demand). */
     private globalWriters;
     /** Whole-program final reference fields (ir/final-fields.ts). */
-    private finalFields;
+    finalFields: FinalFields;
     /** The current function may borrow final fields of borrowable objects:
      * not a constructor (where they change), not async or a generator. */
-    private finalFieldBorrows;
+    finalFieldBorrows: boolean;
     integerRanges: IntegerRanges;
+    /** The current function's bounded for-loop cursors (integer-ranges.ts). */
+    integerLoopRanges: ReadonlyMap<IrStmt, ReadonlyMap<string, IntegerRange>>;
+    /** Number arrays of the current function whose every present element is
+     * an int32 (Int32[] contracts), or null when the module has none. */
+    int32Elements: ((arr: IrExpr) => boolean) | null;
     /** Sums whose result only feeds 32-bit conversions (wrapping-sums.ts). */
     wrappingSums: Set<IrExpr>;
-    private byteWindowsEnabled;
-    private byteWindowEntries;
+    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>;
     bytesBounds: 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. */
-    private privateGlobalSlots;
+    privateGlobalSlots: Map<string, string>;
     /** Number locals of the current function stored only as an i32
      * (int32-locals.ts); their slots are `alloca i32`. */
     int32Locals: Map<string, Int32Local>;
@@ -458,21 +691,31 @@ export declare class LlEmitter {
      * (past its own catch), so the copies emit under the truncated stack.
      * break/continue use the same region snapshots through
      * emitFinallysForJump. */
-    private finallyStack;
+    finallyStack: {
+        frameDepth: number;
+        scopeDepth: number;
+        tryDepth: number;
+        body: IrStmt[];
+    }[];
     /** Enclosing try contexts, innermost last — the compile-time unwind
      * targets: a pending check or `throw` inside a try
      * releases frames/scopes down to the recorded depths and branches to
      * `label` (the catch, or the exception-path finally) instead of
      * returning out of the function. Entering a try emits no code. */
-    private tryStack;
+    tryStack: {
+        label: string;
+        used: boolean;
+        frameDepth: number;
+        scopeDepth: number;
+    }[];
     /** Return type of the function being emitted — the unwind path returns
      * a dummy of this type (never read: callers check the flag first). */
     currentReturnType: IrType;
     /** The current body returns its number result as i32. */
-    private currentInt32Result;
+    currentInt32Result: boolean;
     /** The function's i32 entry returns its scalar union result as tag and
      * payload bits (Int32Abi.union). */
-    private currentUnionResult;
+    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). */
@@ -500,11 +743,13 @@ export declare class LlEmitter {
         nextT: IrType;
     } | null;
     /** The function being emitted is an async generator body. */
-    private currentAsyncGenerator;
+    currentAsyncGenerator: boolean;
     /** Active optional-chain bind slots, by chain id (chainRecv reads). */
     readonly chainSlots: Map<string, LlValue>;
     logArgSlots: number;
-    private readonly stackTraces;
+    readonly stackTraces: boolean;
+    /** Stack-trace mode: functions no capture can include (no frame push). */
+    readonly unframedFunctions: ReadonlySet<string>;
     constructor(mod: IrModule, options: LlvmTargetOptions);
     /** The borrowed parameters of a hierarchy's vtable slot (empty: owned). */
     virtualSlotBorrowed(rootName: string, slotIndex: number): ReadonlySet<number>;
@@ -512,103 +757,89 @@ export declare class LlEmitter {
     get optimizing(): boolean;
     /** The vtable entry for one implementation (VirtualBorrows.entry). */
     virtualEntry(implFn: string): string;
-    private implSlotBorrowed;
+    implSlotBorrowed(implFn: string): ReadonlySet<number>;
     abiOffset(native64: number, wasm32: number): number;
     llType(t: IrType): string;
     ffiCallbackAdapter(binding: string, id: string): FfiCallbackAdapter;
-    /** C-callable scalar callback trampolines. A callback with an explicit
-     * context entry receives the closure at that exact ABI position. A raw
-     * callback loads it from a call-scoped TLS slot installed around the
-     * outer native call. */
-    private emitFfiCallbackDefs;
+    emitFfiCallbackDefs(): {
+        globals: string[];
+        defs: string[];
+    };
     emit(): string;
     emitParts(): string[];
-    private emitModuleParts;
-    /** LIBRARY mode: the profile-declared external definitions — the
-     * export-map wrappers plus init / sink-registration / reset / collect.
-     * Plain `define` (not `define internal`) — the exact linkage distinction
-     * that separates the executable lane's @main from everything else. The
-     * bodies delegate every runtime half to scr_library.c, mirroring the C
-     * emission line for line, so the two lanes are identical by
-     * construction. */
-    private emitLibDefs;
-    /** The shared abort helpers (emitted only when referenced): the OOM
-     * abort of untraced shape allocation and the invalid-union-tag abort —
-     * both print the runtime ABI’s exact message on fd 2 and abort. */
-    private helperDefs;
+    /** The dispose-observer gates the emitted frees and record writers test
+     * (alloc.ts): defined after every helper is emitted, because dynCheck
+     * builders, JSON schemas and weak collection constructors are requested
+     * lazily. */
+    disposeObserverGates(): string[];
+    emitModuleParts(): string[];
+    emitLibDefs(globals: IrGlobal[], globalReleaseLines: (prefix: string) => string[], stamps: string[]): string[];
+    helperDefs(): string[];
     /** The inline RC helpers every call site requested, emitted last so
      * requests from main/library epilogues are included. Slow-path
      * declarations a late request added after the extern block flushed land
      * here too. */
-    private inlineRcTail;
+    inlineRcTail(flushedDecls: ReadonlySet<string>): string[];
     /** Env-signature wrappers + interned immortal closures for declared
      * functions used as values (the runtime ABI’s sc_w_/sc_fc_ pair): every
      * mention of `f` yields the same pointer, so `f === f` holds. */
-    private emitFnValueDefs;
-    /** The argument-pack ABI and trampoline prefix shared by async functions
-     * and generators. Their promise/generator completion and spawn tails stay
-     * with the callers below. */
-    private emitArgPackAndTrampolinePrologue;
+    emitFnValueDefs(): string[];
+    emitArgPackAndTrampolinePrologue(fn: IrFunction): LlArgPackAndTrampolinePrologue;
     /** Settles `promise` from a clean async body result `%r` (moved in). */
-    private asyncFulfillLines;
-    /** Async functions whose calls can skip the fiber (scr_async_inline_*).
-     * A body qualifies only when nothing it runs can park its execution
-     * context: its emitted text, and the text of every module function it
-     * mentions (transitively), contains no suspension entry point. Such a
-     * body always completes before the call returns, which is exactly the
-     * behavior of a fiber that never suspends. Excluded conservatively:
-     * wasm32 (its coroutine lowering owns async bodies), module-evaluation
-     * bodies (their promise caches),
-     * `dyn` results (resolution may adopt a thenable), and every program
-     * that uses node:test subtests — `t.test()` runs a subtest inline and
-     * awaits it on the CURRENT fiber even from synchronous code. Worker
-     * programs keep fibers too: their fiber epilogue owns context
-     * termination (a stopping worker rejects and observes the promise), which
-     * the fiberless wrapper does not reproduce. A missed suspension still
-     * cannot reorder execution undetected: the runtime traps when a context parks while a
-     * fiberless body is on its stack. */
-    private fiberlessAsyncFunctions;
+    asyncFulfillLines(ret: IrType, promise: string): string[];
+    fiberlessAsyncFunctions(): Set<string>;
+    /** The async functions `parks` leaves fiberless (fiberlessAsyncFunctions). */
+    neverParkingAsync(parks: ReadonlySet<string>): Set<string>;
+    parkingFunctions(): Set<string> | null;
+    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. */
+    selectStacklessAsync(fnDefs: string[]): void;
     /** 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. */
-    private emitFiberlessAsyncSpawn;
+    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
      * never carry a lifted environment. */
     awaitCallEligible(fnName: string): boolean;
-    /** The await-call entry of an async function (`sc_aw_*`): one direct
-     * `await f(...)` as a call returning the awaited value, so the call site
-     * needs no promise of its own. A fiberless body runs on the caller's
-     * stack as in its spawn wrapper; a clean result then takes the await's
-     * one microtask turn (scr_await_hop) and is returned without ever
-     * materializing the promise, which nothing else could observe. A throw
-     * builds the rejected promise exactly as the spawn wrapper would and
-     * awaits it, so the rejection reaches the awaiter on the same turn. Other
-     * bodies pack their arguments as the spawn wrapper does and enter
-     * scr_async_spawn_await_*, which parks the caller on the promise as soon
-     * as the body first suspends. The adopting entry (`sc_ad_*`, for
-     * `return f(...)` in an async function) adds the turn of the then job
-     * that adopts the returned promise, before the await proper. */
-    private emitAsyncAwaitCall;
-    /** Per-async-function machinery — async.ts's scaffolding, .ll
-     * flavored: an argument-pack struct type, a fiber trampoline (unpacks,
-     * frees the pack, runs the ordinary compiled body, settles the
-     * promise — fulfilling on clean return, leaving a pending exception
-     * for the runtime to reject with), and a spawn wrapper call sites and
-     * closures enter through (packs the args +1, scr_async_spawn runs the
-     * fiber eagerly to its first suspension and returns the promise). */
-    private emitAsyncScaffolding;
+    /** Whether a stackless coroutine body's `await f(...)` may run f's body in
+     * place (emitCoroInlineAwait): f never suspends, and its direct call is
+     * one an await-call entry could take. */
+    inlineAwaitEligible(fnName: string): boolean;
+    /** 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). */
+    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,
+     * then a clean result takes the await's turn, and a throw becomes the
+     * rejected promise the await takes its turn on and re-throws, exactly as
+     * 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;
+    emitAsyncAwaitCall(fn: IrFunction, argPackLines: string[] | null, adopt?: boolean): string[];
+    emitAsyncScaffolding(): string[];
     /** Whether `fn`'s body is emitted as an LLVM switched coroutine: every
-     * wasm32 async or generator body, and native synchronous generators. */
-    private coroLowered;
-    /** Per-generator-function machinery — the async scaffolding's lazy
-     * sibling (async.ts's emitGenScaffolding): the same argument pack,
-     * a fiber trampoline whose epilogue stores the COMPLETION value (or
-     * consumes the GENRET sentinel, promoting the parked .return value), a
-     * spawn wrapper that only ALLOCATES the suspended fiber, and the
-     * never-started teardown that drops the packed (+1) arguments. */
-    private emitGenScaffolding;
+     * wasm32 async or generator body, native synchronous generators, and the
+     * 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
@@ -666,25 +897,51 @@ export declare class LlEmitter {
     /** Registers a SLOT whose current contents the frame owns (conditional
      * results: optional chains, branch joins that park ownership). */
     ownSlot(slot: string, type: IrType): void;
-    /** Strike a refcounted temp from its frame: ownership is being moved. */
-    moveTemp(v: LlValue): 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;
+    /** Strike frame-owned slots (ownSlot) from their statement frames: their
+     * contents are moving to another owner. */
+    disownSlots(slots: readonly {
+        ptr: string;
+    }[]): void;
+    /** Strike a refcounted temp from its frame. */
+    private disownTemp;
+    /** Ends a temp's frame ownership: its reference moves into heap memory. */
+    toHeap(v: LlValue): void;
+    /** Ends a temp's frame ownership: its reference moves to another frame
+     * owner (a local or parameter slot, a callee's parameter, a return
+     * value, a stack object, another temp). */
+    toFrame(v: LlValue): void;
     /** The retained (+1) read of a refcounted value — type-directed through
      * the `_v` table (immortals skip, exactly the C retain calls). */
-    retainValue(name: string, type: IrType): string;
+    private retainCall;
+    /** A +1 of `name` that heap memory keeps. */
+    retainHeap(name: string, type: IrType): string;
+    /** A +1 of `name` that a frame owns. */
+    retainFrame(name: string, type: IrType): string;
     /** The release call for one owned refcounted value — type-directed like
      * releaseCallC (all runtime releases are NULL-tolerant). */
-    releaseValue(name: string, type: IrType): void;
-    releaseFrame(frame: LlValue[]): void;
-    private releaseScope;
+    private releaseCall;
+    /** Releases a reference that heap memory held. */
+    releaseHeap(name: string, type: IrType): void;
+    /** Releases a reference that a frame owned. */
+    releaseFrame(name: string, type: IrType): void;
+    /** A +1 that the runtime made with the heap retain (a box, generator or
+     * await read) becomes a frame value. Emits nothing; answers `name`. */
+    adoptHeap(name: string, _type: IrType): string;
+    /** Releases a statement frame's temps and owned slots. */
+    releaseTemps(frame: LlValue[]): void;
+    releaseScope(scope: LlScopeEntry[]): void;
     /** THE release-on-jump path (break/continue/return): pending statement
      * frames and entered scopes down to the given depths, innermost first —
      * everything whose normal fall-through releases the jump bypasses.
      * Release every scope crossed by the control-flow edge. */
-    private releaseForJump;
+    releaseForJump(frameDepth: number, scopeDepth: number): void;
     /** Run the finally regions an abrupt loop/block jump crosses, then
      * release to the already-resolved target. This is the return path's
      * completion walk without a parked result value. */
-    private emitFinallysForJump;
+    emitFinallysForJump(finallyDepth: number, frameDepth: number, scopeDepth: number): void;
     /** THE unwind path at a point where an exception is pending: release
      * everything between here and the innermost try handler — or the whole
      * function — and branch to the handler / return a dummy value (never
@@ -694,7 +951,7 @@ export declare class LlEmitter {
      * result of the function's own return type: with nothing to release, the
      * unwind returns it as the dummy, so a call in tail position keeps a single
      * return and stays eligible for tail-call and recursion elimination. */
-    private emitUnwind;
+    emitUnwind(passThrough?: string): void;
     /** Loads the running thread's exact pending word (ELF worker
      * executables, scr_exception.c): bit 0 mirrors the active cell, bit 1
      * requests the context's stop. It lives in the executable's static TLS
@@ -731,20 +988,21 @@ export declare class LlEmitter {
     emitAlwaysPendingUnwind(): void;
     /** A recursive function's entry check: below the running stack's guard,
      * throw Node's RangeError and unwind like any other pending exception. */
-    private emitStackCheck;
+    emitStackCheck(): void;
     /** Whether the emitter follows this call with a pending test (the
      * conditions in expr-calls.ts). */
     private callTestsPending;
-    private workerLoopBudget;
-    /** Emit a loop's condition, body and update through `emitCopy`, twice
-     * when speculative-integers.ts plans a fast integer copy. Both copies
-     * share the loop's setup and exit; the ordinary copy comes first so the
-     * fast copy is only emitted when every resume point exists. */
-    private emitLoopCopies;
-    private writeBackSpeculativeGlobals;
+    workerLoopBudget(loop: Extract<IrStmt, {
+        kind: "while" | "doWhile" | "for" | "forOf";
+    }>): string | null;
+    emitLoopCopies(loop: Extract<IrStmt, {
+        kind: "while" | "doWhile" | "for";
+    }>, allowed: boolean, exit: string, emitCopy: (exit: string) => void): void;
+    /** Store the double of each deferred shadow back to its binding. */
+    writeBackDeferred(deferred: Set<string>): void;
     /** A number local whose only storage is its own double slot, so an i64
      * shadow beside it can stand for it within one loop. */
-    private speculativeLocal;
+    speculativeLocal(id: string): boolean;
     /** A module-level number written only by the file's top-level code that
      * is emitting this loop. Calls may still read it: the fast copy keeps its
      * double current. An init function runs once and is never re-entered, so
@@ -753,20 +1011,17 @@ export declare class LlEmitter {
     /** A module-level number a loop of any function only reads, written by
      * nothing but top-level code: an init function never runs during a loop
      * of another function, so the entry value stays its value. */
-    private speculativeInvariantGlobal;
+    speculativeInvariantGlobal(id: string): boolean;
     /** The functions writing a number global a shadow may stand for, or null
      * when the global is not such a number. */
     private numberGlobalWriters;
-    /** A speculated write in the fast copy: compute the value as a safe
-     * integer, store it to the shadow and its exact double to the local.
-     * Any failed check re-executes the statement in the ordinary copy. */
     private emitSpeculativeWrite;
     /** The amortized cancellation poll, emitted on the loop's back edge (the
      * continue target), after the body. A poll in the header would be a loop
      * exit ahead of the body; LLVM then cannot rotate the loop, so loads that
      * the body repeats on every iteration (a typed array's length, for one)
      * stay in the loop. */
-    private emitWorkerLoopCheck;
+    emitWorkerLoopCheck(slot: string | null): void;
     /** Moves an already-evaluated value into the runtime's exception cell —
      * the `throw` statement's kind dispatch (stmts.ts's), shared with
      * every synthetic thrower. Ownership of a refcounted payload must have
@@ -818,8 +1073,8 @@ export declare class LlEmitter {
         type: IrType;
         inline: boolean;
     };
-    /** `o->vt->pre` — the dynamic class's preorder number (borrowed object;
-     * the static class names which struct spelling carries the vt word). */
+    /** 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;
     /** The class object's static symbol (classes as values), registering it
      * for assembly on first use and interning the .name literal while the
@@ -870,17 +1125,22 @@ export declare class LlEmitter {
     storeInt32Field(ptr: string, value: LlValue, expr: IrExpr): void;
     /** 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>;
+    /** The alias tag of a whole-slot load of a binding (module globals only). */
+    slotAlias(id: string): string;
     binding(id: string): {
         kind: "global" | "local" | "boxed";
         slot: string;
         type: IrType;
         local?: IrLocal;
     };
-    private emitDebugLocal;
+    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 payload slot of a capture box (ScrBox.slot, field 5). */
-    private boxSlot;
+    boxSlot(box: string): string;
     boxGet(box: string, t: IrType): string;
     /** scr_box_set_* — the ref form takes ownership of the passed value. */
     boxSet(box: string, t: IrType, value: string): void;
@@ -892,14 +1152,14 @@ export declare class LlEmitter {
     /** The initializing write of a scalar TDZ box: mint the one-element
      * array cell holding the value and move it into the ARR-kind box
      * (set_ref releases nothing — the slot was the empty sentinel). */
-    private tdzScalarInit;
+    tdzScalarInit(box: string, t: IrType, value: string): void;
     /** The payload a TDZ box holds before its declaration runs, when that is
      * not NULL. A nullable union's value is its arm pointer with NULL as a
      * unit arm (nullable-unions.ts), so a stored `null`/`undefined` would
      * read back as the temporal dead zone; such boxes start at the module's
      * immortal NULLABLE_ABSENT sentinel instead, which no value of the
      * binding can hold and every RC entry point and the collector skip. */
-    private tdzEmptySentinel;
+    tdzEmptySentinel(t: IrType): string | null;
     /** The TDZ-guarded read of a boxed binding: an empty payload slot is
      * the temporal dead zone — throw Node's exact catchable ReferenceError
      * (exprs.ts's varRef guard). Scalars then peek the one-element
@@ -928,6 +1188,18 @@ export declare class LlEmitter {
      * whether the promise waiter list or the ready FIFO owns the continuation;
      * LLVM keeps all live locals in the coroutine frame. */
     emitWasiSuspend(promise: string | null): void;
+    /** Awaits in the current body suspend its coroutine: every wasm32 async
+     * body, and native stackless async bodies (selectStacklessAsync). */
+    get coroAwait(): boolean;
+    /** Suspends the current coroutine body at an await of `promise` (null: a
+     * single microtask hop, as for a non-promise operand). A native body
+     * suspends unless the runtime continues it in place, where a fiber's
+     * hop would continue without switching (scr_coro_await_prepare). */
+    emitCoroAwait(promise: string | null): void;
+    /** The runtime entry extracting an await's result of `kind`. A native
+     * coroutine has already suspended until the promise settled, so its
+     * extraction takes no further turn. */
+    awaitResultFn(kind: "void" | "f64" | "bool" | "str" | "ref"): string;
     /** A native generator's OUT slot (scr_async.c's ScrGen.out, mirrored by
      * %ScrGenHead and %ScrGenSlot { kind, f64, b, payload, release_fn }). */
     genOutSlot(gen: string): string;
@@ -941,16 +1213,15 @@ export declare class LlEmitter {
     /** Suspend after a target-specific runtime helper already queued the
      * continuation (used by module awaits, which skip the hop when settled). */
     emitCoroSuspendPrepared(): void;
-    /** Move a clean async return value into the current fiber's promise. */
-    private emitWasiFulfill;
+    emitWasiFulfill(v: LlValue | null): void;
     /** Number locals declared as a copy of a capture or of a lazily boxed
      * parameter, at the top of the body. */
-    private doubleCopies;
-    private emitFunction;
+    doubleCopies(fn: IrFunction): string[];
+    emitFunction(fn: IrFunction): string;
     /** 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. */
-    private emitInt32AbiWrapper;
+    emitInt32AbiWrapper(fn: IrFunction, symbol: string, abi: Int32Abi): string;
     /** The SCALAR_UNION_RESULT pair of a `%ScrUnion` box of `type`. */
     scalarUnionPair(box: string, type: IrType): string;
     /** A private stack box holding a SCALAR_UNION_RESULT pair of `type`. */
@@ -982,15 +1253,11 @@ export declare class LlEmitter {
     /** With `kept`, the virtual adapter of a borrowing slot instead: the
      * slot's parameters stay borrowed, the body's other borrowed ones are
      * released here. */
-    private emitOwnedCallAdapter;
-    /** A local stable binding keeps its value alive while later arguments
-     * and the callee execute. A proven local union box cannot escape or be
-     * rebound during a call; its independent payload owner keeps it alive.
-     * Other writable bindings need an owned snapshot. */
+    emitOwnedCallAdapter(fn: IrFunction, borrowed: ReadonlySet<number>, kept?: ReadonlySet<number>): string;
     canBorrowCallArgument(value: IrExpr): boolean;
     /** A plain-pointer read of a construction-only field outside any
      * constructor (ImmutableFields). */
-    private immutableRead;
+    immutableRead(e: ExprOf<"fieldGet" | "recordGet">): boolean;
     /** A projection read whose locations nothing writes while a borrowed
      * read of it is in use (ReferenceWrites), given the writes of that
      * extent. The root binding itself must stay alive across it too, which
@@ -1000,12 +1267,16 @@ export declare class LlEmitter {
      * rest of its block (its whole lifetime) writes none of the projection's
      * locations: the source edge then keeps the value alive, and uses that
      * escape still retain their own copies. */
-    private unwrittenAlias;
+    unwrittenAlias(s: IrStmt & {
+        kind: "varDecl";
+    }): boolean;
     /** An optional element read into a projection-only local can borrow the
      * element when the rest of the block writes no array element and none of
      * the locations keeping the array alive (which must itself be read
      * without a frame owner). */
-    private unwrittenLocalArrayRead;
+    unwrittenLocalArrayRead(s: IrStmt & {
+        kind: "varDecl";
+    }, read: LocalArrayRead): boolean;
     /** An optional element read passed to a projection-only parameter can
      * borrow the element when the callee and later arguments (`writes`)
      * write no array element and nothing keeping the array alive. */
@@ -1017,17 +1288,53 @@ export declare class LlEmitter {
      * finally copies, like any pending return value, and the adopting await
      * runs afterwards with no handler in scope: a rejection settles the
      * function's promise instead of reaching its own catch clauses. */
-    private emitAdoptingReturn;
+    emitAdoptingReturn(s: IrStmt & {
+        kind: "return";
+    }, adopted: ExprOf<"awaitExpr">): void;
     /** An async generator completing without a further turn: its request
      * settles as the body returns (scr_async_gen_hop_done). */
-    private emitAsyncGenSettled;
+    emitAsyncGenSettled(): void;
+    /** Owned-binding reads that take over the binding's reference, by read
+     * node (the binding's slot). */
+    readonly lastUseMoves: Map<IrExpr, string>;
+    /** How often each varRef node object occurs in the current function:
+     * lowering may share one node between several reads, and a move keyed by
+     * node identity must fire for exactly one of them. */
+    varRefCounts: Map<IrExpr, number> | null;
+    currentFunctionBody: IrStmt[];
+    private varRefCount;
+    /** Moves need plain slots that nothing else reads behind the binding's
+     * back: no debugger view, no coroutine frame, no borrowed (+0) return. */
+    /** Whether the program reads event-loop utilization (perf.loopStart /
+     * perf.idleTime): main then marks the loop's start before running it. */
+    private loopMetricsRead;
+    readsLoopMetrics(): boolean;
+    private lastUseMovesAllowed;
+    /** An owned local declared at the statement cursor whose last statement
+     * reads it once (lastUseRead): that read moves the reference. */
+    noteLastUseMove(s: IrStmt & {
+        kind: "varDecl";
+    }, b: ReturnType<LlEmitter["binding"]>): void;
+    /** An owned parameter whose last statement in the body reads it once:
+     * that read moves the reference. Walk locals may borrow from an owned
+     * parameter's slot (they need it until the function returns), so bodies
+     * with walks keep their parameters, and locals rebound from the
+     * parameter count as derived from it. */
+    noteParameterMove(fn: IrFunction, localId: string, slot: string): void;
+    /** Emits the move of a noted last read: the slot is cleared, so scope
+     * exits release nothing and the read's owned temp carries the reference. */
+    takeLastUseMove(e: IrExpr, slot: string, type: IrType): boolean;
     /** `return x` of a local whose slot is an owned scope entry of the same
      * type: the return can take over the local's reference. */
-    private movableReturn;
+    movableReturn(value: IrExpr | null): {
+        scope: LlScopeEntry[];
+        entry: LlScopeEntry;
+        index: number;
+    } | null;
     /** A walk host for a body that may write the heap: each walk must read
      * only locations the whole body (with its callees) never writes;
      * rebinding the walk locals themselves releases nothing. */
-    private unwrittenWalkHost;
+    unwrittenWalkHost(fn: IrFunction, host: WalkBorrowHost): WalkBorrowHost;
     /** emitReadReceiver yields a plain pointer for `e` that no statement
      * frame owns, so it can outlive the statement (walk-borrows' walks, from
      * any unboxed plain-pointer binding, plus element reads). */
@@ -1035,52 +1342,26 @@ export declare class LlEmitter {
     /** Every location a borrowed-return callee's walks can read (its body's
      * field, record and element reads, through nested borrowed returns). */
     private borrowedReturnKeys;
-    private emitStmts;
+    emitStmts(stmts: IrStmt[], scoped?: boolean): void;
     /** Emits a block in its own lexical scope (refcounted locals released at
      * end). `setup` runs after the
      * scope opens, before the statements — the catch-binding hook: it may
      * emit prelude lines and register entries the scope owns (released on
      * every exit, jumps and unwinds included). */
-    private emitBlock;
+    emitBlock(stmts: IrStmt[], setup?: (scope: LlScopeEntry[]) => void): void;
     emitStmt(s: IrStmt): void;
     private emitStmtBody;
-    /** try/catch/finally via pending-flag unwinding — stmts.ts's
-     * emitTryCatch, block-flavored. Entering a try emits NO code: the try
-     * context is compile-time state (tryStack) redirecting unwinds inside
-     * the region to a label here. Shape:
-     *
-     *   { try body }           unwinds inside release frames/scopes down to
-     *                          this statement's depths, then br the handler
-     *   br after               (normal completion skips the handler)
-     *   try.c:                 (emitted only when some unwind targets it)
-     *     binding = scr_exc_take()   (or scr_exc_clear() when bindingless)
-     *     { catch body }
-     *   after: { finally body }      normal path
-     *   br try.e
-     *   try.fx:                exception path: the pending exception is
-     *     stash = scr_exc_take()     STASHED across the finally body so the
-     *     { finally body }           body's own pending checks answer for
-     *     scr_rethrow(stash)         themselves; a throw inside REPLACES the
-     *     <unwind>                   stash (it unwinds through the synthetic
-     *   try.e:                       scope entry) — JS's semantics exactly
-     *
-     * Abrupt completions inside tryBody/catchBody ride the finallyStack:
-     * returns inline copies at the return site, while break/continue use the
-     * shared region walk before branching to their resolved target. */
-    private emitTryCatch;
-    /** JS-exact switch: lazily evaluated, arbitrary-expression case tests in
-     * source order, bodies falling through in source order until a break —
-     * Literal-only tests can use native dispatch; other tests keep a chain
-     * of conditional branches. All case bodies
-     * share ONE scope; because dispatch can jump PAST a varDecl into a later
-     * case, refcounted/boxed case-body locals are NULL-reset up front and
-     * the scope-exit releases rely on NULL tolerance. */
-    private emitSwitch;
+    emitTryCatch(s: IrStmt & {
+        kind: "tryCatch";
+    }): void;
+    emitSwitch(s: IrStmt & {
+        kind: "switch";
+    }): void;
     /** Evaluates a condition (IR conds are bool-typed) and releases its
      * temps BEFORE the branch — safe because the result is a scalar i1, and
      * required in loop-condition blocks (their temps must not survive into
      * later blocks across the back edge). */
-    private emitCondition;
+    emitCondition(cond: IrExpr): string;
     /** Evaluates `expr` in its own statement frame inside an already-open
      * branch and moves the result into `slot`: the chosen value's ownership
      * transfers, every other temp the arm allocated releases inside the
@@ -1103,20 +1384,14 @@ export declare class LlEmitter {
      * throwing call itself) because a borrowed use still evaluates them;
      * skipping those would drop the throw. */
     private discardableRead;
-    private emitDiscarded;
+    emitDiscarded(e: IrExpr): void;
     emitControlExpr(e: ExprOf<"dynDestrCheck" | "dynIterN" | "toBool" | "logical" | "ternary" | "optChain" | "chainRecv" | "orDefault" | "nullish">): LlValue;
     emitStringExpr(e: ExprOf<"strConcat" | "strEq" | "strCmp" | "toString" | "strIntrinsic" | "regexLit" | "templateStrings" | "regexIntrinsic">): LlValue;
-    /**
-     * Lower canonical `target = target + suffix` after evaluating the old
-     * left side and suffix in JavaScript order.  The snapshot stays owned by
-     * the statement frame while the destination relinquishes its CURRENT
-     * value, making the snapshot unique unless a real observable alias exists.
-     */
     emitStringSelfConcatAssign(localId: string, left: IrExpr, suffix: IrExpr, retainForYield: boolean): LlValue;
     /** The code of a one-argument `String.fromCharCode(c)` suffix, emitted, so
      * `s += String.fromCharCode(c)` appends the character without building
      * the one-character string; null for any other suffix. */
-    private emitSingleCharCode;
+    emitSingleCharCode(suffix: IrExpr): LlValue | null;
     /**
      * Lower `recv.f = recv.f + suffix` on a plain string field like
      * emitStringSelfConcatAssign does for locals. The field's old value is
@@ -1126,7 +1401,9 @@ export declare class LlEmitter {
      * copying the whole string on every append. Returns false (emitting
      * nothing) for every other store.
      */
-    private emitFieldSelfConcat;
+    emitFieldSelfConcat(s: Extract<IrStmt, {
+        kind: "fieldSet" | "recordSet";
+    }>): boolean;
     /** A snapshot the current statement frames own (+1), or an immortal
      * value: it stays valid after its container releases the same string. */
     private ownsSnapshot;
@@ -1137,13 +1414,15 @@ export declare class LlEmitter {
      * the snapshot, the array lets go of it (emitDenseSlotUnlink) so the
      * concat can append in place, and the result is stored as usual.
      */
-    private emitArraySelfConcat;
+    emitArraySelfConcat(s: Extract<IrStmt, {
+        kind: "arraySet";
+    }>): boolean;
     /** `local = local + suffix` when the suffix cannot read or write the
      * local (an unboxed binding is only reachable through this function's own
      * expressions): reading the binding after the suffix gives the value the
      * left side had, so it moves into a consuming concat, and the result takes
      * its place. Null when the general snapshot path is needed. */
-    private emitMovedSelfConcat;
+    emitMovedSelfConcat(localId: string, left: IrExpr, suffix: IrExpr, retainForYield: boolean): LlValue | null;
     emitContainerExpr(e: ExprOf<"arrayLit" | "arrayNewLen" | "arrayGet" | "arrayHas" | "arrayState" | "arrIntrinsic" | "bytesNew" | "bytesIntrinsic" | "mapNew" | "mapIntrinsic" | "setIntrinsic" | "setNew">): LlValue;
     emitCallExpr(e: ExprOf<"call" | "ffiCall" | "closure" | "callValue" | "selfRef" | "new" | "classRef" | "newValue" | "instanceOfValue" | "promiseVoidWiden" | "upcast" | "downcast" | "instanceOf" | "virtualCall">): LlValue;
     /** A direct async call an enclosing `await` consumes whole: emitted
@@ -1152,6 +1431,8 @@ export declare class LlEmitter {
     emitRecordExpr(e: ExprOf<"fieldGet" | "recordGet" | "recordLit" | "recordClone" | "recordKeyGet" | "recordOvfKeys" | "recordOvfHas" | "recordNullProto" | "recordHas" | "fieldAbsent">): LlValue;
     emitDynamicExpr(e: ExprOf<"dynFrom" | "dynCall" | "dynInvoke" | "dynArrLit" | "dynObjLit" | "unionWrap" | "unionNarrow" | "unionDisc" | "unionKeyGet" | "unionIsTag" | "dynKeyGet" | "dynHasKey" | "dynScalarEq" | "dynTest" | "unionEq" | "unionFuncEq" | "caughtTest" | "caughtCheck" | "caughtNarrow" | "caughtToDyn">): LlValue;
     emitIntrinsicExpr(e: ExprOf<"intrinsic">): LlValue;
+    /** The ScrSlots block of the ThreadSlots family `name`. */
+    threadSlotsBlock(name: string): string;
     /** InternTable's runtime calls (scr_itable.c). Table and entry handles
      * are f64 values carrying pointer bits; entry values are 64-bit slots
      * (double bits, a bool, or a pointer to an immortal value) that the
@@ -1160,26 +1441,30 @@ export declare class LlEmitter {
     private emitInternTableIntrinsic;
     /** Lifetime regions in modules with lifetimeRegions (llvm/regions.ts).
      * Created with the class graph; null elsewhere. */
-    private regions;
+    regions: LifetimeRegions | null;
     /** LifetimeRegion's runtime calls: create answers the region id, enter
      * and leave bracket run(), release condemns. */
     private emitRegionIntrinsic;
-    private publishWalkersCache;
+    publishWalkersCache: PublishWalkers | null;
     /** Per-type publication walkers, created on the first publish. */
-    private get publishWalkers();
+    get publishWalkers(): PublishWalkers;
     /** `publish(value)` (@scriptc/threads): makes the graph immortal and
      * immutable (scr_publish with the static type's walker) and answers the
      * same value. Throws (pending) when a dyn part is unpublishable. */
     private emitPublish;
-    /** Branches on "`obj` is published" (rc == SIZE_MAX); leaves the builder
-     * in the cold block and answers the continuation label. */
+    /** 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. */
     private emitPublishedTest;
     private publishedNamesSym;
     /** The class-name table the hierarchy field guards index by preorder. */
-    private publishedClassNamesDefs;
+    publishedClassNamesDefs(): string[];
     /** The frozen-object guard of a class field store, unless the store
      * provably targets a still-private `this` (PublishedTypes.privateStores). */
-    private emitStoreGuard;
+    emitStoreGuard(obj: string, s: Extract<IrStmt, {
+        kind: "fieldSet";
+    }>): void;
     /** The frozen-object guard of a class field or record field store:
      * Node's "Cannot assign to read only property" TypeError when the target
      * is published. `className` null means a record (`#<Object>`). */
@@ -1191,18 +1476,10 @@ export declare class LlEmitter {
     emitPublishedCollectionGuard(m: string, t: IrType): void;
     emitSerializationExpr(e: ExprOf<"jsonStringify" | "dynCheck">): LlValue;
     emitAsyncExpr(e: ExprOf<"yieldExpr" | "genResume" | "awaitExpr" | "awaitUnionExpr" | "newPromise" | "promiseWithResolvers">): LlValue;
-    /** Read a receiver whose value is consumed immediately by a field or tag
-     * load. No user code may run between this read and its consumer. Locals
-     * and their projections already have an owner; other expressions keep
-     * their ordinary statement-frame ownership. The caller must retain any
-     * reference result before evaluating another expression. */
     emitReadReceiver(e: IrExpr): LlValue;
     /** The frame slot a reassigned stack-object local keeps for its value. */
-    private stackObjectSlot;
-    /** A private stack union source with an independently owned payload. */
+    stackObjectSlot(localId: string, type: IrType): string;
     canStackReceiver(e: IrExpr): boolean;
-    /** True for union sources that emitReadReceiver can produce as a private
-     * stack box with an independently owned payload (no heap union). */
     isStackUnionSource(e: IrExpr): boolean;
     /** A read of a record or class field that stores its scalar union
      * inline. */
@@ -1246,19 +1523,10 @@ export declare class LlEmitter {
     emitExactCapsuleObject(value: IrExpr, type: IrType): LlValue;
     canBorrowReceiver(e: IrExpr): boolean;
     /** A reference held as one plain pointer that emitReadReceiver can read
-     * without owning: class instances, records, arrays, strings and
-     * nullable-pointer unions. Tagged union boxes, closures and dynamic
+     * without owning: class instances, records, arrays, strings, typed arrays
+     * and nullable-pointer unions. Tagged union boxes, closures and dynamic
      * values keep ordinary ownership. */
     plainReference(type: IrType): boolean;
-    /** Functions returning a walk of their borrowed parameters return it
-     * without a reference (+0) from their borrowing body; direct callers
-     * either consume it as a receiver/walk or retain it at once, and the owned
-     * adapter retains before releasing its parameters. Candidates preserve
-     * every heap edge (so the result stays reachable from the arguments),
-     * borrow every reference parameter and return plain pointers. The set
-     * grows to a fixpoint because a call to a borrowed-return function with
-     * walk arguments is itself a walk; walk facts are then recomputed with
-     * the final set, admitting only parameters whose convention borrows. */
     private analyzeBorrowedReturns;
     /** emitReadReceiver produces this node's pointer without acquiring a
      * reference, given operands (and ternary arms) that do the same: plain
@@ -1274,6 +1542,9 @@ export declare class LlEmitter {
     borrowableNullableWrap(e: IrExpr): "unit" | "ref" | null;
     materializeSplitLocal(localId: string): void;
     emitExpr(e: IrExpr): LlValue;
+    /** The helper classification of this module's inline-cache sites. */
+    get jsIcSites(): JsIcSites;
+    jsIcSite(): string;
     /** A fresh read-site cache for one constant-key dyn read. */
     dynReadIcSite(): string;
     dynKind(d: string): string;
@@ -1295,6 +1566,7 @@ export declare class LlEmitter {
     }): string;
     childExitSignalThunkFor(codeParam: IrType, sigParam: IrType): string;
     childDataThunkFor(param: IrType): string;
+    childDataDynThunkFor(chunk: "bytes" | "str"): string;
     emitterFixedAdapter(cbT: IrType & {
         kind: "func";
     }): {
@@ -1303,7 +1575,7 @@ export declare class LlEmitter {
     };
     emitterOnceAdapter(boxerT: IrType & {
         kind: "func";
-    }): {
+    }, fire?: string): {
         fn: string;
         shim: string;
     };
@@ -1369,7 +1641,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;
-    private emitBytesSet;
+    emitBytesSet(elem: IrBytesElem, receiver: string, index: LlValue, value: LlValue, indexExpr?: IrExpr, expr?: IrExpr, inBounds?: boolean): void;
     emitBytesIntrinsic(e: IrExpr & {
         kind: "bytesIntrinsic";
     }): LlValue;
@@ -1379,7 +1651,7 @@ export declare class LlEmitter {
     emitRecordKeyGet(e: IrExpr & {
         kind: "recordKeyGet";
     }): LlValue;
-    keyedRecordReadInto(slot: string, join: string, objName: string, keyName: string, shapeId: string, resultType: IrType, overflowOnly: boolean, loc?: SrcLoc): void;
+    keyedRecordReadInto(slot: string, join: string, objName: string, keyName: string, shapeId: string, resultType: IrType, overflowOnly: boolean, loc?: SrcLoc, missNaN?: boolean): void;
     dynPromiseAdapter(inner: IrType): string;
     streamTypedRefCommitAdapter(t: IrType, snapshot: string): string;
     liveDynRefAdapter(t: IrType): LlStreamTypedRefAdapter;
@@ -1406,3 +1678,6 @@ export declare class LlEmitter {
     emitGenericLibCall(e: LibCallExpr): LlValue;
     emitLibCall(e: LibCallExpr): LlValue;
 }
+/** The adopting await a `return` value resolves through, if any: the value
+ * itself or the operand of its conversion into the declared result. */
+export declare function adoptingAwaitOf(value: IrExpr | null): ExprOf<"awaitExpr"> | null;