@scriptc/compiler 0.2.10 → 0.3.1

package/dist/backend/llvm/emitter.js

@@ -1,31 +1,14 @@
 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";
-/** Lower typed IR to LLVM, using the runtime's C ABI.
- *
- * Reference-counted temporaries own one reference. Declarations, assignments,
- * returns and arguments move that ownership; frame and scope exits release
- * everything remaining. Slot-backed entries release the slot's current value.
- *
- * Exceptions use a pending flag and explicit cleanup edges. Throwing calls
- * test scr_exc_pending before consuming results, release the scopes crossed,
- * and branch to the innermost handler or return to the caller. Catch bindings
- * hold ScrCaught snapshots; finally runs on normal, throwing and returning
- * paths. This keeps ownership cleanup intact without nonlocal jumps.
- *
- * Program objects are emitted by the packaged LLVM helper and linked with
- * runtime packs. Sanitizer development builds use an external LLVM driver.
- * Dynamic values and islands share the runtime ABI; embedded npm modules use
- * compressed source tables that the runtime inflates on demand.
- */
 import { createHash } from "node:crypto";
-import { deflateRawSync } from "node:zlib";
 import { endsWithJump, matchStringSelfConcat, streamTypedRefEligible, undefinedArmTag, } from "../../ir/analysis.js";
 import { emitLibraryIdentityLines } from "../library-identity-markers.js";
 import { loopTestsEveryIteration } from "../loop-polls.js";
 import { CAUGHT, ffiCallbackType, isDynTypedRefType, isFfiContextParam, isRefCounted, isUnitType, POINTER_KINDS, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, typeEquals, typeKey, STRING, VOID, } from "../../ir/ir.js";
-import { moduleRuntimeFeatures, moduleEmbedsBuiltin, moduleEmbedsCompressedNpm, NPM_COMPRESS_MIN, } from "../../ir/runtime-features.js";
+import { moduleRuntimeFeatures } from "../../ir/runtime-features.js";
 import { matchIntegerArrayForLoop, matchIntegerBytesForLoop, matchIntegerCountedForLoop, } from "../../ir/integer-loops.js";
 import { emitCountedLoopLimit } from "./counted-loops.js";
 import { emitLiteralSwitch } from "./switch-dispatch.js";
@@ -34,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";
@@ -79,8 +65,7 @@ import { emitIntrinsicExpr, emitSerializationExpr, emitAsyncExpr } from "./expr-
 import { PublishWalkers } from "./publish.js";
 import { computeImmutableFields, stableGlobals } from "../immutability.js";
 import { computePublishedTypes } from "../publication.js";
-import { emitJsInteropExpr, emitExpr } from "./expr-dispatch.js";
-import { emitJsMarshal, emitJsOp, emitJsExit, islandAdapter, islandTypedAdapter, } from "./expr-island.js";
+import { emitExpr } from "./expr-dispatch.js";
 import { dynKind, raceAdapterFor, genResultThunkFor, childExitThunkFor, childExitSignalThunkFor, childDataThunkFor, execFileThunkFor, ipcMessageThunkFor, ipcSendThunkFor, emitterFixedAdapter, wrapEmitterListener, unwrapNullableClosure, closeBindThunkFor, closeOverrideWrapFor, } from "./expr-callbacks.js";
 import { streamDataAdapter, streamDoneFnFor, cryptoBytesThunkFor, fsRenameThunkFor, streamCbThunkFor, zlibBytesThunkFor, } from "./expr-stream-callbacks.js";
 import { emitStableReceiver, resolveThunkFor, tagInSet, arrPush, emitArrayCopyLoop, emitStrIntrinsic, emitArrIntrinsic, emitDiscardedSplice, wrapNullable, emitMapNew, mapSet, emitMapLikeIntrinsic, emitSetNew, } from "./expr-containers.js";
