@scriptc/compiler 0.3.0 → 0.3.1

package/dist/backend/llvm/emitter.js

@@ -1,4 +1,5 @@
 import { emitLlvmLayouts } from "./layouts.js";
+import { compileRegexMatcher } from "./regex-matchers.js";
 import { FIRST_EMITTED_CYC_KIND, inlineAllocSupported } from "./alloc.js";
 import { llvmBytes as llBytes } from "../literals.js";
 import { InternalCompilerError } from "../../errors.js";
@@ -16,19 +17,22 @@ import { emitByteWindowGuard, findInitializedByteLoopBindings, matchByteWindow,
 import { canDeferSplitPiece, emitSplitSpanNext, materializeSplitPiece, emitSplitCursor, emitSplitNext, emitSplitScratch, emitSplitSnapshot, findPrivateSplitLocals, loadSplitSnapshot, storeSplitSnapshot, stringSplit, } from "./split-loops.js";
 import { scalarizeNumericRecords } from "../../ir/scalar-records.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 } 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";
@@ -85,6 +89,7 @@ import { NUMBER_MAP_ENTRY_DECL, STRING_MAP_ENTRY_DECL } from "./map-number-looku
 import { STRING_READ_HELPERS } 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) {
@@ -220,6 +225,14 @@ export class LlEmitter {
      * 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 +252,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 +264,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();
@@ -312,6 +333,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 +391,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;
@@ -440,6 +479,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 +498,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,9 +528,12 @@ 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;
+    /** 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. */
@@ -505,6 +556,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 +564,7 @@ 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;
         // 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.
@@ -663,6 +716,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),
@@ -1351,6 +1405,16 @@ export class LlEmitter {
         ];
         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 +1428,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
@@ -1472,6 +1536,26 @@ export class LlEmitter {
         }
         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 +1565,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 +1599,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(``);
@@ -1622,7 +1716,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 +1831,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,6 +2139,9 @@ 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, Buffer.from(text, "utf8"), 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
@@ -2128,7 +2225,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 +2243,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 +2260,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 +2337,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 +2433,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 +2578,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 +2599,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 +2698,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 +2725,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 +2818,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 +2860,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 +2933,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 +3187,21 @@ 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"
+                        : 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 +3214,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 +4190,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 +4230,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 +4241,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 +4259,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 +4373,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 =
@@ -4065,17 +4402,28 @@ export class LlEmitter {
         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.currentGenerator = fn.generator ?? null;
         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 +4431,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 +4445,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 +4462,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 +4484,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 +4560,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 +4583,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 +4604,32 @@ 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) {
+            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 +4641,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 +4666,22 @@ 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" : 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 +4692,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 +4703,62 @@ 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 call = `call ${abi.result ? "i32" : ret} @${symbol}${INT32_ABI_SUFFIX}(${args.join(", ")})`;
+        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 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 +4768,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 +4858,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 +4938,74 @@ 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;
+    }
     /** `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 +5175,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.
@@ -4816,6 +5326,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
@@ -4904,8 +5418,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 +5599,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 +5608,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 +5663,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,6 +6191,13 @@ 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) {
@@ -5745,12 +6265,14 @@ export class LlEmitter {
                     this.releaseForJump(0, 0);
                 }
                 if (!B.isTerminated()) {
-                    if (this.currentWasiCoro !== null) {
+                    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
                         B.terminate(`ret ${this.llType(s.value.type)} ${v.name}`);
                 }
@@ -6008,7 +6530,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 +6650,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 +6773,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);
     }
@@ -7011,6 +7547,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 +7679,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