@scriptc/compiler 0.3.0 → 0.3.2

package/dist/backend/llvm/emitter.js

@@ -1,6 +1,7 @@
 import { emitLlvmLayouts } from "./layouts.js";
-import { FIRST_EMITTED_CYC_KIND, inlineAllocSupported } from "./alloc.js";
-import { llvmBytes as llBytes } from "../literals.js";
+import { compileRegexMatcher } from "./regex-matchers.js";
+import { CYC_BUF, CYC_HDR, FIRST_EMITTED_CYC_KIND, inlineAllocSupported } from "./alloc.js";
+import { hasLoneSurrogate, llvmBytes as llBytes, wtf8Bytes } from "../literals.js";
 import { InternalCompilerError } from "../../errors.js";
 import { createHash } from "node:crypto";
 import { endsWithJump, matchStringSelfConcat, streamTypedRefEligible, undefinedArmTag, } from "../../ir/analysis.js";
@@ -15,23 +16,28 @@ import { findBytesBounds } from "./bytes-bounds.js";
 import { emitByteWindowGuard, findInitializedByteLoopBindings, matchByteWindow, } from "./byte-windows.js";
 import { canDeferSplitPiece, emitSplitSpanNext, materializeSplitPiece, emitSplitCursor, emitSplitNext, emitSplitScratch, emitSplitSnapshot, findPrivateSplitLocals, loadSplitSnapshot, storeSplitSnapshot, stringSplit, } from "./split-loops.js";
 import { scalarizeNumericRecords } from "../../ir/scalar-records.js";
+import { addRecordResultEntries } from "./record-results.js";
 import { specializeNumericCalls } from "../../ir/numeric-call-specialization.js";
-import { everyExprChild, everyStmtChild, everyStmtList } from "../../ir/traverse.js";
+import { everyExpr, everyExprChild, everyStmtChild, everyStmtList } from "../../ir/traverse.js";
 import { analyzeIntegerRanges, INT32_RANGE } from "../../ir/integer-ranges.js";
 import { unshareNodes } from "../../ir/unshare.js";
 import { analyzeInt32Slots } from "../../ir/int32-slots.js";
 import { analyzeFinalFields, constructorClass } from "../../ir/final-fields.js";
 import { foldConstantGlobals } from "../../ir/constant-globals.js";
 import { findIntegerViews } from "./integer-views.js";
+import { findInt32Abis, INT32_ABI_SUFFIX, SCALAR_UNION_DUMMY, SCALAR_UNION_RESULT, } from "./int32-abi.js";
+import { findInt32Locals } from "./int32-locals.js";
+import { exactInteger, narrowInteger } from "./integer-values.js";
 import { findInitializerBindings, withInitializerBindings } from "../../ir/initializer-bindings.js";
 import { findConstantNumericTables } from "../../ir/constant-tables.js";
 import { allocateFfiCallbackAdapters, hasForeignFfiCallback, hasRetainedFfiCallback, } from "../ffi-callbacks.js";
 import { RUNTIME_ABI_MARKER } from "../runtime-abi.js";
 import { computeMayThrow } from "../may-throw.js";
-import { mangleArgPack, mangleAsyncSpawn, mangleBorrowedFunction, mangleClassObj, mangleClassStruct, mangleFnClosure, mangleFunction, mangleGenDrop, mangleGenSpawn, mangleGlobal, mangleLocal, mangleRecordStruct, mangleTrampoline, mangleWrapper, mangleVtInstance, } from "../mangle.js";
+import { mangleArgPack, mangleAsyncAdoptCall, mangleAsyncAwaitCall, mangleAsyncSpawn, mangleBorrowedFunction, mangleClassObj, mangleClassStruct, mangleFnClosure, mangleFunction, mangleGenDrop, mangleGenSpawn, mangleGlobal, mangleLocal, mangleRecordStruct, mangleTrampoline, mangleWrapper, mangleBorrowingWrapper, mangleVtInstance, } from "../mangle.js";
 import { analyzeCallLifetimes } from "./call-lifetimes.js";
 import { canStackUnion, emitStackUnion, findLocalStackUnions } from "./stack-unions.js";
-import { allocateLocalUnion, findLocalUnionStorage, storeLocalUnion, } from "./local-union-storage.js";
+import { emitStackObject, findLocalStackObjects, findReassignedStackObjects, stackObjectStruct, } from "./stack-objects.js";
+import { allocateLocalUnion, emitScalarOptional, findLocalUnionStorage, isScalarOptionalSource, storeLocalUnion, } from "./local-union-storage.js";
 import { BlockBuilder } from "./blocks.js";
 import { NullableRefFields } from "./nullable-fields.js";
 import { emitLocalArrayRead, emitProjectedArrayRead, emitBorrowedArrayRead, findLocalArrayReads, findCallArrayReads, OptionalArrayReads, } from "./local-array-reads.js";
@@ -47,6 +53,7 @@ import { ReferenceWrites } from "./reference-writes.js";
 import { LlvmDebugInfo } from "./debug-info.js";
 import { StackCallbacks } from "./stack-callbacks.js";
 import { findLoopArrayBorrows } from "./loop-array-borrows.js";
+import { findAppendedArrayLiterals } from "./appended-array-literals.js";
 import { AmbientReceiverReaders, findConstantCallbacks } from "./constant-callbacks.js";
 import { findScalarStringSlices, emitStringSliceSnapshot, } from "./string-slices.js";
 import { LazyCaptures } from "./lazy-captures.js";