@@ -104,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) {
@@ -239,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. */
@@ -258,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
@@ -266,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();
@@ -331,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();
@@ -386,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;
@@ -459,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;
@@ -476,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
@@ -499,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. */
@@ -524,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);
@@ -531,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.
@@ -682,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),
@@ -1125,23 +1160,6 @@ export class LlEmitter {
         const asyncDefs = this.emitAsyncScaffolding();
         const ffiCallbacks = this.emitFfiCallbackDefs();
         const hasNoInlineRecordClone = [...this.recordCloneShapes].some((shapeId) => (this.recordsById.get(shapeId)?.fields.length ?? 0) >= 16);
-        const embedded = this.mod.embedded;
-        const usesIsland = embedded !== undefined && embedded.modules.length > 0;
-        const storeNpmText = (text) => {
-            const plain = Buffer.from(text, "utf8");
-            if (text.length < NPM_COMPRESS_MIN)
-                return { bytes: plain, raw: 0 };
-            const deflated = deflateRawSync(plain, { level: 9 });
-            return deflated.length < plain.length
-                ? { bytes: deflated, raw: plain.length }
-                : { bytes: plain, raw: 0 };
-        };
-        const npmStored = usesIsland
-            ? embedded.modules.map((m) => ({
-                src: storeNpmText(m.source),
-                esm: m.esm === undefined ? null : storeNpmText(m.esm),
-            }))
-            : [];
         // Module globals, FIRST OCCURRENCE per id: a class-expression static
         // instantiated through several mixin applications registers one global
         // id several times (2041-mixin-values) — C's tentative definitions
@@ -1205,24 +1223,14 @@ export class LlEmitter {
         const usesDgram = runtimeFeatures.dgram;
         const usesHttp2 = runtimeFeatures.http2;
         const usesHttp = runtimeFeatures.http;
-        // Fetch-referencing programs register the native fetch bridge before
-        // any island entry (the engine's lazy boot consults it) — native/executable.ts
-        // compiles scr_fetch.c on the same predicate.
+        // Fetch-referencing programs register native fetch before main.
+        // Runtime selection compiles scr_fetch.c on the same predicate.
         const usesFetch = runtimeFeatures.fetch;
-        const embedsZlib = moduleEmbedsBuiltin(this.mod, "node:zlib");
-        const embedsNet = moduleEmbedsBuiltin(this.mod, "node:http") ||
-            moduleEmbedsBuiltin(this.mod, "node:https") ||
-            moduleEmbedsBuiltin(this.mod, "node:net") ||
-            moduleEmbedsBuiltin(this.mod, "node:tls");
-        const snapshotsTlsCa = runtimeFeatures.tls ||
-            runtimeFeatures.tlsCa ||
-            moduleEmbedsBuiltin(this.mod, "node:https") ||
-            moduleEmbedsBuiltin(this.mod, "node:tls");
+        const snapshotsTlsCa = runtimeFeatures.tls || runtimeFeatures.tlsCa;
         // The process verdict has the same precedence as the C reference
         // emitter: node:test owns the final status when present; otherwise an
         // embedded process.exitCode owns it; ordinary programs return zero.
         const usesNodeTest = runtimeFeatures.nodeTest;
-        const programExitUsesIsland = !usesNodeTest && usesIsland;
         // Declared NOW — the extern block flushes before main assembles.
         if (usesEvents)
             this.declare(`declare void @scr_events_install()`);
@@ -1259,19 +1267,6 @@ export class LlEmitter {
             this.declare(`declare void @scr_http_dyn_install()`);
         if (usesFetch)
             this.declare(`declare void @scr_fetch_install()`);
-        if (embedsZlib)
-            this.declare(`declare void @scr_zlib_island_install()`);
-        if (embedsNet)
-            this.declare(`declare void @scr_net_island_install()`);
-        if (usesIsland) {
-            this.declare(`declare void @scr_island_modules(ptr, ${this.sizeType}, ptr, ${this.sizeType})`);
-            this.declare(`declare void @scr_island_entry_module(ptr)`);
-            this.declare(`declare i32 @scr_island_exit_code()`);
-            if (moduleEmbedsCompressedNpm(this.mod)) {
-                this.declare(`declare void @scr_island_set_inflate(ptr)`);
-                this.declare(`declare zeroext i1 @scr_zlib_inflate_exact(ptr, ${this.sizeType}, ptr, ${this.sizeType})`);
-            }
-        }
         if (usesNodeTest)
             this.declare(`declare i32 @scr_test_exit_code()`);
         if (snapshotsTlsCa) {
@@ -1310,7 +1305,6 @@ export class LlEmitter {
         // fibers as abandoned, so the RC audit downgrades exactly like the
         // async loop-exhaustion story.
         const runsLoop = this.usesTimers ||
-            usesIsland ||
             this.ffiHasForeignCallback ||
             this.mod.functions.some((f) => f.async === true || f.generator !== undefined);
         const uncaughtReleases = entryMayThrow && !asyncEntry ? globalReleaseLines("gu") : [];
@@ -1337,9 +1331,6 @@ export class LlEmitter {
             this.declare(`declare void @scr_promise_rethrow_top_level(ptr)`);
             this.declare(`declare void @scr_promise_release(ptr)`);
             this.declare(`declare void @scr_exit_code_note(i32)`);
-            if (programExitUsesIsland && inlineExitListeners) {
-                this.declare(`declare ${this.sizeType} @scr_island_exit_code_version()`);
-            }
         }
         const topPendingExitLines = () => {
             if (!asyncEntry)
@@ -1348,28 +1339,18 @@ export class LlEmitter {
             if (usesNodeTest) {
                 lines.push(`  %tla_program_exit = call i32 @scr_test_exit_code()`);
             }
-            else if (usesIsland) {
-                lines.push(`  %tla_program_exit = call i32 @scr_island_exit_code()`);
-            }
-            if (usesNodeTest || usesIsland) {
+            if (usesNodeTest) {
                 lines.push(`  %tla_program_exit_zero = icmp eq i32 %tla_program_exit, 0`, `  %tla_exit_status = select i1 %tla_program_exit_zero, i32 %tla_status, i32 %tla_program_exit`);
             }
-            const exitStatus = usesNodeTest || usesIsland ? "%tla_exit_status" : "%tla_status";
-            const tracksIslandExit = programExitUsesIsland && inlineExitListeners;
-            if (tracksIslandExit) {
-                lines.push(`  %tla_exit_version = call ${this.sizeType} @scr_island_exit_code_version()`);
-            }
+            const exitStatus = usesNodeTest ? "%tla_exit_status" : "%tla_status";
             // finish_top_level initially notes 13. Replace that hint before exit
             // listeners run when a higher-priority verdict was already selected.
             lines.push(`  call void @scr_exit_code_note(i32 ${exitStatus})`);
             for (const line of exitListenerLines("xp"))
                 lines.push(line);
-            if (tracksIslandExit) {
-                lines.push(`  %tla_exit_version_after = call ${this.sizeType} @scr_island_exit_code_version()`, `  %tla_exit_changed = icmp ne ${this.sizeType} %tla_exit_version_after, %tla_exit_version`, `  br i1 %tla_exit_changed, label %tla_exit_updated, label %tla_exit_unchanged`, `tla_exit_updated:`, `  %tla_listener_exit = call i32 @scr_island_exit_code()`, `  call void @scr_exit_code_note(i32 %tla_listener_exit)`, `  br label %tla_exit_done`, `tla_exit_unchanged:`, `  br label %tla_exit_done`, `tla_exit_done:`, `  %tla_final_exit = phi i32 [ %tla_listener_exit, %tla_exit_updated ], [ ${exitStatus}, %tla_exit_unchanged ]`);
-            }
             for (const line of topPendingReleases)
                 lines.push(line);
-            lines.push(`  ret i32 ${tracksIslandExit ? "%tla_final_exit" : exitStatus}`);
+            lines.push(`  ret i32 ${exitStatus}`);
             return lines;
         };
         // LIBRARY mode: the runtime entry points the generated library
@@ -1424,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.`,
             ``,
@@ -1437,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
@@ -1456,11 +1447,12 @@ export class LlEmitter {
                 ? []
                 : [`%ScrMapRc = type { ${this.sizeType}, i32, i32, ptr, ptr, ptr, ptr, ptr, ptr }`]),
             // The complete ScrMap and its { key, val, hash } entry, read by the
-            // inline number-key lookup (sc_map_entry_f64): entries is field 12,
-            // the direct index and its length fields 18 and 19.
-            ...(this.decls.has(NUMBER_MAP_ENTRY_DECL)
+            // inline number-key lookup (sc_map_entry_f64): field 11 is the i64
+            // absent-key filter, entries is field 13, the direct index and its
+            // length fields 19 and 20.
+            ...(this.decls.has(NUMBER_MAP_ENTRY_DECL) || this.decls.has(STRING_MAP_ENTRY_DECL)
                 ? [
-                    `%ScrMapIx = type { ${this.sizeType}, i32, i32, ptr, ptr, ptr, ptr, ptr, ptr, ${this.sizeType}, ${this.sizeType}, ${this.sizeType}, ptr, ${this.sizeType}, ptr, ${this.sizeType}, ptr, ptr, ptr, ${this.sizeType} }`,
+                    `%ScrMapIx = type { ${this.sizeType}, i32, i32, ptr, ptr, ptr, ptr, ptr, ptr, ${this.sizeType}, ${this.sizeType}, i64, ${this.sizeType}, ptr, ${this.sizeType}, ptr, ${this.sizeType}, ptr, ptr, ptr, ${this.sizeType} }`,
                 ]
                 : []),
             // String-keyed reference reads load the value slot of the entry
@@ -1544,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
@@ -1553,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
@@ -1580,71 +1599,34 @@ 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(``);
-        const islandEntryPath = usesIsland ? this.cstr(this.mod.sourceFile) : null;
         for (const [text, c] of this.cstrs) {
             // NUL-terminated byte-array constants for scr_jb_puts and indentation.
             out.push(`@${c.sym} = internal constant [${c.len + 1} x i8] c"${llStrBytes(text)}"`);
         }
         if (this.cstrs.size > 0)
             out.push(``);
-        if (usesIsland) {
-            const fmt = { esm: 0, cjs: 1, json: 2 };
-            const edgeKind = { any: 0, import: 1, require: 2 };
-            embedded.modules.forEach((m, i) => {
-                const stored = npmStored[i];
-                const key = Buffer.from(m.key, "utf8");
-                out.push(`@sc_npm_key_${i} = internal constant [${key.length + 1} x i8] c"${llBytes(key)}"`, `@sc_npm_src_${i} = internal constant [${stored.src.bytes.length + 1} x i8] c"${llBytes(stored.src.bytes)}"`);
-                if (stored.esm !== null) {
-                    out.push(`@sc_npm_esm_${i} = internal constant [${stored.esm.bytes.length + 1} x i8] c"${llBytes(stored.esm.bytes)}"`);
-                }
-            });
-            const moduleRows = embedded.modules.map((m, i) => {
-                const stored = npmStored[i];
-                const esm = stored.esm === null
-                    ? `ptr null, ${this.sizeType} 0, ${this.sizeType} 0`
-                    : `ptr @sc_npm_esm_${i}, ${this.sizeType} ${stored.esm.bytes.length}, ${this.sizeType} ${stored.esm.raw}`;
-                return (`%ScrIslandModule { ptr @sc_npm_key_${i}, ptr @sc_npm_src_${i}, ` +
-                    `${this.sizeType} ${stored.src.bytes.length}, ${this.sizeType} ${stored.src.raw}, ` +
-                    `i32 ${fmt[m.format]}, ${esm} }`);
-            });
-            out.push(`@sc_npm_modules = internal constant [${moduleRows.length} x %ScrIslandModule] [ ${moduleRows.join(", ")} ]`);
-            embedded.edges.forEach((edge, i) => {
-                const parts = [
-                    ["from", edge.from],
-                    ["spec", edge.specifier],
-                    ["to", edge.to],
-                ];
-                for (const [part, text] of parts) {
-                    const bytes = Buffer.from(text, "utf8");
-                    out.push(`@sc_npm_edge_${i}_${part} = internal constant [${bytes.length + 1} x i8] c"${llBytes(bytes)}"`);
-                }
-            });
-            if (embedded.edges.length > 0) {
-                const edgeRows = embedded.edges.map((edge, i) => `%ScrIslandEdge { ptr @sc_npm_edge_${i}_from, ptr @sc_npm_edge_${i}_spec, ` +
-                    `ptr @sc_npm_edge_${i}_to, i32 ${edgeKind[edge.kind]} }`);
-                out.push(`@sc_npm_edges = internal constant [${edgeRows.length} x %ScrIslandEdge] [ ${edgeRows.join(", ")} ]`);
-            }
-            out.push(``);
-        }
         for (const line of ffiCallbacks.globals)
             out.push(line);
         if (ffiCallbacks.globals.length > 0)
@@ -1734,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 }`);
@@ -1758,16 +1740,7 @@ export class LlEmitter {
             : []), 
         // fs.watch programs fill the loop's watch hooks the same way —
         // scr_watch.c links only when this line is emitted.
-        ...(usesFsWatch ? [`  call void @scr_watch_install()`] : []), ...(this.ffiHasForeignCallback ? [`  call void @scr_ffi_install()`] : []), ...(snapshotsTlsCa ? [`  call void @scr_tls_ca_install()`] : []), ...(usesFetch ? [`  call void @scr_fetch_install()`] : []), ...(embedsZlib ? [`  call void @scr_zlib_island_install()`] : []), ...(embedsNet ? [`  call void @scr_net_island_install()`] : []), ...(usesNet ? [`  call void @scr_net_install()`, `  call void @scr_net_dyn_install()`] : []), ...(usesHttp ? [`  call void @scr_http_dyn_install()`] : []), ...(usesDgram ? [`  call void @scr_dgram_install()`] : []), ...(usesHttp2 ? [`  call void @scr_http2_dyn_install()`] : []), ...(usesStream ? [`  call void @scr_stream_install()`] : []), `  call void @scr_lib_init(i32 %argc, ptr %argv)`, ...(usesIsland
-            ? [
-                `  call void @scr_island_entry_module(ptr ${islandEntryPath})`,
-                ...(moduleEmbedsCompressedNpm(this.mod)
-                    ? [`  call void @scr_island_set_inflate(ptr @scr_zlib_inflate_exact)`]
-                    : []),
-                `  call void @scr_island_modules(ptr @sc_npm_modules, ${this.sizeType} ${embedded.modules.length}, ` +
-                    `ptr ${embedded.edges.length > 0 ? "@sc_npm_edges" : "null"}, ${this.sizeType} ${embedded.edges.length})`,
-            ]
-            : []), ...(asyncEntry
+        ...(usesFsWatch ? [`  call void @scr_watch_install()`] : []), ...(this.ffiHasForeignCallback ? [`  call void @scr_ffi_install()`] : []), ...(snapshotsTlsCa ? [`  call void @scr_tls_ca_install()`] : []), ...(usesFetch ? [`  call void @scr_fetch_install()`] : []), ...(usesNet ? [`  call void @scr_net_install()`, `  call void @scr_net_dyn_install()`] : []), ...(usesHttp ? [`  call void @scr_http_dyn_install()`] : []), ...(usesDgram ? [`  call void @scr_dgram_install()`] : []), ...(usesHttp2 ? [`  call void @scr_http2_dyn_install()`] : []), ...(usesStream ? [`  call void @scr_stream_install()`] : []), `  call void @scr_lib_init(i32 %argc, ptr %argv)`, ...(asyncEntry
             ? [`  %top = call ptr @${mangleAsyncSpawn(this.mod.entry)}()`]
             : [`  call void @${mangleFunction(this.mod.entry)}()`]), 
         // Uncaught exception from top-level code: Node exits 1.
@@ -1854,13 +1827,11 @@ export class LlEmitter {
             ]
             : []), ...exitListenerLines("xn"), ...globalReleases, ...(usesNodeTest
             ? [`  %test_exit = call i32 @scr_test_exit_code()`, `  ret i32 %test_exit`]
-            : usesIsland
-                ? [`  %island_exit = call i32 @scr_island_exit_code()`, `  ret i32 %island_exit`]
-                : [`  %native_exit = call i32 @scr_exit_code_hint_get()`, `  ret i32 %native_exit`]), `}`, ``, ...this.inlineRcTail(flushedDecls), 
+            : [`  %native_exit = call i32 @scr_exit_code_hint_get()`, `  ret i32 %native_exit`]), `}`, ``, ...this.inlineRcTail(flushedDecls), 
         // 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`, `}`);
         }
@@ -2122,11 +2093,44 @@ export class LlEmitter {
             const sz = this.sizeType;
             let mapTmp = 0;
             const mapIndex = exactIndexLines("%k", "%nd", sz, () => `%ix${mapTmp++}`);
-            defs.push(`define internal ptr @sc_map_entry_f64(ptr %m, double %k) ${FN_ATTRS} {`, `entry:`, `  %ndp = getelementptr inbounds %ScrMapIx, ptr %m, i32 0, i32 19`, `  %nd = load ${sz}, ptr %ndp`, 
+            defs.push(`define internal ptr @sc_map_entry_f64(ptr %m, double %k) ${FN_ATTRS} {`, `entry:`, `  %ndp = getelementptr inbounds %ScrMapIx, ptr %m, i32 0, i32 20`, `  %nd = load ${sz}, ptr %ndp`, 
             // A non-integral key inside the table is as absent as one outside it.
             ...mapIndex.lines.map((line) => `  ${line}`), `  br i1 ${mapIndex.ok}, label %slot, label %outside`, `slot:`, sz === "i64"
                 ? `  %i = add i64 ${mapIndex.wide}, 0`
-                : `  %i = trunc i64 ${mapIndex.wide} to ${sz}`, `  %dp = getelementptr inbounds %ScrMapIx, ptr %m, i32 0, i32 18`, `  %dense = load ptr, ptr %dp`, `  %sp = getelementptr inbounds i32, ptr %dense, ${sz} %i`, `  %s = load i32, ptr %sp`, `  %empty = icmp eq i32 %s, 0`, `  br i1 %empty, label %miss, label %hit`, `hit:`, `  %e32 = sub i32 %s, 1`, sz === "i32" ? `  %e = add i32 %e32, 0` : `  %e = zext i32 %e32 to ${sz}`, `  %ep = getelementptr inbounds %ScrMapIx, ptr %m, i32 0, i32 12`, `  %entries = load ptr, ptr %ep`, `  %found = getelementptr inbounds %ScrMapEntry, ptr %entries, ${sz} %e`, `  ret ptr %found`, `miss:`, `  ret ptr null`, `outside:`, `  %dense.any = icmp ne ${sz} %nd, 0`, `  br i1 %dense.any, label %miss, label %slow`, `slow:`, `  %r = call ptr @scr_map_entry_f64(ptr %m, double %k)`, `  ret ptr %r`, `}`, ``);
+                : `  %i = trunc i64 ${mapIndex.wide} to ${sz}`, `  %dp = getelementptr inbounds %ScrMapIx, ptr %m, i32 0, i32 19`, `  %dense = load ptr, ptr %dp`, `  %sp = getelementptr inbounds i32, ptr %dense, ${sz} %i`, `  %s = load i32, ptr %sp`, `  %empty = icmp eq i32 %s, 0`, `  br i1 %empty, label %miss, label %hit`, `hit:`, `  %e32 = sub i32 %s, 1`, sz === "i32" ? `  %e = add i32 %e32, 0` : `  %e = zext i32 %e32 to ${sz}`, `  %ep = getelementptr inbounds %ScrMapIx, ptr %m, i32 0, i32 13`, `  %entries = load ptr, ptr %ep`, `  %found = getelementptr inbounds %ScrMapEntry, ptr %entries, ${sz} %e`, `  ret ptr %found`, `miss:`, `  ret ptr null`, `outside:`, `  %dense.any = icmp ne ${sz} %nd, 0`, `  br i1 %dense.any, label %miss, label %slow`, `slow:`, `  %r = call ptr @scr_map_entry_f64(ptr %m, double %k)`, `  ret ptr %r`, `}`, ``);
+        }
+        // String-key Map/Set lookups test the map's absent-key filter inline
+        // (scr_map.c scr_map_filter_bits): a key whose two filter bits are not
+        // both set is absent, so most misses on small and medium maps return
+        // without a call. On 64-bit targets the key's cached hash h is the high
+        // half of its capacity word, the runtime's widened hash is (h << 32) | h,
+        // and the filter reads its bits 44..55, which are the capacity word's
+        // own. A key without a cached hash, and every possible hit, take the
+        // runtime lookup.
+        if (this.decls.has(STRING_MAP_ENTRY_DECL)) {
+            defs.push(`define internal ptr @sc_map_entry_str(ptr %m, ptr %k) ${FN_ATTRS} {`, `entry:`, ...(this.sizeType === "i64"
+                ? [
+                    `  %fp = getelementptr inbounds %ScrMapIx, ptr %m, i32 0, i32 11`,
+                    `  %filter = load i64, ptr %fp`,
+                    `  %capp = getelementptr inbounds %ScrStr, ptr %k, i32 0, i32 2`,
+                    `  %cap = load i64, ptr %capp`,
+                    `  %cached = icmp uge i64 %cap, 4294967296`,
+                    `  br i1 %cached, label %test, label %slow`,
+                    `test:`,
+                    `  %s1 = lshr i64 %cap, 44`,
+                    `  %i1 = and i64 %s1, 63`,
+                    `  %b1 = shl i64 1, %i1`,
+                    `  %s2 = lshr i64 %cap, 50`,
+                    `  %i2 = and i64 %s2, 63`,
+                    `  %b2 = shl i64 1, %i2`,
+                    `  %bits = or i64 %b1, %b2`,
+                    `  %have = and i64 %filter, %bits`,
+                    `  %maybe = icmp eq i64 %have, %bits`,
+                    `  br i1 %maybe, label %slow, label %absent`,
+                    `absent:`,
+                    `  ret ptr null`,
+                ]
+                : [`  br label %slow`]), `slow:`, `  %r = call ptr @scr_map_entry_str(ptr %m, ptr %k)`, `  ret ptr %r`, `}`, ``);
         }
         // String comparisons enter through small internal wrappers that LLVM
         // inlines at each site: interned literals and shared values compare by
@@ -2135,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
@@ -2218,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;
     }
@@ -2231,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:`,
@@ -2242,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:`,
@@ -2305,8 +2323,8 @@ export class LlEmitter {
      * mentions (transitively), contains no suspension entry point. Such a
      * body always completes before the call returns, which is exactly the
      * behavior of a fiber that never suspends. Excluded conservatively:
-     * wasm32 (its coroutine lowering owns async bodies), programs embedding
-     * the dynamic engine, module-evaluation bodies (their promise caches),
+     * wasm32 (its coroutine lowering owns async bodies), module-evaluation
+     * bodies (their promise caches),
      * `dyn` results (resolution may adopt a thenable), and every program
      * that uses node:test subtests — `t.test()` runs a subtest inline and
      * awaits it on the CURRENT fiber even from synchronous code. Worker
@@ -2319,10 +2337,7 @@ export class LlEmitter {
         const eligible = new Set();
         if (this.wasi || this.mod.workers === true)
             return eligible;
-        const embedded = this.mod.embedded;
-        if (embedded !== undefined && embedded.modules.length > 0)
-            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;
@@ -2418,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
@@ -2436,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"] : []),
@@ -2449,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();
@@ -2540,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
@@ -2560,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 {
@@ -2652,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);
@@ -2691,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) {
@@ -2729,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) {
@@ -2973,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.
@@ -2998,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}`;
@@ -3324,15 +3543,6 @@ export class LlEmitter {
             this.declare(`declare void @scr_dyn_throw(ptr)`);
             B.line(`call void @scr_dyn_throw(ptr ${v.name})`);
         }
-        else if (t.kind === "jsval") {
-            const rc = vAdapters(this.shapeHost, t);
-            const test = "scr_jsval_is_object";
-            this.declare(`declare zeroext i1 @${test}(ptr)`);
-            this.declare(`declare void @scr_throw_ref_classified(ptr, ptr, ptr, ptr, i1 zeroext)`);
-            const object = B.tmp();
-            B.line(`${object} = call zeroext i1 @${test}(ptr ${v.name})`);
-            B.line(`call void @scr_throw_ref_classified(ptr ${v.name}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${traceArg(this.shapeHost, t)}, i1 zeroext ${object})`);
-        }
         else {
             const rc = vAdapters(this.shapeHost, t);
             this.declare(`declare void @scr_throw_ref(ptr, ptr, ptr, ptr)`);
@@ -3370,7 +3580,7 @@ export class LlEmitter {
                 else if (arm.kind === "string") {
                     valueName = this.unionPeek(v.name, unionId);
                 }
-                else if (arm.kind === "bigint" || arm.kind === "dyn" || arm.kind === "jsval") {
+                else if (arm.kind === "bigint" || arm.kind === "dyn") {
                     valueName = this.unionPeek(v.name, unionId);
                 }
                 const truthy = this.truthyOf(arm.kind, valueName, true);
@@ -3464,14 +3674,6 @@ export class LlEmitter {
                 B.line(`${truthy} = call zeroext i1 @scr_dyn_truthy(ptr ${valueName})`);
                 return truthy;
             }
-            case "jsval": {
-                this.declare(`declare i32 @scr_jsval_truthy(ptr)`);
-                const raw = B.tmp();
-                const truthy = B.tmp();
-                B.line(`${raw} = call i32 @scr_jsval_truthy(ptr ${valueName})`);
-                B.line(`${truthy} = icmp ne i32 ${raw}, 0`);
-                return truthy;
-            }
             default:
                 throw new LlvmUnsupportedError(`truthy:${unionArm ? "union:" : ""}${kind}`);
         }
@@ -3988,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);
@@ -4005,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) {
@@ -4016,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();
@@ -4034,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;
@@ -4148,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 =
@@ -4175,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)`);
@@ -4193,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();
@@ -4204,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,
@@ -4221,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);
@@ -4240,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`):
@@ -4314,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)) {
@@ -4329,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)`);
@@ -4349,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)`);
@@ -4379,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)`);
@@ -4404,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
@@ -4419,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);
@@ -4428,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
@@ -4440,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}`);
@@ -4527,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 ||
@@ -4604,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)
@@ -4779,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.
@@ -4926,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
@@ -5014,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")
@@ -5193,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
@@ -5203,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);
@@ -5259,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);
@@ -5788,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) {
@@ -5855,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}`);
                 }
@@ -6118,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})`);
                 }
@@ -6235,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" &&
@@ -6352,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);
     }
@@ -6518,9 +6944,6 @@ export class LlEmitter {
     emitAsyncExpr(e) {
         return emitAsyncExpr(this, e);
     }
-    emitJsInteropExpr(e) {
-        return emitJsInteropExpr(this, e);
-    }
     /** Read a receiver whose value is consumed immediately by a field or tag
      * load. No user code may run between this read and its consumer. Locals
      * and their projections already have an owner; other expressions keep
@@ -7010,21 +7433,6 @@ export class LlEmitter {
     emitExpr(e) {
         return emitExpr(this, e);
     }
-    emitJsMarshal(e) {
-        return emitJsMarshal(this, e);
-    }
-    emitJsOp(e) {
-        return emitJsOp(this, e);
-    }
-    emitJsExit(e) {
-        return emitJsExit(this, e);
-    }
-    islandAdapter(arity, retKind) {
-        return islandAdapter(this, arity, retKind);
-    }
-    islandTypedAdapter(fn) {
-        return islandTypedAdapter(this, fn);
-    }
     dynKind(d) {
         return dynKind(this, d);
     }
@@ -7139,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)
@@ -7228,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