@@ -73,7 +80,8 @@ import { emitChildProcessLibCall, emitAsyncContextLibCall, emitProcessLibCall, e
 import { emitStreamLibCall } from "./lib-stream.js";
 import { emitNetworkHttpLibCall } from "./lib-network.js";
 import { emitAssertInspectLibCall, emitIoLibCall, emitGenericLibCall, emitLibCall, } from "./lib-dispatch.js";
-import { buildClassGraph, classMembershipIntervals, emitClassMembershipHelper, classEnvironmentIndex, classFieldIndex, classStructSym, } from "./classes.js";
+import { buildClassGraph, classMembershipIntervals, emitClassMembershipHelper, classEnvironmentIndex, classFieldIndex, classStructSym, programLifetimeClass, } from "./classes.js";
+import { LifetimeRegions, REGION_TYPES } from "./regions.js";
 import { LlDyn } from "./dyn.js";
 import { VirtualBorrows } from "./virtual-borrows.js";
 import { LlvmUnsupportedError } from "./unsupported.js";
@@ -82,9 +90,10 @@ import { isObjectArm, NULLABLE_ABSENT, NULLABLE_NULL, NullableUnions } from "./n
 import { emitNullablePresent, emitUnionPeek, emitUnionTag } from "./union-repr.js";
 import { literalCapWord, literalCapWord32 } from "./string-key-hash.js";
 import { NUMBER_MAP_ENTRY_DECL, STRING_MAP_ENTRY_DECL } from "./map-number-lookup.js";
-import { STRING_READ_HELPERS } from "./string-reads.js";
+import { STRING_READ_HELPERS, stringScanDecl } from "./string-reads.js";
 import { emitConcatInputs, emitMixedConcat, numberPart, stringParts, } from "./string-construction.js";
 import { arrNewCall, boxAccess, boxNewCall, boxReleaseSym, computeTraced, elemAccess, emitInlineRcHelpers, emitNullableRetainWrappers, FN_ATTRS, inlineRcDecls, llFieldType, releaseSym, retainSym, traceArg, typedRefConstructor, vAdapters, } from "./shapes.js";
+import { INLINE_LITERAL_BYTES, literalEqualityDefinition } from "./string-literal-equality.js";
 export { LlvmUnsupportedError } from "./unsupported.js";
 function ffiCallbackDummyLl(callback) {
     switch (callback.returns) {
@@ -117,14 +126,14 @@ export function emitLlvmModule(input, options = {}) {
     const mod = unshareNodes(input);
     // Keep source storage intact for debugger inspection in dev builds.
     return new LlEmitter(options.debugSources === undefined
-        ? scalarizeNumericRecords(specializeNumericCalls(foldConstantGlobals(mod), mangleFunction))
+        ? addRecordResultEntries(scalarizeNumericRecords(specializeNumericCalls(foldConstantGlobals(mod), mangleFunction)))
         : mod, options).emit();
 }
 /** Keep large translation units below the host's single-string limit. */
 export function emitLlvmModuleSource(input, options = {}) {
     const mod = unshareNodes(input);
     const parts = new LlEmitter(options.debugSources === undefined
-        ? scalarizeNumericRecords(specializeNumericCalls(foldConstantGlobals(mod), mangleFunction))
+        ? addRecordResultEntries(scalarizeNumericRecords(specializeNumericCalls(foldConstantGlobals(mod), mangleFunction)))
         : mod, options).emitParts();
     const length = parts.reduce((total, part) => total + part.length, Math.max(0, parts.length - 1));
     if (length <= 256 * 1024 * 1024)
@@ -132,7 +141,7 @@ export function emitLlvmModuleSource(input, options = {}) {
     return parts.flatMap((part, index) => (index === 0 ? [part] : ["\n", part]));
 }
 function llStrBytes(text) {
-    return llBytes(Buffer.from(text, "utf8"));
+    return llBytes(wtf8Bytes(text));
 }
 const NO_BORROWED = new Set();
 /** Whether any node of `e` names the local (reads, writes, declarations,
@@ -176,6 +185,10 @@ export class LlEmitter {
     scalarStringSlices = new Map();
     stringSlices = new Map();
     localStackUnions = new Map();
+    localStackObjects = new Map();
+    reassignedStackObjects = new Set();
+    /** The binding slot of each reassigned stack-object local. */
+    stackObjectSlots = new Map();
     localUnionStorageProofs = new Map();
     localUnionStorage = new Map();
     integerArrayBindings = new Set();
@@ -198,6 +211,18 @@ export class LlEmitter {
         }
         this.fieldPointerTags.set(ptr, tag);
     }
+    /** 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) {
+        if (this.debug !== null)
+            return "";
+        let tag = this.fieldAliasTags.get(category);
+        if (tag === undefined) {
+            tag = 2 + this.fieldAliasTags.size * 2;
+            this.fieldAliasTags.set(category, tag);
+        }
+        return `, !tbaa !${tag}`;
+    }
     fieldAliasAttachment(ptr) {
         const tag = this.fieldPointerTags.get(ptr);
         return tag === undefined ? "" : `, !tbaa !${tag}`;
@@ -212,14 +237,24 @@ export class LlEmitter {
         return lines;
     }
     debug;
+    /** Projection-only scalar objects may live in frame storage (stack-objects.ts). */
+    stackObjects;
     debugScope = null;
     sizeType;
     ffiExtendNarrowIntegers;
-    cycleBufferedOffset;
+    cycleBufOffset;
     /** Emitted ScrCycType descriptors so far (their collector statistics
      * indices; see ShapeHost.nextCycKind). */
     cycKinds = 0;
     wasi;
+    /** Synchronous generator bodies compile to LLVM switched coroutines (a
+     * heap frame resumed by an ordinary call) instead of running on a fiber
+     * stack. Worker programs keep fibers (context shutdown unwinds suspended
+     * generator stacks) and so do debug builds (the debugger reads locals
+     * from the native frame). */
+    stacklessGenerators = false;
+    /** Some function in the module is lowered as a coroutine. */
+    usesCoroutines = false;
     /** 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. */
@@ -239,6 +274,10 @@ export class LlEmitter {
     /** Interned string literals: UTF-8 text → { symbol, byte length } —
      * first-use order, the runtime ABI’s determinism discipline. */
     literals = new Map();
+    /** Literal equality helpers: literal text → helper symbol (literalEquals). */
+    literalEqualities = new Map();
+    /** Interned bigint literals: hex magnitude with sign → { symbol, value }. */
+    bigintLiterals = new Map();
     /** Symbols of interned constant data, named by content (contentSymbol). */
     contentSymbols = new Set();
     /** Interned unit-armed union instances: "unionId:tag" → symbol — one
@@ -247,6 +286,10 @@ export class LlEmitter {
     unitInstances = new Map();
     /** unionId → symbol of the union's immortal ABSENT field-slot instance. */
     absentInstances = new Map();
+    /** 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. */
+    retypeGuards = new Map();
     /** The nullable-union ABSENT sentinel was referenced (absentInstanceRef). */
     needsNullableAbsent = false;
     immortalValues = new Set();
@@ -286,6 +329,8 @@ export class LlEmitter {
      * when inline RC is off. */
     rcHelpers;
     fnByName = new Map();
+    /** Empty literals that construct with inline slots (appended-array-literals.ts). */
+    appendedArrayLiterals = new Set();
     /** Emitted LLVM text of every IR function body, by function name: the
      * fiberless-async analysis scans it for suspension entry points. */
     fnDefText = new Map();
@@ -297,6 +342,8 @@ export class LlEmitter {
      * whose bindings end with the list (emitBlock and function bodies). */
     stmtCursor = null;
     optionalArrayReads;
+    /** Union sources a binding or projection can hold in a stack box. */
+    unionSources;
     checkedNarrows;
     callArrayReads = new Map();
     mapReadLifetimes = { locals: new Map(), arguments: new Map() };
@@ -312,6 +359,9 @@ export class LlEmitter {
     lazyCaptureBoxes = new Map();
     lazyStackBoxes = new Map();
     borrowedParameters = new Set();
+    /** Captures of the current closure body that its environment holds
+     * unchanged for the closure's whole life (LazyCaptures.stableCaptures). */
+    stableCaptureIds = new Set();
     /** Parameters proven projection-only: callers may pass stack boxes. */
     projectedParameters = new Set();
     stableCallBindings = new Set();
@@ -367,6 +417,21 @@ export class LlEmitter {
     /** Method names with at least one may-throw implementation — the
      * virtualCall pending check's key. */
     mayThrowMethods = new Set();
+    /** Async functions awaited directly at some `await f(...)` site; each
+     * gets an await-call entry (emitAsyncAwaitCall). */
+    awaitCallees = new Set();
+    /** Async functions returned directly at some `return f(...)` site of an
+     * async function; each gets an adopting entry (emitAsyncAwaitCall). */
+    adoptCallees = new Set();
+    /** 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. */
+    adoptedOperand = null;
+    takeAdoptedOperand() {
+        const value = this.adoptedOperand;
+        this.adoptedOperand = null;
+        return value;
+    }
     /** setTimeout and friends appeared somewhere: main must run the event
      * loop even in programs with no async functions. */
     usesTimers = false;
@@ -374,6 +439,8 @@ export class LlEmitter {
      * typeKey → thunk symbol. */
     resolveThunks = new Map();
     resolveThunkDefs = [];
+    /** Typed-ref recipe constants by type key (lazy receivers). */
+    typedRefRecipes = new Map();
     /** ReadableStream.from adapters keep typed arrays by reference and box
      * one current element per pull. */
     streamFromArrayAdapters = new Map();
@@ -440,6 +507,8 @@ export class LlEmitter {
     initializerBindings;
     /** Whole-program int32 storage and parameter/result facts. */
     int32Slots;
+    /** Functions whose direct calls use i32 parameters or results. */
+    int32Abis;
     /** Immutable module constants (contract types) whose graphs become
      * immortal once initialized: their reads need no reference counting. */
     immortalGlobals;
@@ -457,10 +526,17 @@ export class LlEmitter {
      * not a constructor (where they change), not async or a generator. */
     finalFieldBorrows = false;
     integerRanges = new Map();
+    /** Sums whose result only feeds 32-bit conversions (wrapping-sums.ts). */
+    wrappingSums = new Set();
     byteWindowsEnabled = true;
     byteWindowEntries = new Map();
     bytesBounds = new Set();
     integerViews = new Map();
+    /** Number locals of the current function stored only as an i32
+     * (int32-locals.ts); their slots are `alloca i32`. */
+    int32Locals = new Map();
+    /** The written values (and `++`/`--` nodes) the int32 proof covers. */
+    int32LocalWrites = new Set();
     /** Enclosing try-with-FINALLY regions, innermost last: a `return`
      * inside one runs every crossed finally (innermost first) before the
      * actual ret — the runtime ABI’s pending-return path, with the finally
@@ -480,13 +556,21 @@ export class LlEmitter {
     /** Return type of the function being emitted — the unwind path returns
      * a dummy of this type (never read: callers check the flag first). */
     currentReturnType = VOID;
-    /** Active only while emitting a wasm32 async body lowered with LLVM's
-     * switched-coroutine intrinsics. */
-    currentWasiCoro = null;
+    /** The current body returns its number result as i32. */
+    currentInt32Result = false;
+    /** The function's i32 entry returns its scalar union result as tag and
+     * payload bits (Int32Abi.union). */
+    currentUnionResult = false;
+    /** Active only while emitting a body lowered with LLVM's
+     * switched-coroutine intrinsics (wasm32 async bodies and generators,
+     * native synchronous generators; see coroLowered). */
+    currentCoro = null;
     /** The generator channels of the function being emitted (null outside
      * generator bodies): yieldExpr emission reads them, and emitTryCatch's
      * catch prologue emits the GENRET sentinel re-unwind exactly here. */
     currentGenerator = null;
+    /** The function being emitted is an async generator body. */
+    currentAsyncGenerator = false;
     /** Active optional-chain bind slots, by chain id (chainRecv reads). */
     chainSlots = new Map();
     logArgSlots = 0;
@@ -505,6 +589,7 @@ export class LlEmitter {
         this.constantNumericTables = findConstantNumericTables(mod);
         this.initializerBindings = findInitializerBindings(mod);
         this.int32Slots = analyzeInt32Slots(mod);
+        this.int32Abis = this.debug === null ? findInt32Abis(mod, this.int32Slots) : new Map();
         this.immortalGlobals = new Set(mod.contracts?.immortalGlobals ?? []);
         this.programLifetime = new Set(mod.contracts?.programLifetime ?? []);
         this.finalFields = analyzeFinalFields(mod);
@@ -512,6 +597,8 @@ export class LlEmitter {
         this.ffiExtendNarrowIntegers =
             options.wasi === true || ffiExtendsNarrowIntegers(options.targetTriple);
         this.wasi = options.wasi === true;
+        this.stacklessGenerators = !this.wasi && mod.workers !== true && this.debug === null;
+        this.stackObjects = this.debug === null;
         // An empty triple targets the host, as for executableTls below: the
         // Node-hosted CLI passes none, the native CLI passes its toolchain's, and
         // both must emit the same module for the same target.
@@ -538,15 +625,14 @@ export class LlEmitter {
         this.runtimeAbiMarker = options.runtimeAbiMarker === true;
         this.detachedExit = options.detachedExit === true;
         this.rcHelpers = options.inlineRc === true ? new Set() : null;
-        // ScrCycHdr.buffered sits 6 bytes behind every object. The wasm32
-        // header pads before its descriptor so its payload remains
-        // double-aligned without changing this ABI offset.
-        this.cycleBufferedOffset = 6;
+        // ScrCycHdr.buf sits 4 bytes behind every object on every target.
+        this.cycleBufOffset = CYC_HDR - CYC_BUF;
         this.ffiCallbackAdapters = allocateFfiCallbackAdapters(mod.ffiImports ?? []);
         this.ffiHasRetainedCallback = hasRetainedFfiCallback(mod.ffiImports ?? []);
         this.ffiHasForeignCallback = hasForeignFfiCallback(mod.ffiImports ?? []);
         for (const fn of mod.functions)
             this.fnByName.set(fn.name, fn);
+        this.appendedArrayLiterals = findAppendedArrayLiterals(mod);
         for (const entry of mod.ffiImports ?? []) {
             this.ffiByName.set(entry.name, entry);
         }
@@ -580,6 +666,13 @@ export class LlEmitter {
         // then yields the (borrowed or owned) element pointer, not a stack box.
         // Arrays of such a union are read the same way.
         this.optionalArrayReads = new OptionalArrayReads(this.fnByName, this.unionsById, (id) => this.nullableUnions.has(id));
+        this.unionSources = {
+            unions: this.boxedUnionsById,
+            receiverUnions: this.unionsById,
+            nullableField: (e) => this.nullableFieldGet(e) !== null,
+            arrayRead: (e) => this.optionalArrayReads.get(e) !== null,
+            scalarCall: (e) => this.scalarResultCall(e),
+        };
         this.checkedNarrows = new CheckedNarrows(this.fnByName);
         this.referenceEffects = new ReferenceEffects(this.fnByName, (call) => this.optionalArrayReads.get(call) !== null, mod.classes ?? []);
         if (this.debug === null)
@@ -625,7 +718,7 @@ export class LlEmitter {
                 walkParameters.set(fn.name, indexes);
             }
         }
-        this.callLifetimes = analyzeCallLifetimes(this.fnByName, (className, field) => this.nullableFields.get(className, field) !== null, walkParameters);
+        this.callLifetimes = analyzeCallLifetimes(this.fnByName, (className, field) => this.nullableFields.get(className, field) !== null, walkParameters, new Set([...this.int32Abis].filter(([, abi]) => abi.union).map(([name]) => name)));
         this.constantCallbacks = findConstantCallbacks(mod, this.callLifetimes);
         this.stackCallbacks = new StackCallbacks(this.fnByName);
         this.receiverReaders = new AmbientReceiverReaders(this.fnByName);
@@ -638,7 +731,7 @@ export class LlEmitter {
         this.tracedUnions = traced.unions;
         this.shapeHost = {
             sizeType: this.sizeType,
-            cycleBufferedOffset: this.cycleBufferedOffset,
+            cycleBufOffset: this.cycleBufOffset,
             tracedShapes: this.tracedShapes,
             tracedUnions: this.tracedUnions,
             nullableUnions: this.nullableUnions,
@@ -663,6 +756,7 @@ export class LlEmitter {
             internLiteral: (text) => this.internLiteral(text),
             cstr: (text) => this.cstr(text),
             unitInstanceRef: (unionId, tag) => this.unitInstanceRef(unionId, tag),
+            retypeGuardRef: (unionId) => this.retypeGuardRef(unionId),
             fieldAbsentTestIn: (B, value, unionId) => this.fieldAbsentTestIn(B, value, unionId),
             absentInstanceRef: (unionId) => this.absentInstanceRef(unionId),
             liveDynRefAdapter: (type) => this.liveDynRefAdapter(type),
@@ -679,6 +773,7 @@ export class LlEmitter {
             pendingTestLines: (dest) => this.pendingTestLines(dest),
             virtualEntry: (implFn) => this.virtualEntry(implFn),
             programLifetime: this.programLifetime,
+            regionAliasTag: (word) => this.memoryAliasAttachment(`region.${word}`),
         };
         this.walkers = new LlWalkers(this.shapeHost);
         this.dyn = new LlDyn(this.shapeHost);
@@ -716,6 +811,17 @@ export class LlEmitter {
         // whole-program preorder numbering for instanceof over runtime and
         // compiled error objects, and the per-hierarchy virtual slot lists.
         this.classMeta = buildClassGraph(mod, this.fnByName);
+        if (mod.lifetimeRegions === true) {
+            this.regions = new LifetimeRegions(this.shapeHost, mod, this.classMeta, (meta) => programLifetimeClass(this.shapeHost, meta), this.nullableFields);
+            const regions = this.regions;
+            // Member names differ from LifetimeRegions' own, which keeps the
+            // record from reading as that class's protocol.
+            this.shapeHost.regions = {
+                rcBody: (fnName, ret, comment) => regions.countBody(fnName, ret, comment),
+                newAlloc: (className, sizeOf) => regions.allocLines(className, sizeOf),
+                classDefinitions: (cls, sizeOf) => regions.classDefs(cls, sizeOf),
+            };
+        }
         for (const [name, rec] of RUNTIME_ERROR_CLASSES) {
             const meta = this.classMeta.get(name);
             if (!meta)
@@ -1348,9 +1454,20 @@ export class LlEmitter {
             ...emitClassMembershipHelper(this.classMeta, this.sizeType),
             ...(this.publishWalkersCache?.defs() ?? []),
             ...this.publishedClassNamesDefs(),
+            ...(this.regions?.moduleDefs() ?? []),
         ];
         if (this.constantNumericTables.size > 0)
             this.declare(`declare double @scr_arr_get_number(ptr, double)`);
+        // Native matchers of the regex literals inside the compiled subset.
+        const regexMatchers = new Map();
+        for (const [key, re] of this.regexInstances) {
+            const code = compileRegexMatcher(`${re.sym}_match`, re.pattern, re.flags, this.sizeType, !this.wasi);
+            if (code === null)
+                continue;
+            regexMatchers.set(key, code);
+            for (const decl of code.decls)
+                this.declare(decl);
+        }
         const out = [
             `; Generated by scriptc (LLVM backend) from ${this.mod.sourceFile}. Do not edit.`,
             ``,
@@ -1364,17 +1481,17 @@ export class LlEmitter {
             `%ScrLogArg = type { i32, i64 }`,
             `%ScrVt = type { ${this.sizeType}, ${this.sizeType}, ptr }`,
             `%ScrUnion = type { ${this.sizeType}, i32, ptr, ptr, ptr, i64 }`,
-            `%ScrClosure = type { ${this.sizeType}, ptr, ${this.sizeType}, ptr, i32, i32, ptr }`,
+            `%ScrClosure = type { ${this.sizeType}, ptr, ${this.sizeType}, ptr, i32, i32, ptr, ptr }`,
             `%ScrFfiTable = type { ptr, ${this.sizeType}, ${this.sizeType}, ptr, i8, ptr, ptr, ${this.sizeType}, ${this.sizeType}, ${this.sizeType}, ptr, ptr }`,
-            `%ScrRegex = type { ${this.sizeType}, ptr, ptr, ptr, double, ptr, ptr }`,
+            `%ScrRegex = type { ${this.sizeType}, ptr, ptr, ptr, double, ptr, ptr, ptr }`,
             // ScrArr mirrors scr_runtime.h field-for-field: { rc, len, cap, elem,
-            // cyc, ops, data, present, ext } (field numbers in SCR_ARR_FIELD),
-            // where ops points at the element type's constant RC descriptor
+            // cyc, spare, filled, ops, data, present, ext } (field numbers in
+            // SCR_ARR_FIELD), where filled bounds the hole-free prefix, ops points at the element type's constant RC descriptor
             // (%ScrArrOps, SCR_ELEM_REF only) and ext at the out-of-line sparse,
             // property and metadata storage (NULL until first used). Live dynamic
             // stream commits swap its dense, presence and out-of-line storage while
             // preserving the target object's identity.
-            `%ScrArr = type { ${this.sizeType}, ${this.sizeType}, ${this.sizeType}, i32, i32, ptr, ptr, ptr, ptr }`,
+            `%ScrArr = type { ${this.sizeType}, ${this.sizeType}, ${this.sizeType}, i8, i8, i16, i32, ptr, ptr, ptr, ptr }`,
             `%ScrArrOps = type { ptr, ptr, ptr }`,
             // The ScrMap prefix { rc, key_kind, val_kind, val_retain, val_release,
             // val_trace, key_retain, key_release, key_trace } — the inline RC
@@ -1465,13 +1582,33 @@ export class LlEmitter {
             // half carries the precomputed Map key hash (SCR_STR_HASH_CACHE).
             // Bit 31 marks all-ASCII literals (SCR_STR_ASCII_BIT) on every target.
             const capWord = this.sizeType === "i64"
-                ? literalCapWord(Buffer.from(text, "utf8"))
-                : literalCapWord32(Buffer.from(text, "utf8"));
+                ? literalCapWord(wtf8Bytes(text))
+                : literalCapWord32(wtf8Bytes(text));
             out.push(`@${lit.sym} = internal global { ${this.sizeType}, ${this.sizeType}, ${this.sizeType}, [${lit.len + 1} x i8] } ` +
                 `{ ${this.sizeType} -1, ${this.sizeType} ${lit.len}, ${this.sizeType} ${capWord}, [${lit.len + 1} x i8] c"${llStrBytes(text)}" }`);
         }
         if (this.literals.size > 0)
             out.push(``);
+        for (const lit of this.bigintLiterals.values()) {
+            // Immortal ScrBigInt: { rc = SIZE_MAX, len, sign, cap, limbs } with
+            // pointer-sized little-endian limbs (scr_bigint.c); zero keeps one
+            // zero limb so limb 0 is always readable.
+            const size = this.sizeType;
+            const limbBits = size === "i64" ? 64n : 32n;
+            const mask = (1n << limbBits) - 1n;
+            const limbs = [];
+            for (let m = lit.value < 0n ? -lit.value : lit.value; m > 0n; m = m >> limbBits) {
+                limbs.push(`${size} ${m & mask}`);
+            }
+            const len = limbs.length;
+            if (len === 0)
+                limbs.push(`${size} 0`);
+            const sign = lit.value < 0n ? -1 : lit.value > 0n ? 1 : 0;
+            out.push(`@${lit.sym} = internal global { ${size}, ${size}, i32, i32, [${limbs.length} x ${size}] } ` +
+                `{ ${size} -1, ${size} ${len}, i32 ${sign}, i32 ${limbs.length}, [${limbs.length} x ${size}] [${limbs.join(", ")}] }`);
+        }
+        if (this.bigintLiterals.size > 0)
+            out.push(``);
         for (const [key, sym] of this.unitInstances) {
             // One immortal instance per unit-armed (union, tag): tag set, payload
             // slot and RC entry points zero — retain/release/collector all skip
@@ -1481,6 +1618,13 @@ export class LlEmitter {
         }
         if (this.unitInstances.size > 0)
             out.push(``);
+        for (const [unionId, sym] of this.retypeGuards) {
+            // Thread-local like module globals: a thread's cast caches hold only
+            // its own boxes. Never written, the flag folds to false.
+            out.push(`@${sym} = internal ${tl}global i8 0 ; ${unionId} boxes in a cast cache`);
+        }
+        if (this.retypeGuards.size > 0)
+            out.push(``);
         for (const [unionId, sym] of this.absentInstances) {
             // One immortal ABSENT field-slot instance per undefined-armed union:
             // the undefined arm's tag with payload 1 (ordinary unit instances
@@ -1508,22 +1652,25 @@ export class LlEmitter {
         }
         for (const [key, re] of this.regexInstances) {
             // One immortal ScrRegex per (pattern, flags) literal, pointing at
-            // the interned source/flags strings. The bc and native-matcher slots
-            // start null (lazy compile, cached by the runtime) — a mutable
-            // global, not constant.
-            out.push(`@${re.sym} = internal ${tl}global %ScrRegex { ${this.sizeType} -1, ptr ${re.src}, ptr ${re.fl}, ptr null, double 0.0, ptr null, ptr null } ; ${key.replace(/\n/g, "\\n")}`);
+            // the interned source/flags strings. The bc and translated-program
+            // slots start null (lazy compile, cached by the runtime) — a mutable
+            // global, not constant. The last slot is the build-time matcher.
+            const matcher = regexMatchers.has(key) ? `@${re.sym}_match` : "null";
+            out.push(`@${re.sym} = internal ${tl}global %ScrRegex { ${this.sizeType} -1, ptr ${re.src}, ptr ${re.fl}, ptr null, double 0.0, ptr null, ptr null, ptr ${matcher} } ; ${key.replace(/\n/g, "\\n")}`);
         }
         if (this.regexInstances.size > 0)
             out.push(``);
+        for (const code of regexMatchers.values())
+            out.push(...code.lines, ``);
         for (const [, inst] of this.templateStringsInstances) {
             // One immortal ScrArr per tagged-template site: a [N x ptr] data
             // global of interned cooked-string literals, and the ScrArr header
-            // over it (rc == SIZE_MAX, len == cap, SCR_ELEM_STR = 2, no REF
-            // entry points). Every dense slot is present; reads retain immortal
-            // strings — a no-op.
+            // over it (rc == SIZE_MAX, len == cap == filled, SCR_ELEM_STR = 2,
+            // no REF entry points). Every dense slot is present; reads retain
+            // immortal strings — a no-op.
             const n = inst.slots.length;
             const present = n === 0 ? "zeroinitializer" : `[ ${inst.slots.map(() => "i8 1").join(", ")} ]`;
-            out.push(`@${inst.sym}_data = internal constant [${n} x ptr] [ ${inst.slots.map((s) => `ptr ${s}`).join(", ")} ]`, `@${inst.sym}_present = internal constant [${n} x i8] ${present}`, `@${inst.sym} = internal global %ScrArr { ${this.sizeType} -1, ${this.sizeType} ${n}, ${this.sizeType} ${n}, i32 2, i32 0, ptr null, ptr @${inst.sym}_data, ptr @${inst.sym}_present, ptr null }`);
+            out.push(`@${inst.sym}_data = internal constant [${n} x ptr] [ ${inst.slots.map((s) => `ptr ${s}`).join(", ")} ]`, `@${inst.sym}_present = internal constant [${n} x i8] ${present}`, `@${inst.sym} = internal global %ScrArr { ${this.sizeType} -1, ${this.sizeType} ${n}, ${this.sizeType} ${n}, i8 2, i8 0, i16 0, i32 ${n}, ptr null, ptr @${inst.sym}_data, ptr @${inst.sym}_present, ptr null }`);
         }
         if (this.templateStringsInstances.size > 0)
             out.push(``);
@@ -1599,6 +1746,12 @@ export class LlEmitter {
         }
         if (this.streamIntervals.length > 0)
             out.push(``);
+        if ([...this.literals.keys(), ...this.cstrs.keys()].some(hasLoneSurrogate)) {
+            // The runtime skips surrogate work until a lone surrogate may exist
+            // (scr_wtf8_any); its own producers note one, and literals do here.
+            out.push(`declare void @scr_wtf8_note()`, ``);
+            stamps.push(`  call void @scr_wtf8_note()`);
+        }
         if (this.errorIntervals.length > 0 && this.tracedShapes.has("object:%Error")) {
             // The cycle fixpoint marked the Error hierarchy (a user subclass
             // holds cycle-capable fields — capability is hierarchy-uniform), so
@@ -1622,7 +1775,7 @@ export class LlEmitter {
                 out.push(line);
             out.push(...this.inlineRcTail(flushedDecls));
             out.push(`attributes #0 = { sanitize_address }`);
-            if (this.wasi)
+            if (this.usesCoroutines)
                 out.push(`attributes #1 = { sanitize_address presplitcoroutine }`);
             if (hasNoInlineRecordClone)
                 out.push(`attributes #2 = { noinline sanitize_address }`);
@@ -1737,7 +1890,7 @@ export class LlEmitter {
         // sanitize_address is inert under the plain pipeline; the sanitized
         // lane's -fsanitize=address link activates instrumentation over the
         // emitted functions too (the runtime TUs get theirs from clang).
-        `attributes #0 = { sanitize_address }`, ...(this.wasi ? [`attributes #1 = { sanitize_address presplitcoroutine }`] : []), ...(hasNoInlineRecordClone ? [`attributes #2 = { noinline sanitize_address }`] : []), ``);
+        `attributes #0 = { sanitize_address }`, ...(this.usesCoroutines ? [`attributes #1 = { sanitize_address presplitcoroutine }`] : []), ...(hasNoInlineRecordClone ? [`attributes #2 = { noinline sanitize_address }`] : []), ``);
         if (this.mod.workers) {
             out.push(`declare void @scr_context_cleanup()`, `declare i32 @scr_worker_argc()`, `declare ptr @scr_worker_argv()`, `define i32 @sc_worker_entry(i32 %root) ${FN_ATTRS} {`, `entry:`, `  %argc = call i32 @scr_worker_argc()`, `  %argv = call ptr @scr_worker_argv()`, `  %result = call i32 @sc_context_entry(i32 %argc, ptr %argv)`, `  ret i32 %result`, `}`, `define i32 @main(i32 %argc, ptr %argv) ${FN_ATTRS} {`, `entry:`, `  %result = call i32 @sc_context_entry(i32 %argc, ptr %argv)`, `  call void @scr_context_cleanup()`, `  ret i32 %result`, `}`);
         }
@@ -2045,14 +2198,25 @@ export class LlEmitter {
         if (this.decls.has(`declare zeroext i1 @scr_str_eq(ptr, ptr)`)) {
             defs.push(`define internal zeroext i1 @sc_str_eq(ptr %a, ptr %b) ${FN_ATTRS} {`, `entry:`, `  %same = icmp eq ptr %a, %b`, `  br i1 %same, label %yes, label %lengths`, `lengths:`, `  %alen.p = getelementptr inbounds %ScrStr, ptr %a, i32 0, i32 1`, `  %blen.p = getelementptr inbounds %ScrStr, ptr %b, i32 0, i32 1`, `  %alen = load ${this.sizeType}, ptr %alen.p`, `  %blen = load ${this.sizeType}, ptr %blen.p`, `  %samelen = icmp eq ${this.sizeType} %alen, %blen`, `  br i1 %samelen, label %bytes, label %no`, `bytes:`, `  %eq = call zeroext i1 @scr_str_eq(ptr %a, ptr %b)`, `  ret i1 %eq`, `yes:`, `  ret i1 true`, `no:`, `  ret i1 false`, `}`, ``);
         }
+        for (const [text, name] of this.literalEqualities) {
+            defs.push(...literalEqualityDefinition(name, wtf8Bytes(text), this.internLiteral(text), this.sizeType, FN_ATTRS), ``);
+        }
         // String length and charCodeAt read proven-ASCII strings inline: bit 31
         // of the capacity word (SCR_STR_ASCII_BIT, the low half's sign bit on
         // little-endian targets) makes UTF-16 units bytes. Unproven strings and
         // anything but an in-range index take the runtime's UTF-16 mapping.
+        // A scan's receiver reads inline too where runtime state is ordinary
+        // global storage (ScrStrScan; SCR_TL makes it thread-local otherwise).
+        const scanInline = this.mod.workers !== true && this.mod.lib?.threadInstances !== true;
+        let scanDeclared = false;
         for (const helper of STRING_READ_HELPERS) {
             if (!this.decls.has(helper.decl))
                 continue;
-            defs.push(...helper.define(this.sizeType, FN_ATTRS), ``);
+            if (scanInline && !scanDeclared) {
+                defs.push(stringScanDecl(this.sizeType), ``);
+                scanDeclared = true;
+            }
+            defs.push(...helper.define(this.sizeType, FN_ATTRS, scanInline), ``);
         }
         // Ordering also decides inline when the first bytes differ: byte order
         // is the plain comparison's order, and the UTF-16 order whenever both
@@ -2128,7 +2292,12 @@ export class LlEmitter {
             // never the inner return type.
             const ret = fn.async === true || fn.generator !== undefined ? "ptr" : this.llType(fn.returnType);
             const call = `call ${ret} @${this.callTarget(name)}(${args})`;
-            out.push(`define internal ${ret} @${mangleWrapper(name)}(ptr %env${params.length ? ", " + params.join(", ") : ""}) ${FN_ATTRS} { ; ${name} as a value`, `entry:`, ret === "void" ? `  ${call}` : `  %r = ${call}`, ret === "void" ? `  ret void` : `  ret ${ret} %r`, `}`, `@${mangleFnClosure(name)} = internal ${this.mod.workers === true || this.mod.lib?.threadInstances === true ? "thread_local " : ""}global %ScrClosure { ${this.sizeType} -1, ptr @${mangleWrapper(name)}, ${this.sizeType} 0, ptr null, i32 ${(fn.generator ? 1 : 0) + (fn.async ? 2 : 0) + (fn.ownsPrototype ? 4 : 0)}, i32 0, ptr null }`, ``);
+            const lending = this.lendsEveryArgument(name);
+            out.push(`define internal ${ret} @${mangleWrapper(name)}(ptr %env${params.length ? ", " + params.join(", ") : ""}) ${FN_ATTRS} { ; ${name} as a value`, `entry:`, ret === "void" ? `  ${call}` : `  %r = ${call}`, ret === "void" ? `  ret void` : `  ret ${ret} %r`, `}`, `@${mangleFnClosure(name)} = internal ${this.mod.workers === true || this.mod.lib?.threadInstances === true ? "thread_local " : ""}global %ScrClosure { ${this.sizeType} -1, ptr @${mangleWrapper(name)}, ${this.sizeType} 0, ptr null, i32 ${(fn.generator ? 1 : 0) + (fn.async ? 2 : 0) + (fn.ownsPrototype ? 4 : 0)}, i32 0, ptr null, ptr ${lending ? `@${mangleBorrowingWrapper(name)}` : "null"} }`, ``);
+            if (lending)
+                out.push(`define internal ${ret} @${mangleBorrowingWrapper(name)}(ptr %env${params.length ? ", " + params.join(", ") : ""}) ${FN_ATTRS} { ; ${name} as a value, lending its arguments`, `entry:`, ret === "void"
+                    ? `  call void @${mangleBorrowedFunction(name)}(${args})`
+                    : `  %r = call ${ret} @${mangleBorrowedFunction(name)}(${args})`, ret === "void" ? `  ret void` : `  ret ${ret} %r`, `}`, ``);
         }
         return out;
     }
@@ -2141,8 +2310,14 @@ export class LlEmitter {
         const fieldTys = [...(lifted ? ["ptr"] : []), ...fn.params.map((p) => this.llType(p.type))];
         const definitions = [`%${pack} = type { ${fieldTys.join(", ") || "i8"} } ; ${fn.name} args`];
         const sizeOf = `ptrtoint (ptr getelementptr (%${pack}, ptr null, i32 1) to ${this.sizeType})`;
-        this.declare(`declare void @free(ptr)`);
-        this.declare(`declare ptr @malloc(${this.sizeType})`);
+        // Async argument packs live from the spawn to the trampoline's first
+        // instructions, so they take the runtime's small-block allocator.
+        // Generator packs keep malloc: the runtime frees never-started ones.
+        const smallPack = fn.generator === undefined;
+        const packAlloc = smallPack ? "scr_rt_calloc" : "malloc";
+        const packFree = smallPack ? "scr_rt_free" : "free";
+        this.declare(`declare void @${packFree}(ptr)`);
+        this.declare(`declare ptr @${packAlloc}(${this.sizeType})`);
         const tr = [
             `define internal void @${mangleTrampoline(fn.name)}(ptr %self, ptr %ap) ${FN_ATTRS} {`,
             `entry:`,
@@ -2152,17 +2327,17 @@ export class LlEmitter {
             tr.push(`  %fp${i} = getelementptr inbounds %${pack}, ptr %ap, i64 0, i32 ${i}`, `  %a${i} = load ${ty}, ptr %fp${i}`);
             loads.push(`${ty} %a${i}`);
         });
-        tr.push(`  call void @free(ptr %ap)`);
+        tr.push(`  call void @${packFree}(ptr %ap)`);
         const ret = fn.returnType;
         const retTy = this.llType(ret);
         const bodyCall = `call ${retTy} @${mangleFunction(fn.name)}(${loads.join(", ")})`;
         tr.push(retTy === "void" ? `  ${bodyCall}` : `  %r = ${bodyCall}`);
-        if (lifted && !this.wasi) {
+        if (lifted && !this.coroLowered(fn)) {
             tr.push(`  call void @scr_closure_release(ptr %a0)`);
         }
         const spawnParams = fieldTys.map((ty, i) => `${ty} %a${i}`);
         const argPackLines = [
-            `  %ap = call ptr @malloc(${this.sizeType} ${sizeOf})`,
+            `  %ap = call ptr @${packAlloc}(${this.sizeType} ${sizeOf})`,
             `  %isnull = icmp eq ptr %ap, null`,
             `  br i1 %isnull, label %oom, label %ok`,
             `oom:`,
@@ -2229,7 +2404,7 @@ export class LlEmitter {
         const eligible = new Set();
         if (this.wasi || this.mod.workers === true)
             return eligible;
-        const suspends = /@scr_(?:await_|module_await\b|promise_await_settled\b|test_sub\b|gen_yield_|async_gen_|fiber_)/;
+        const suspends = /@(?:scr_(?:await_|module_await\b|promise_await_settled\b|test_sub\b|gen_yield_|async_gen_|fiber_)|sc_a[wd]_)/;
         for (const decl of this.decls)
             if (/@scr_test_sub\b/.test(decl))
                 return eligible;
@@ -2325,6 +2500,133 @@ export class LlEmitter {
         out.push(`  call void @scr_promise_reject_pending(ptr %p)`, `  ret ptr %p`, `}`, ``);
         return out;
     }
+    /** 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) {
+        if (this.wasi || this.mod.workers === true)
+            return false;
+        const fn = this.fnByName.get(fnName);
+        if (fn === undefined || fn.async !== true || fn.generator !== undefined)
+            return false;
+        if (fn.captures !== undefined || fn.returnType.kind === "dyn")
+            return false;
+        return fn.asyncCacheGlobal === undefined && fn.asyncCycleCacheGlobal === undefined;
+    }
+    /** 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. */
+    emitAsyncAwaitCall(fn, argPackLines, adopt = false) {
+        const ret = fn.returnType;
+        const retTy = this.llType(ret);
+        const params = fn.params.map((p, i) => `${this.llType(p.type)} %a${i}`);
+        const awaitLine = (dest, promise) => {
+            switch (ret.kind) {
+                case "void":
+                    this.declare(`declare void @scr_await_void(ptr)`);
+                    return `  call void @scr_await_void(ptr ${promise})`;
+                case "f64":
+                case "date":
+                    this.declare(`declare double @scr_await_f64(ptr)`);
+                    return `  ${dest} = call double @scr_await_f64(ptr ${promise})`;
+                case "bool":
+                    this.declare(`declare zeroext i1 @scr_await_bool(ptr)`);
+                    return `  ${dest} = call zeroext i1 @scr_await_bool(ptr ${promise})`;
+                case "string":
+                    this.declare(`declare ptr @scr_await_str(ptr)`);
+                    return `  ${dest} = call ptr @scr_await_str(ptr ${promise})`;
+                default:
+                    this.declare(`declare ptr @scr_await_ref(ptr)`);
+                    return `  ${dest} = call ptr @scr_await_ref(ptr ${promise})`;
+            }
+        };
+        const retLine = (v) => retTy === "void" ? `  ret void` : `  ret ${retTy} ${v}`;
+        const head = adopt
+            ? `define internal ${retTy} @${mangleAsyncAdoptCall(fn.name)}(${params.join(", ")}) ${FN_ATTRS} { ; adopt ${fn.name}`
+            : `define internal ${retTy} @${mangleAsyncAwaitCall(fn.name)}(${params.join(", ")}) ${FN_ATTRS} { ; await ${fn.name}`;
+        const args = params.join(", ");
+        if (adopt && argPackLines !== null) {
+            // A body that may suspend settles later than the adoption's then job
+            // runs: materialize its promise, take that turn, then await it.
+            this.declare(`declare void @scr_await_hop()`);
+            this.declare(`declare void @scr_promise_release(ptr)`);
+            return [
+                head,
+                `entry:`,
+                `  %p = call ptr @${mangleAsyncSpawn(fn.name)}(${args})`,
+                `  call void @scr_await_hop()`,
+                awaitLine("%v", "%p"),
+                `  call void @scr_promise_release(ptr %p)`,
+                retLine("%v"),
+                `}`,
+                ``,
+            ];
+        }
+        if (argPackLines !== null) {
+            const kind = ret.kind === "void"
+                ? "void"
+                : ret.kind === "f64" || ret.kind === "date"
+                    ? "f64"
+                    : ret.kind === "bool"
+                        ? "bool"
+                        : ret.kind === "string"
+                            ? "str"
+                            : "ref";
+            const cret = kind === "bool" ? "zeroext i1" : retTy;
+            this.declare(`declare ${cret} @scr_async_spawn_await_${kind}(ptr, ptr)`);
+            this.needOom();
+            const call = `call ${cret} @scr_async_spawn_await_${kind}(ptr @${mangleTrampoline(fn.name)}, ptr %ap)`;
+            return [
+                head,
+                `entry:`,
+                ...argPackLines,
+                kind === "void" ? `  ${call}` : `  %v = ${call}`,
+                retLine("%v"),
+                `}`,
+                ``,
+            ];
+        }
+        this.declare(`declare void @scr_async_inline_enter(ptr)`);
+        this.declare(`declare void @scr_async_inline_exit(ptr)`);
+        this.declare(`declare void @scr_await_hop()`);
+        this.declare(`declare ptr @scr_promise_new()`);
+        this.declare(`declare void @scr_promise_reject_pending(ptr)`);
+        this.declare(`declare void @scr_promise_release(ptr)`);
+        const bodyCall = `call ${retTy} @${mangleFunction(fn.name)}(${args})`;
+        const out = [
+            head,
+            `entry:`,
+            `  %frame = alloca { ptr, ptr }`,
+            `  call void @scr_async_inline_enter(ptr %frame)`,
+            retTy === "void" ? `  ${bodyCall}` : `  %r = ${bodyCall}`,
+            ...this.pendingTestLines("%pend"),
+            `  call void @scr_async_inline_exit(ptr %frame)`,
+            // Adopting: the then job's turn comes before the settled promise's
+            // own reaction, whichever way the body completed.
+            ...(adopt ? [`  call void @scr_await_hop()`] : []),
+            `  br i1 %pend, label %thrown, label %clean`,
+            `clean:`,
+            `  call void @scr_await_hop()`,
+            retLine("%r"),
+            `thrown:`,
+        ];
+        if (ret.kind !== "void" && isRefCounted(ret)) {
+            // An escaping throw means %r is the never-read dummy (NULL).
+            out.push(`  call void ${releaseSym(this.shapeHost, ret)}(ptr %r)`);
+        }
+        out.push(`  %p = call ptr @scr_promise_new()`, `  call void @scr_promise_reject_pending(ptr %p)`, awaitLine("%v", "%p"), `  call void @scr_promise_release(ptr %p)`, retLine("%v"), `}`, ``);
+        return out;
+    }
     /** 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
@@ -2343,6 +2645,14 @@ export class LlEmitter {
         for (const fn of this.mod.functions) {
             if (fn.async !== true || fn.generator !== undefined)
                 continue;
+            if (fiberless.has(fn.name) && this.awaitCallees.has(fn.name)) {
+                for (const line of this.emitAsyncAwaitCall(fn, null))
+                    out.push(line);
+            }
+            if (fiberless.has(fn.name) && this.adoptCallees.has(fn.name)) {
+                for (const line of this.emitAsyncAwaitCall(fn, null, true))
+                    out.push(line);
+            }
             if (fiberless.has(fn.name)) {
                 const fieldTys = [
                     ...(fn.captures !== undefined ? ["ptr"] : []),
@@ -2356,6 +2666,14 @@ export class LlEmitter {
             const { definitions, ret, tr, spawnParams, argPackLines } = this.emitArgPackAndTrampolinePrologue(fn);
             for (const line of definitions)
                 out.push(line);
+            if (this.awaitCallees.has(fn.name)) {
+                for (const line of this.emitAsyncAwaitCall(fn, argPackLines))
+                    out.push(line);
+            }
+            if (this.adoptCallees.has(fn.name)) {
+                for (const line of this.emitAsyncAwaitCall(fn, argPackLines, true))
+                    out.push(line);
+            }
             this.declare(`declare ptr @scr_fiber_promise(ptr)`);
             this.declare(`declare ptr @scr_async_spawn(ptr, ptr)`);
             this.needOom();
@@ -2447,6 +2765,13 @@ export class LlEmitter {
             out.push(line);
         return out;
     }
+    /** Whether `fn`'s body is emitted as an LLVM switched coroutine: every
+     * wasm32 async or generator body, and native synchronous generators. */
+    coroLowered(fn) {
+        if (this.wasi)
+            return fn.async === true || fn.generator !== undefined;
+        return this.stacklessGenerators && fn.generator !== undefined && fn.async !== true;
+    }
     /** 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
@@ -2467,14 +2792,15 @@ export class LlEmitter {
             this.declare(`declare void @scr_gen_ret_to_out(ptr)`);
             this.declare(`declare ptr @scr_gen_new(ptr, ptr, ptr)`);
             this.needOom();
-            if (lifted && !this.wasi) {
+            const coroBody = this.coroLowered(fn);
+            if (lifted && !coroBody) {
                 this.declare(`declare void @scr_closure_release(ptr)`);
             }
             // Normal completion stores the (typed) return value; void completes
             // with the NONE slot — JS's undefined done-value. A GENRET unwind
             // consumes the sentinel and promotes the parked .return value; a
             // real exception stays pending (the consumer-side resume moves it).
-            if (this.wasi) {
+            if (coroBody) {
                 tr.push(`  ret void`, `}`, ``);
             }
             else {
@@ -2559,8 +2885,11 @@ export class LlEmitter {
                 `entry:`,
                 ...argPackLines,
             ];
+            const genNew = coroBody && !this.wasi ? "scr_gen_new_stackless" : "scr_gen_new";
+            if (genNew !== "scr_gen_new")
+                this.declare(`declare ptr @${genNew}(ptr, ptr, ptr)`);
             sp.push(settleAsync === null
-                ? `  %gg = call ptr @scr_gen_new(ptr @${mangleTrampoline(fn.name)}, ptr %ap, ptr @${mangleGenDrop(fn.name)})`
+                ? `  %gg = call ptr @${genNew}(ptr @${mangleTrampoline(fn.name)}, ptr %ap, ptr @${mangleGenDrop(fn.name)})`
                 : `  %gg = call ptr @scr_async_gen_new(ptr @${mangleTrampoline(fn.name)}, ptr %ap, ptr @${mangleGenDrop(fn.name)}, ptr @${settleAsync})`, `  ret ptr %gg`, `}`, ``);
             for (const line of sp)
                 out.push(line);
@@ -2598,6 +2927,41 @@ export class LlEmitter {
         this.immortalValues.add(name);
         return name;
     }
+    /** The inline equality test against one string literal (an
+     * `i1 (ptr)` helper LLVM inlines at each site), by literal symbol. */
+    literalEquals(text) {
+        const literal = this.internLiteral(text);
+        const name = `@sc_streq_${literal.slice("@sc_lit_".length)}`;
+        if (!this.literalEqualities.has(text)) {
+            this.literalEqualities.set(text, name);
+            if (Buffer.byteLength(text, "utf8") > INLINE_LITERAL_BYTES) {
+                this.declare(`declare zeroext i1 @scr_str_eq(ptr, ptr)`);
+            }
+        }
+        return name;
+    }
+    /** `@`-ref of an immortal ScrBigInt holding `value`, or null when the
+     * text is not a valid StringToBigInt input (the runtime parse then
+     * throws as usual). BigInt here is the same StringToBigInt as the
+     * program's, so every accepted spelling folds to the value Node gives. */
+    internBigIntLiteral(text) {
+        let value;
+        try {
+            value = BigInt(text);
+        }
+        catch {
+            return null;
+        }
+        const key = value.toString(16);
+        let lit = this.bigintLiterals.get(key);
+        if (!lit) {
+            lit = { sym: this.contentSymbol("sc_bigint_", key), value };
+            this.bigintLiterals.set(key, lit);
+        }
+        const name = `@${lit.sym}`;
+        this.immortalValues.add(name);
+        return name;
+    }
     /** Interned NUL-terminated C-string constant (the scr_jb_puts /
      * stringify-indent currency) — `@`-ref, first-use order. */
     cstr(text) {
@@ -2636,6 +3000,16 @@ export class LlEmitter {
         this.immortalValues.add(name);
         return name;
     }
+    /** The i8 flag that a checked-dynamic cast sets before caching one of
+     * this tagged union's boxes (unionRetype rebuilds once it is set). */
+    retypeGuardRef(unionId) {
+        let sym = this.retypeGuards.get(unionId);
+        if (!sym) {
+            sym = `sc_retype_guard_${this.retypeGuards.size}`;
+            this.retypeGuards.set(unionId, sym);
+        }
+        return `@${sym}`;
+    }
     /** The immortal ABSENT state of an undefined-armed record field slot
      * (IR fieldAbsent). */
     absentInstanceRef(unionId) {
@@ -2880,19 +3254,23 @@ export class LlEmitter {
             target.used = true;
             terminator = `br label %${target.label}`;
         }
-        else if (this.currentWasiCoro !== null) {
-            terminator = `br label %${this.currentWasiCoro.finalLabel}`;
+        else if (this.currentCoro !== null) {
+            terminator = `br label %${this.currentCoro.finalLabel}`;
         }
         else {
             const t = this.llType(this.currentReturnType);
             terminator =
                 t === "void"
                     ? "ret void"
-                    : t === "double"
-                        ? `ret double ${f64Lit(0)}`
-                        : t === "i1"
-                            ? "ret i1 false"
-                            : "ret ptr null";
+                    : this.currentInt32Result
+                        ? "ret i32 0"
+                        : this.currentUnionResult
+                            ? `ret ${SCALAR_UNION_DUMMY}`
+                            : t === "double"
+                                ? `ret double ${f64Lit(0)}`
+                                : t === "i1"
+                                    ? "ret i1 false"
+                                    : "ret ptr null";
         }
         // Copy the entries now: later declarations extend these lexical scopes.
         // Release order and the handler are part of the shared block's identity.
@@ -2905,7 +3283,10 @@ export class LlEmitter {
             }
         }
         if (entries.length === 0) {
-            if (passThrough !== undefined && !target && this.currentWasiCoro === null) {
+            if (passThrough !== undefined &&
+                !target &&
+                this.currentCoro === null &&
+                !this.currentInt32Result) {
                 const t = this.llType(this.currentReturnType);
                 if (t === "double" || t === "i1")
                     terminator = `ret ${t} ${passThrough}`;
@@ -3878,6 +4259,29 @@ export class LlEmitter {
         this.boxSet(box, local.type, borrowed && isRefCounted(local.type) ? this.retainValue(value, local.type) : value);
     }
     // ── functions ───────────────────────────────────────────────────────────
+    /** True when `fnName`'s borrowing body lends every reference parameter
+     * and returns an owned result: a closure over it then carries that body
+     * as its borrowing entry (ScrClosure.fn_borrowed), which callers that
+     * keep their arguments alive across the call may enter instead of `fn`. */
+    lendsEveryArgument(fnName) {
+        const fn = this.fnByName.get(fnName);
+        if (!fn || fn.async || fn.generator || this.borrowedReturns.has(fnName))
+            return false;
+        if (fn.classCaptures !== undefined || this.implSlotBorrowed(fnName).size > 0)
+            return false;
+        const borrowed = this.callLifetimes.borrowed.get(fnName);
+        if (!borrowed)
+            return false;
+        let any = false;
+        for (const [index, param] of fn.params.entries()) {
+            if (!isRefCounted(param.type))
+                continue;
+            if (!borrowed.has(index))
+                return false;
+            any = true;
+        }
+        return any;
+    }
     /** The LLVM symbol a direct call or closure enters a function through:
      * async bodies are entered via their emitted spawn wrapper (which runs
      * the fiber eagerly to its first suspension and returns the promise);
@@ -3895,7 +4299,7 @@ export 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) {
-        const coro = this.currentWasiCoro;
+        const coro = this.currentCoro;
         if (coro === null)
             throw new InternalCompilerError("llvm emitter bug: wasm suspension outside async body");
         if (promise === null) {
@@ -3906,12 +4310,12 @@ export class LlEmitter {
             this.declare(`declare void @scr_wasi_await_prepare(ptr, ptr)`);
             this.B.line(`call void @scr_wasi_await_prepare(ptr ${coro.self}, ptr ${promise})`);
         }
-        this.emitWasiSuspendPrepared();
+        this.emitCoroSuspendPrepared();
     }
     /** Suspend after a target-specific runtime helper already queued the
      * continuation (used by module awaits, which skip the hop when settled). */
-    emitWasiSuspendPrepared() {
-        const coro = this.currentWasiCoro;
+    emitCoroSuspendPrepared() {
+        const coro = this.currentCoro;
         if (coro === null)
             throw new InternalCompilerError("llvm emitter bug: wasm suspension outside async body");
         const save = this.B.tmp();
@@ -3924,7 +4328,7 @@ export class LlEmitter {
     }
     /** Move a clean async return value into the current fiber's promise. */
     emitWasiFulfill(v) {
-        const coro = this.currentWasiCoro;
+        const coro = this.currentCoro;
         if (coro === null)
             throw new InternalCompilerError("llvm emitter bug: wasm fulfillment outside async body");
         const ret = this.currentReturnType;
@@ -4038,6 +4442,8 @@ export class LlEmitter {
                     this.borrowedParameters.add(fn.params[index].localId);
         }
         this.captureIds = new Set([...(fn.captures ?? []), ...(fn.classCaptures ?? [])].map((c) => c.localId));
+        this.stableCaptureIds =
+            fn.captures !== undefined ? this.lazyCaptures.stableCaptures(fn.name) : new Set();
         this.integerLoopBindings.clear();
         this.countedLoopsEnabled = this.debug === null && !fn.async && !fn.generator;
         this.finalFieldBorrows =
@@ -4060,22 +4466,42 @@ export class LlEmitter {
             this.debug === null ? findScalarStringSlices(fn, this.callLifetimes) : new Map();
         this.mapReadLifetimes = findMapReadLifetimes(fn, this.boxedUnionsById, this.callLifetimes);
         this.localStackUnions = findLocalStackUnions(fn, this.callLifetimes, this.boxedUnionsById);
-        this.localUnionStorageProofs = findLocalUnionStorage(fn, this.callLifetimes, this.boxedUnionsById, (e) => this.nullableFieldGet(e) !== null);
+        this.localStackObjects = this.stackObjects
+            ? findLocalStackObjects(this, fn, this.callLifetimes)
+            : new Map();
+        this.reassignedStackObjects = this.stackObjects
+            ? findReassignedStackObjects(this, fn, this.callLifetimes)
+            : new Set();
+        this.stackObjectSlots = new Map();
+        this.localUnionStorageProofs = findLocalUnionStorage(fn, this.callLifetimes, this.unionSources);
         this.localUnionStorage = new Map();
         this.walkBorrows = this.walkBorrowsByFunction.get(fn.name) ?? new Set();
         this.integerRanges = analyzeIntegerRanges(numericFn, this.int32Slots.facts(fn.name));
         this.bytesBounds = findBytesBounds(numericFn, this.integerRanges);
+        // Debug builds keep every number local a double for the debugger's
+        // variable view. Lazily boxed captured parameters keep their double,
+        // which the box is created from.
+        const int32Locals = this.debug === null
+            ? findInt32Locals(fn, this.integerRanges, this.int32Slots.facts(fn.name), new Set(this.lazyCaptureBoxes.keys()))
+            : null;
+        this.int32Locals = int32Locals?.locals ?? new Map();
+        this.int32LocalWrites = int32Locals?.values ?? new Set();
         this.chainSlots.clear();
         this.finallyStack = [];
         this.tryStack = [];
         this.loopDepth = 0;
         this.currentReturnType = fn.returnType;
+        const int32Abi = this.int32Abis.get(fn.name);
+        this.currentInt32Result = int32Abi?.result === true;
+        this.currentUnionResult = int32Abi?.union === true;
         this.currentGenerator = fn.generator ?? null;
+        this.currentAsyncGenerator = fn.async === true && fn.generator !== undefined;
         this.currentBorrowedReturn = this.borrowedReturns.has(fn.name);
         this.inConstructor = this.constructorFunctions.has(fn.name);
-        this.currentWasiCoro = null;
+        this.currentCoro = null;
         this.logArgSlots = 0;
-        if (this.wasi && (fn.async === true || fn.generator !== undefined)) {
+        if (this.coroLowered(fn)) {
+            this.usesCoroutines = true;
             this.declare(`declare token @llvm.coro.id(i32, ptr, ptr, ptr)`);
             this.declare(`declare ${this.sizeType} @llvm.coro.size.${this.sizeType}()`);
             this.declare(`declare ptr @llvm.coro.begin(token, ptr)`);
@@ -4083,9 +4509,12 @@ export class LlEmitter {
             this.declare(`declare i8 @llvm.coro.suspend(token, i1)`);
             this.declare(`declare ptr @llvm.coro.free(token, ptr)`);
             this.declare(`declare void @llvm.coro.end(ptr, i1, token)`);
-            this.declare(`declare ptr @malloc(${this.sizeType})`);
-            this.declare(`declare void @free(ptr)`);
-            this.declare(`declare void @scr_wasi_coro_started(ptr)`);
+            // Native frames come from the runtime's small-block allocator.
+            const frameAlloc = this.wasi ? "malloc" : "scr_rt_calloc";
+            this.declare(`declare ptr @${frameAlloc}(${this.sizeType})`);
+            this.declare(`declare void @${this.wasi ? "free" : "scr_rt_free"}(ptr)`);
+            const started = this.wasi ? "scr_wasi_coro_started" : "scr_coro_started";
+            this.declare(`declare void @${started}(ptr)`);
             this.declare(`declare ptr @scr_fiber_self()`);
             const id = B.tmp();
             const size = B.tmp();
@@ -4094,11 +4523,11 @@ export class LlEmitter {
             const self = B.tmp();
             B.line(`${id} = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)`);
             B.line(`${size} = call ${this.sizeType} @llvm.coro.size.${this.sizeType}()`);
-            B.line(`${mem} = call ptr @malloc(${this.sizeType} ${size})`);
+            B.line(`${mem} = call ptr @${frameAlloc}(${this.sizeType} ${size})`);
             B.line(`${handle} = call ptr @llvm.coro.begin(token ${id}, ptr ${mem})`);
-            B.line(`call void @scr_wasi_coro_started(ptr ${handle})`);
+            B.line(`call void @${started}(ptr ${handle})`);
             B.line(`${self} = call ptr @scr_fiber_self()`);
-            this.currentWasiCoro = {
+            this.currentCoro = {
                 kind: fn.generator !== undefined ? "generator" : "async",
                 id,
                 handle,
@@ -4111,6 +4540,9 @@ export class LlEmitter {
         const paramIds = new Set(fn.params.map((p) => p.localId));
         if (this.debug === null) {
             for (const id of findIntegerViews(numericFn)) {
+                // An i32 slot is its own view.
+                if (this.int32Locals.has(id))
+                    continue;
                 const slot = B.slot();
                 B.entryAllocas.push(`${slot} = alloca i32 ; integer view ${this.numericLocals.get(id).name}`);
                 this.integerViews.set(id, slot);
@@ -4130,7 +4562,9 @@ export class LlEmitter {
             // box the catch prologue takes (scr_exc_take).
             const slotTy = local.boxed || this.captureIds.has(local.id) || local.type.kind === "caught"
                 ? "ptr"
-                : this.llType(local.type);
+                : this.int32Locals.has(local.id)
+                    ? "i32"
+                    : this.llType(local.type);
             B.entryAllocas.push(`%${mangleLocal(local.id)} = alloca ${slotTy} ; ${local.name}`);
             this.emitDebugLocal(local, `%${mangleLocal(local.id)}`, fn.params.findIndex((p) => p.localId === local.id) + 1, this.captureIds.has(local.id));
             // Refcounted/boxed locals start NULL (the C prologue's `= NULL`):
@@ -4204,8 +4638,16 @@ export class LlEmitter {
                 fnScope.push({ slot, type: p.type, boxed: true });
                 continue;
             }
+            const incoming = { name: `%p_${mangleLocal(p.localId)}`, type: p.type };
+            if (int32Abi?.params[index]) {
+                const bits = `%p_${mangleLocal(p.localId)}${INT32_ABI_SUFFIX}`;
+                incoming.uint32 = bits;
+                incoming.integer = { name: bits, type: "i32", signed: true, range: INT32_RANGE };
+            }
+            if (this.storeInt32Local(p.localId, incoming))
+                continue;
             B.line(`store ${this.llType(p.type)} %p_${mangleLocal(p.localId)}, ptr ${slot}`);
-            this.storeIntegerView(p.localId, { name: `%p_${mangleLocal(p.localId)}`, type: p.type });
+            this.storeIntegerView(p.localId, incoming);
             if (isRefCounted(p.type) && !borrowed?.has(index))
                 fnScope.push({ slot, type: p.type });
             if (this.reboundByFunction.get(fn.name)?.has(p.localId) && borrowed?.has(index)) {
@@ -4219,8 +4661,9 @@ export class LlEmitter {
             }
         }
         this.scopes.push(fnScope);
-        // Stackful native fibers retain these frames while suspended. The
-        // active exception context owns the chain, so concurrent fibers isolate it.
+        // Stackful native fibers and native coroutine frames retain these frames
+        // while suspended. The active exception context owns the chain, so
+        // concurrent fibers isolate it.
         if (this.stackTraces && !this.wasi && fn.sourceName !== undefined) {
             this.declare(`declare void @scr_stack_enter(ptr, ptr)`);
             this.declare(`declare void @scr_stack_leave(ptr)`);
@@ -4239,25 +4682,35 @@ export class LlEmitter {
         // whose unwind released everything down to depth 0).
         if (fn.returnType.kind === "void" && !B.isTerminated()) {
             this.releaseScope(this.scopes[0]);
-            if (this.currentWasiCoro !== null) {
+            // Completing by falling off the end has nothing to await.
+            if (this.currentAsyncGenerator)
+                this.emitAsyncGenSettled();
+            if (this.currentCoro !== null) {
                 this.emitWasiFulfill(null);
-                B.terminate(`br label %${this.currentWasiCoro.finalLabel}`);
+                B.terminate(`br label %${this.currentCoro.finalLabel}`);
             }
             else {
                 B.terminate("ret void");
             }
         }
         this.scopes.pop();
-        const coro = this.currentWasiCoro;
+        const coro = this.currentCoro;
         if (coro !== null) {
             B.startBlock(coro.finalLabel);
+            // Every exit of a coroutine body joins here: its source frame (part
+            // of the coroutine frame) leaves the generator's own chain.
+            const epilogue = B.returnEpilogue;
+            B.returnEpilogue = null;
+            if (epilogue !== null)
+                B.line(epilogue);
             if (fn.captures !== undefined) {
                 this.declare(`declare void @scr_closure_release(ptr)`);
                 B.line(`call void @scr_closure_release(ptr %sc_env)`);
             }
             if (coro.kind === "generator") {
-                this.declare(`declare void @scr_wasi_gen_finish(ptr)`);
-                B.line(`call void @scr_wasi_gen_finish(ptr ${coro.self})`);
+                const finish = this.wasi ? "scr_wasi_gen_finish" : "scr_gen_coro_finish";
+                this.declare(`declare void @${finish}(ptr)`);
+                B.line(`call void @${finish}(ptr ${coro.self})`);
             }
             else {
                 this.declare(`declare void @scr_wasi_async_finish(ptr)`);
@@ -4269,7 +4722,7 @@ export class LlEmitter {
             B.startBlock(coro.cleanupLabel);
             const frame = B.tmp();
             B.line(`${frame} = call ptr @llvm.coro.free(token ${coro.id}, ptr ${coro.handle})`);
-            B.line(`call void @free(ptr ${frame})`);
+            B.line(`call void @${this.wasi ? "free" : "scr_rt_free"}(ptr ${frame})`);
             B.br(coro.suspendLabel);
             B.startBlock(coro.suspendLabel);
             B.line(`call void @llvm.coro.end(ptr ${coro.handle}, i1 false, token none)`);
@@ -4294,11 +4747,26 @@ export class LlEmitter {
         if (this.logArgSlots > 0) {
             B.entryAllocas.push(`%logargs = alloca [${this.logArgSlots} x %ScrLogArg]`);
         }
-        const params = fn.params.map((p) => `${this.llType(p.type)} %p_${mangleLocal(p.localId)}`);
+        const params = fn.params.map((p, index) => int32Abi?.params[index]
+            ? `i32 %p_${mangleLocal(p.localId)}${INT32_ABI_SUFFIX}`
+            : `${this.llType(p.type)} %p_${mangleLocal(p.localId)}`);
+        // The i32 entry widens its i32 parameters once; the proof makes the
+        // double exact, so readers of the incoming number see the same value.
+        if (int32Abi)
+            fn.params.forEach((p, index) => {
+                if (!int32Abi.params[index])
+                    return;
+                const name = `%p_${mangleLocal(p.localId)}`;
+                B.entryAllocas.push(`${name} = sitofp i32 ${name}${INT32_ABI_SUFFIX} to double`);
+            });
         // Lifted functions receive their closure first (the callValue ABI).
         if (fn.captures !== undefined)
             params.unshift("ptr %sc_env");
-        const ret = this.llType(fn.returnType);
+        const ret = int32Abi?.result
+            ? "i32"
+            : int32Abi?.union
+                ? SCALAR_UNION_RESULT
+                : this.llType(fn.returnType);
         let attrs = coro !== null ? "#1" : FN_ATTRS;
         // The shared indexed-read helper (lowerSafeIndexRead) is a dense bounds
         // test, a state test and a load behind cold runtime fallbacks, called
@@ -4309,7 +4777,9 @@ export class LlEmitter {
             attrs = `inlinehint ${attrs}`;
         const debug = this.debugScope === null ? "" : ` !dbg ${this.debugScope}`;
         const symbol = borrowed ? mangleBorrowedFunction(fn.name) : mangleFunction(fn.name);
-        const body = `define internal ${ret} @${symbol}(${params.join(", ")}) ${attrs}${debug} { ; ${fn.name}\n${B.render()}\n}`;
+        let body = `define internal ${ret} @${symbol}${int32Abi ? INT32_ABI_SUFFIX : ""}(${params.join(", ")}) ${attrs}${debug} { ; ${fn.name}\n${B.render()}\n}`;
+        if (int32Abi)
+            body += "\n" + this.emitInt32AbiWrapper(fn, symbol, int32Abi);
         if (!borrowed)
             return body;
         const slot = this.implSlotBorrowed(fn.name);
@@ -4318,9 +4788,141 @@ export class LlEmitter {
             : "";
         return body + "\n" + this.emitOwnedCallAdapter(fn, borrowed) + virtual;
     }
+    /** 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. */
+    emitInt32AbiWrapper(fn, symbol, abi) {
+        const lines = [];
+        const params = [];
+        const args = [];
+        fn.params.forEach((param, index) => {
+            const type = this.llType(param.type);
+            params.push(`${type} %p${index}`);
+            if (abi.params[index]) {
+                lines.push(`  %a${index} = fptosi double %p${index} to i32`);
+                args.push(`i32 %a${index}`);
+            }
+            else
+                args.push(`${type} %p${index}`);
+        });
+        const ret = this.llType(fn.returnType);
+        const entry = `@${symbol}${INT32_ABI_SUFFIX}(${args.join(", ")})`;
+        if (abi.union) {
+            // Box the register pair for every caller of the ordinary ABI.
+            const B = new BlockBuilder();
+            this.B = B;
+            for (const line of lines)
+                B.line(line.trim());
+            const pair = B.tmp();
+            B.line(`${pair} = call ${SCALAR_UNION_RESULT} ${entry}`);
+            B.terminate(`ret ptr ${this.boxScalarUnion(pair, fn.returnType)}`);
+            return `define internal ptr @${symbol}(${params.join(", ")}) ${FN_ATTRS} {\n${B.render()}\n}`;
+        }
+        const call = `call ${abi.result ? "i32" : ret} ${entry}`;
+        if (ret === "void")
+            lines.push(`  ${call}`, "  ret void");
+        else if (abi.result)
+            lines.push(`  %r = ${call}`, `  %d = sitofp i32 %r to double`, `  ret double %d`);
+        else
+            lines.push(`  %r = ${call}`, `  ret ${ret} %r`);
+        return `define internal ${ret} @${symbol}(${params.join(", ")}) ${FN_ATTRS} {\nentry:\n${lines.join("\n")}\n}`;
+    }
+    /** The SCALAR_UNION_RESULT pair of a `%ScrUnion` box of `type`. */
+    scalarUnionPair(box, type) {
+        const B = this.B;
+        const unionId = type.kind === "union" ? type.unionId : "";
+        const tag = this.unionTag(box, unionId);
+        const payload = B.tmp(), bits = B.tmp(), partial = B.tmp(), pair = B.tmp();
+        B.line(`${payload} = getelementptr inbounds %ScrUnion, ptr ${box}, i32 0, i32 5`);
+        B.line(`${bits} = load i64, ptr ${payload}`);
+        B.line(`${partial} = insertvalue ${SCALAR_UNION_RESULT} poison, i32 ${tag}, 0`);
+        B.line(`${pair} = insertvalue ${SCALAR_UNION_RESULT} ${partial}, i64 ${bits}, 1`);
+        return pair;
+    }
+    /** A private stack box holding a SCALAR_UNION_RESULT pair of `type`. */
+    stackScalarUnion(pair, type) {
+        const B = this.B;
+        const box = B.slot(), tagSlot = B.slot(), payloadSlot = B.slot();
+        B.entryAllocas.push(`${box} = alloca %ScrUnion`);
+        B.entryAllocas.push(`${tagSlot} = getelementptr inbounds %ScrUnion, ptr ${box}, i32 0, i32 1`);
+        B.entryAllocas.push(`${payloadSlot} = getelementptr inbounds %ScrUnion, ptr ${box}, i32 0, i32 5`);
+        const tag = B.tmp(), bits = B.tmp();
+        B.line(`${tag} = extractvalue ${SCALAR_UNION_RESULT} ${pair}, 0`);
+        B.line(`${bits} = extractvalue ${SCALAR_UNION_RESULT} ${pair}, 1`);
+        B.line(`store i32 ${tag}, ptr ${tagSlot}`);
+        B.line(`store i64 ${bits}, ptr ${payloadSlot}`);
+        return { name: box, type };
+    }
+    /** A direct call whose i32 entry returns its scalar union in registers. */
+    scalarResultCall(e) {
+        return e.kind === "call" && this.int32Abis.get(e.callee)?.union === true;
+    }
+    /** A fresh heap box (+1) for a SCALAR_UNION_RESULT pair of `type`; the
+     * exception dummy (tag -1) answers NULL. */
+    boxScalarUnion(pair, type) {
+        const B = this.B;
+        const unionId = type.kind === "union" ? type.unionId : "";
+        const arms = this.unionsById.get(unionId).arms;
+        const tag = B.tmp(), bits = B.tmp();
+        B.line(`${tag} = extractvalue ${SCALAR_UNION_RESULT} ${pair}, 0`);
+        B.line(`${bits} = extractvalue ${SCALAR_UNION_RESULT} ${pair}, 1`);
+        const join = B.newLabel("union.box.join"), none = B.newLabel("union.box.none");
+        const labels = arms.map(() => B.newLabel("union.box.arm"));
+        B.terminate(`switch i32 ${tag}, label %${none} [ ${labels.map((label, armTag) => `i32 ${armTag}, label %${label}`).join(" ")} ]`);
+        const incoming = [];
+        arms.forEach((arm, armTag) => {
+            B.startBlock(labels[armTag]);
+            let value;
+            if (isUnitType(arm))
+                value = this.unitInstanceRef(unionId, armTag);
+            else {
+                const payload = B.tmp();
+                if (arm.kind === "bool")
+                    B.line(`${payload} = trunc i64 ${bits} to i1`);
+                else
+                    B.line(`${payload} = bitcast i64 ${bits} to double`);
+                value = this.unionNewOwned(unionId, armTag, { name: payload, type: arm });
+            }
+            incoming.push(`[ ${value}, %${B.currentLabel()} ]`);
+            B.br(join);
+        });
+        B.startBlock(none);
+        incoming.push(`[ null, %${none} ]`);
+        B.br(join);
+        B.startBlock(join);
+        const box = B.tmp();
+        B.line(`${box} = phi ptr ${incoming.join(", ")}`);
+        return box;
+    }
+    /** The i32 bits of a number proven an int32 (a direct call's i32
+     * argument or an i32 result): its exact integer when the value carries
+     * one, else the conversion the proof makes exact. */
+    int32Argument(value, expr) {
+        const integer = exactInteger(this, value, expr);
+        if (integer && /^-?\d+$/.test(integer.name))
+            return String(Number(integer.name) | 0);
+        if (integer)
+            return narrowInteger(this, integer);
+        const bits = this.B.tmp();
+        this.B.line(`${bits} = fptosi double ${value.name} to i32`);
+        return bits;
+    }
+    /** A direct call's i32 result as a number, with the i32 as its integer
+     * and ToUint32 forms. */
+    int32Result(bits, type) {
+        const number = this.B.tmp();
+        this.B.line(`${number} = sitofp i32 ${bits} to double`);
+        return {
+            name: number,
+            type,
+            uint32: bits,
+            integer: { name: bits, type: "i32", signed: true, range: INT32_RANGE },
+        };
+    }
     /** Keep the ordinary owned ABI for closures, virtual dispatch, generated
-     * runtime adapters and library exports. Only direct IR calls select the
-     * borrowing body. Ownership of other parameters moves into that body;
+     * runtime adapters and library exports. Only direct IR calls, calls of a
+     * known closure body and borrowing closure entries (fn_borrowed) select
+     * the borrowing body. Ownership of other parameters moves into that body;
      * borrowed parameters are released here on normal and exceptional exits.
      * The pending exception remains for the adapter's caller to handle. */
     /** With `kept`, the virtual adapter of a borrowing slot instead: the
@@ -4330,6 +4932,9 @@ export class LlEmitter {
         const B = new BlockBuilder();
         this.B = B;
         const params = fn.params.map((param, index) => `${this.llType(param.type)} %p${index}`);
+        // Lifted bodies receive their closure first (the callValue ABI).
+        if (fn.captures !== undefined)
+            params.unshift("ptr %sc_env");
         const ret = this.llType(fn.returnType);
         const call = `call ${ret} @${mangleBorrowedFunction(fn.name)}(${params.join(", ")})`;
         B.line(ret === "void" ? call : `%result = ${call}`);
@@ -4417,6 +5022,9 @@ export class LlEmitter {
         // A module constant owns its value for the rest of the program.
         if (binding.kind === "global")
             return this.stableGlobals.has(value.localId);
+        // So does the environment for a capture nothing ever rebinds.
+        if (binding.kind === "boxed")
+            return this.stableCaptureIds.has(value.localId) && this.canBorrowReceiver(value);
         return (binding.kind === "local" &&
             binding.local !== undefined &&
             (!binding.local.mutable ||
@@ -4494,12 +5102,80 @@ export class LlEmitter {
             return false;
         return !rw.conflicts(["a", ...keys], writes);
     }
+    /** `return p` of a promise inside try regions of an async function. JS
+     * completes the return first: p is evaluated, every crossed finally runs,
+     * and only then does the function's promise adopt p's settlement (a then
+     * job, then p's reaction). So the promise parks in a slot through the
+     * 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. */
+    emitAdoptingReturn(s, adopted) {
+        const B = this.B;
+        const promise = this.emitExpr(adopted.value);
+        this.moveTemp(promise);
+        const slot = B.slot();
+        B.entryAllocas.push(`${slot} = alloca ptr ; adopted return promise`);
+        B.line(`store ptr ${promise.name}, ptr ${slot}`);
+        const parked = { slot, type: adopted.value.type };
+        const savedFrames = this.frames;
+        const savedScopes = this.scopes;
+        const savedFinally = this.finallyStack;
+        const savedTry = this.tryStack;
+        for (let i = savedFinally.length - 1; i >= 0 && !B.isTerminated(); i--) {
+            const fin = savedFinally[i];
+            this.releaseForJump(fin.frameDepth, fin.scopeDepth);
+            this.frames = this.frames.slice(0, fin.frameDepth);
+            this.scopes = this.scopes.slice(0, fin.scopeDepth);
+            this.finallyStack = savedFinally.slice(0, i);
+            this.tryStack = savedTry.slice(0, fin.tryDepth);
+            this.scopes.push([parked]);
+            this.emitBlock(fin.body);
+            this.scopes.pop();
+        }
+        if (!B.isTerminated()) {
+            this.releaseForJump(0, 0);
+            // Nothing of the body is live any more except the parked promise,
+            // whose scope releases it on either exit of the await.
+            this.frames = [[]];
+            this.scopes = [[parked]];
+            this.finallyStack = [];
+            this.tryStack = [];
+            const loaded = B.tmp();
+            B.line(`${loaded} = load ptr, ptr ${slot}`);
+            this.adoptedOperand = { name: loaded, type: adopted.value.type };
+            const v = this.emitExpr(s.value);
+            if (this.adoptedOperand !== null)
+                throw new InternalCompilerError("llvm emitter bug: adopted return promise was not awaited");
+            this.moveTemp(v);
+            this.releaseForJump(0, 0);
+            if (!B.isTerminated()) {
+                if (this.currentCoro !== null) {
+                    this.emitWasiFulfill(v);
+                    B.terminate(`br label %${this.currentCoro.finalLabel}`);
+                }
+                else if (s.value.type.kind === "void")
+                    B.terminate("ret void");
+                else
+                    B.terminate(`ret ${this.llType(s.value.type)} ${v.name}`);
+            }
+        }
+        this.frames = savedFrames;
+        this.scopes = savedScopes;
+        this.finallyStack = savedFinally;
+        this.tryStack = savedTry;
+    }
+    /** An async generator completing without a further turn: its request
+     * settles as the body returns (scr_async_gen_hop_done). */
+    emitAsyncGenSettled() {
+        this.declare(`declare void @scr_async_gen_hop_done()`);
+        this.B.line(`call void @scr_async_gen_hop_done()`);
+    }
     /** `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. */
     movableReturn(value) {
         if (value === null || value.kind !== "varRef" || !isRefCounted(value.type))
             return null;
-        if (this.currentBorrowedReturn || this.currentWasiCoro !== null)
+        if (this.currentBorrowedReturn || this.currentCoro !== null)
             return null;
         const binding = this.binding(value.localId);
         if (binding.kind !== "local" || binding.local === undefined || binding.local.boxed)
@@ -4669,6 +5345,10 @@ export class LlEmitter {
         this.frames.push([]);
         switch (s.kind) {
             case "varDecl": {
+                if (s.init && this.int32Locals.has(s.localId)) {
+                    this.storeInt32Local(s.localId, this.emitExpr(s.init), s.init);
+                    break;
+                }
                 const b = this.binding(s.localId);
                 if (this.walkBorrows.has(s.localId) && b.kind === "local") {
                     // A borrowed walk pointer: no retain now, no release at scope exit.
@@ -4690,6 +5370,17 @@ export class LlEmitter {
                     this.scopes[this.scopes.length - 1].push({ slot: snapshot.sourceSlot, type: STRING }, { slot: snapshot.separatorSlot, type: STRING });
                     break;
                 }
+                const stackObject = this.localStackObjects.get(s.localId);
+                if (stackObject) {
+                    B.line(`store ptr ${emitStackObject(this, stackObject).name}, ptr ${b.slot}`);
+                    break;
+                }
+                if (s.init && this.reassignedStackObjects.has(s.localId)) {
+                    const slot = this.stackObjectSlot(s.localId, s.init.type);
+                    emitStackObject(this, s.init, slot);
+                    B.line(`store ptr ${slot}, ptr ${b.slot}`);
+                    break;
+                }
                 const localUnion = this.localStackUnions.get(s.localId);
                 if (localUnion) {
                     const union = emitStackUnion(this, localUnion);
@@ -4816,6 +5507,10 @@ export class LlEmitter {
                 break;
             }
             case "assign": {
+                if (this.int32Locals.has(s.localId)) {
+                    this.storeInt32Local(s.localId, this.emitExpr(s.value), s.value);
+                    break;
+                }
                 const owner = this.reboundOwnerSlots.get(s.localId);
                 if (owner !== undefined && !this.walkBorrows.has(s.localId)) {
                     // A rebound borrowed parameter: the new value moves into the owner
@@ -4833,6 +5528,15 @@ export class LlEmitter {
                     B.line(`store ptr ${v.name}, ptr ${owner}`);
                     break;
                 }
+                if (this.reassignedStackObjects.has(s.localId)) {
+                    // The new value may read the old one: build it apart, then copy.
+                    const struct = stackObjectStruct(s.value.type);
+                    const value = emitStackObject(this, s.value);
+                    const bits = B.tmp();
+                    B.line(`${bits} = load ${struct}, ptr ${value.name}`);
+                    B.line(`store ${struct} ${bits}, ptr ${this.stackObjectSlot(s.localId, s.value.type)}`);
+                    break;
+                }
                 const localStorage = this.localUnionStorage.get(s.localId);
                 if (localStorage) {
                     storeLocalUnion(this, localStorage, s.value);
@@ -4904,8 +5608,10 @@ export class LlEmitter {
             case "arraySet": {
                 // Evaluation order matches JS: array, index, then value. Ownership
                 // of a refcounted value moves into the array (the runtime releases
-                // the replaced element itself).
-                const arr = emitBorrowedInput(this, s.arr);
+                // the replaced element itself). A local receiver that the index and
+                // value cannot rebind is read in place, as for field stores; the
+                // released element cannot reach that binding.
+                const arr = this.emitStableReceiver(s.arr, [s.index, s.value]);
                 const idx = this.emitExpr(s.index);
                 const v = this.emitExpr(s.value);
                 if (s.arr.type.kind !== "array")
@@ -5083,7 +5789,6 @@ export class LlEmitter {
                     break;
                 }
                 const join = B.newLabel("rks.j");
-                this.declare(`declare zeroext i1 @scr_str_eq(ptr, ptr)`);
                 if (iv.kind === "dyn" && shape.indexValue) {
                     // A dyn-valued shape (the C recordKeySetHelper's dyn arm,
                     // inline): declared keys VALIDATE the dyn value against the
@@ -5093,9 +5798,8 @@ export class LlEmitter {
                     // insert the dyn value into the overflow map as-is.
                     this.declare(`declare void @scr_dyn_release(ptr)`);
                     for (const f of shape.fields) {
-                        const lit = this.internLiteral(f.name);
                         const hit = B.tmp();
-                        B.line(`${hit} = call zeroext i1 @sc_str_eq(ptr ${key.name}, ptr ${lit}) ; ${llvmCommentText(f.name)}`);
+                        B.line(`${hit} = call zeroext i1 ${this.literalEquals(f.name)}(ptr ${key.name}) ; ${llvmCommentText(f.name)}`);
                         const lh = B.newLabel("rks.h");
                         const ln = B.newLabel("rks.n");
                         B.condBr(hit, lh, ln);
@@ -5149,9 +5853,8 @@ export class LlEmitter {
                 }
                 for (const f of shape.fields) {
                     // typeEquals(f.type, iv) — the frontend fences everything else.
-                    const lit = this.internLiteral(f.name);
                     const hit = B.tmp();
-                    B.line(`${hit} = call zeroext i1 @sc_str_eq(ptr ${key.name}, ptr ${lit}) ; ${llvmCommentText(f.name)}`);
+                    B.line(`${hit} = call zeroext i1 ${this.literalEquals(f.name)}(ptr ${key.name}) ; ${llvmCommentText(f.name)}`);
                     const lh = B.newLabel("rks.h");
                     const ln = B.newLabel("rks.n");
                     B.condBr(hit, lh, ln);
@@ -5678,9 +6381,24 @@ export class LlEmitter {
                 // try, past its own catch), then the function-level releases and
                 // the actual ret. The parked value owns a synthetic slot-backed
                 // scope entry during each copy so a throwing finally releases it.
+                const adopted = this.finallyStack.length > 0 || this.tryStack.length > 0
+                    ? adoptingAwaitOf(s.value)
+                    : null;
+                if (adopted !== null) {
+                    this.emitAdoptingReturn(s, adopted);
+                    break;
+                }
                 let v = null;
-                const moved = this.finallyStack.length === 0 ? this.movableReturn(s.value) : null;
-                if (moved !== null) {
+                const moved = this.finallyStack.length === 0 && !this.currentUnionResult
+                    ? this.movableReturn(s.value)
+                    : null;
+                if (s.value !== null && this.currentUnionResult) {
+                    // The tag and payload bits leave in registers; a heap box the
+                    // value needed is released with its frame below.
+                    const box = this.emitUnionProjection(s.value);
+                    v = { name: this.scalarUnionPair(box.name, s.value.type), type: s.value.type };
+                }
+                else if (moved !== null) {
                     // Returning an owned local hands its reference to the caller: no
                     // retain now and no release of the local below.
                     const t = B.tmp();
@@ -5710,9 +6428,22 @@ export class LlEmitter {
                     v = this.emitExpr(s.value);
                     this.moveTemp(v);
                 }
+                // An async generator's `return v` awaits v before any crossed
+                // finally runs. Past finally regions that turn is taken here and
+                // the request settles at completion; otherwise the completion's
+                // own turn is the await (nothing runs in between).
+                const genSettles = this.currentAsyncGenerator && (s.awaited === true || this.finallyStack.length > 0);
+                if (this.currentAsyncGenerator && s.awaited !== true && this.finallyStack.length > 0) {
+                    if (this.wasi)
+                        this.emitWasiSuspend(null);
+                    else {
+                        this.declare(`declare void @scr_await_hop()`);
+                        B.line(`call void @scr_await_hop()`);
+                    }
+                }
                 if (this.finallyStack.length > 0) {
                     let pretSlot = null;
-                    if (v !== null && isRefCounted(v.type)) {
+                    if (v !== null && isRefCounted(v.type) && !this.currentUnionResult) {
                         pretSlot = B.slot();
                         B.entryAllocas.push(`${pretSlot} = alloca ptr ; pending return (through finally)`);
                         B.line(`store ptr ${v.name}, ptr ${pretSlot}`);
@@ -5745,12 +6476,18 @@ export class LlEmitter {
                     this.releaseForJump(0, 0);
                 }
                 if (!B.isTerminated()) {
-                    if (this.currentWasiCoro !== null) {
+                    if (genSettles)
+                        this.emitAsyncGenSettled();
+                    if (this.currentCoro !== null) {
                         this.emitWasiFulfill(v);
-                        B.terminate(`br label %${this.currentWasiCoro.finalLabel}`);
+                        B.terminate(`br label %${this.currentCoro.finalLabel}`);
                     }
                     else if (v === null)
                         B.terminate("ret void");
+                    else if (this.currentInt32Result)
+                        B.terminate(`ret i32 ${this.int32Argument(v, s.value)}`);
+                    else if (this.currentUnionResult)
+                        B.terminate(`ret ${SCALAR_UNION_RESULT} ${v.name}`);
                     else
                         B.terminate(`ret ${this.llType(s.value.type)} ${v.name}`);
                 }
@@ -6008,7 +6745,10 @@ export class LlEmitter {
                 this.frames.push([]);
                 const t = this.emitExpr(c.test);
                 const hit = B.tmp();
-                if (c.test.type.kind === "string") {
+                if (c.test.kind === "strLit") {
+                    B.line(`${hit} = call zeroext i1 ${this.literalEquals(c.test.value)}(ptr ${disc.name})`);
+                }
+                else if (c.test.type.kind === "string") {
                     this.declare(`declare zeroext i1 @scr_str_eq(ptr, ptr)`);
                     B.line(`${hit} = call zeroext i1 @sc_str_eq(ptr ${disc.name}, ptr ${t.name})`);
                 }
@@ -6125,6 +6865,12 @@ export class LlEmitter {
         return this.canBorrowCallArgument(value);
     }
     emitDiscarded(e) {
+        // A statement-position yield never reads the resumed value: it stays
+        // in the IN slot until the next resume replaces it.
+        if (e.kind === "yieldExpr" && e.captureCompletion === undefined && e.type.kind !== "void") {
+            this.emitExpr({ ...e, type: VOID });
+            return;
+        }
         if (e.kind === "seqExpr" &&
             isRefCounted(e.result.type) &&
             e.result.kind !== "strLit" &&
@@ -6242,6 +6988,11 @@ export class LlEmitter {
     emitCallExpr(e) {
         return emitCallExpr(this, e);
     }
+    /** A direct async call an enclosing `await` consumes whole: emitted
+     * through the callee's await-call entry, yielding the awaited value. */
+    emitAwaitedCall(e, adopt = false) {
+        return emitCallExpr(this, e, adopt ? "adopt" : "await");
+    }
     emitRecordExpr(e) {
         return emitRecordExpr(this, e);
     }
@@ -6251,8 +7002,45 @@ export class LlEmitter {
     emitIntrinsicExpr(e) {
         if (e.name === "threads.publish")
             return this.emitPublish(e);
+        if (e.name === "region.create" ||
+            e.name === "region.enter" ||
+            e.name === "region.leave" ||
+            e.name === "region.release")
+            return this.emitRegionIntrinsic(e);
         return emitIntrinsicExpr(this, e);
     }
+    /** Lifetime regions in modules with lifetimeRegions (llvm/regions.ts).
+     * Created with the class graph; null elsewhere. */
+    regions = null;
+    /** LifetimeRegion's runtime calls: create answers the region id, enter
+     * and leave bracket run(), release condemns. */
+    emitRegionIntrinsic(e) {
+        if (this.regions === null)
+            throw new InternalCompilerError(`llvm emitter bug: ${e.name} without lifetimeRegions`);
+        const args = e.args.map((a) => this.emitExpr(a));
+        if (this.B.isTerminated())
+            return { name: "", type: e.type };
+        switch (e.name) {
+            case "region.create": {
+                this.declare(`declare double @scr_region_create(ptr)`);
+                const id = this.B.tmp();
+                this.B.line(`${id} = call double @scr_region_create(ptr ${REGION_TYPES})`);
+                return { name: id, type: e.type };
+            }
+            case "region.enter":
+                this.declare(`declare void @scr_region_enter(double)`);
+                this.B.line(`call void @scr_region_enter(double ${args[0].name})`);
+                break;
+            case "region.leave":
+                this.declare(`declare void @scr_region_leave()`);
+                this.B.line(`call void @scr_region_leave()`);
+                break;
+            default:
+                this.declare(`declare void @scr_region_release(double)`);
+                this.B.line(`call void @scr_region_release(double ${args[0].name})`);
+        }
+        return { name: "", type: e.type };
+    }
     publishWalkersCache = null;
     /** Per-type publication walkers, created on the first publish. */
     get publishWalkers() {
@@ -6539,10 +7327,30 @@ export class LlEmitter {
             B.line(`${value} = load ptr, ptr ${slot}`);
             return { name: value, type: e.type };
         }
+        // Scalar optional values and register results answer a private stack
+        // box. A ternary of borrowable arms above keeps lending its arm.
+        if ((e.kind === "optChain" ||
+            e.kind === "nullish" ||
+            e.kind === "ternary" ||
+            e.kind === "arrIntrinsic") &&
+            isScalarOptionalSource(e, this.unionSources))
+            return emitScalarOptional(this, e);
+        if (e.kind === "call" && this.scalarResultCall(e))
+            return emitCallExpr(this, e, false, true);
         if (e.kind === "call" && this.canBorrowReceiver(e))
             return emitBorrowedResultCall(this, e);
         return this.emitExpr(e);
     }
+    /** The frame slot a reassigned stack-object local keeps for its value. */
+    stackObjectSlot(localId, type) {
+        let slot = this.stackObjectSlots.get(localId);
+        if (slot === undefined) {
+            slot = this.B.slot();
+            this.B.entryAllocas.push(`${slot} = alloca ${stackObjectStruct(type)}, align 8`);
+            this.stackObjectSlots.set(localId, slot);
+        }
+        return slot;
+    }
     /** A private stack union source with an independently owned payload. */
     canStackReceiver(e) {
         return this.isStackUnionSource(e);
@@ -6554,7 +7362,9 @@ export class LlEmitter {
             return false;
         return (canStackUnion(e, this.boxedUnionsById) ||
             matchMapRead(e, this.boxedUnionsById) !== null ||
-            this.optionalArrayReads.get(e) !== null);
+            this.optionalArrayReads.get(e) !== null ||
+            isScalarOptionalSource(e, this.unionSources) ||
+            this.scalarResultCall(e));
     }
     /** The nullable-pointer representation behind a union-typed class field
      * read, or null for every other expression. */
@@ -7011,6 +7821,49 @@ export class LlEmitter {
     emitToUint32(value, expr, uint32) {
         return emitToUint32(this, value, expr, uint32);
     }
+    /** 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
+     * exact value. */
+    storeInt32Local(localId, value, expr) {
+        const local = this.int32Locals.get(localId);
+        if (local === undefined)
+            return false;
+        if (expr !== undefined && !this.int32LocalWrites.has(expr))
+            throw new InternalCompilerError(`llvm emitter bug: unproven write of int32 local ${localId}`);
+        const B = this.B;
+        const integer = exactInteger(this, value, expr);
+        let bits;
+        if (integer && /^-?\d+$/.test(integer.name))
+            bits = String(Number(integer.name) | 0); // a literal's i32 bits
+        else if (integer)
+            bits = narrowInteger(this, integer);
+        else if (value.uint32 !== undefined)
+            bits = value.uint32;
+        else {
+            // An Int32 contract proved this write without a range at the value.
+            bits = B.tmp();
+            B.line(`${bits} = ${local.signed ? "fptosi" : "fptoui"} double ${value.name} to i32`);
+        }
+        B.line(`store i32 ${bits}, ptr %${mangleLocal(localId)}`);
+        return true;
+    }
+    /** The number of an int32-stored local's i32, with the i32 as its
+     * integer and ToUint32 forms. A parameter the body never writes reads
+     * as its incoming double, which is the same number. */
+    int32LocalValue(localId, bits, type) {
+        const local = this.int32Locals.get(localId);
+        let number = `%p_${mangleLocal(localId)}`;
+        if (!local.incoming) {
+            number = this.B.tmp();
+            this.B.line(`${number} = ${local.signed ? "sitofp" : "uitofp"} i32 ${bits} to double`);
+        }
+        return {
+            name: number,
+            type,
+            uint32: bits,
+            integer: { name: bits, type: "i32", signed: local.signed, range: local.range },
+        };
+    }
     storeIntegerView(localId, value, expr) {
         const slot = this.integerViews.get(localId);
         if (slot === undefined)
@@ -7100,4 +7953,24 @@ export class LlEmitter {
         return emitLibCall(this, e);
     }
 }
+/** The adopting await a `return` value resolves through, if any: the value
+ * itself or the operand of its conversion into the declared result. */
+function adoptingAwaitOf(value) {
+    if (value === null)
+        return null;
+    let found = null;
+    everyExpr(value, {
+        expr: (node) => {
+            if (found !== null)
+                return false;
+            if (node.kind === "awaitExpr" && node.adopt === true) {
+                found = node;
+                return false;
+            }
+            return true;
+        },
+        stmt: () => true,
+    });
+    return found;
+}
 //# sourceMappingURL=emitter.js.map