@scriptc/compiler 0.3.1 → 0.3.3

package/dist/backend/llvm/emitter.js

@@ -1,13 +1,15 @@
+import { emitArraySearchHelpers } from "./array-search.js";
+import { emitStringInputs } from "./string-lifetimes.js";
 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 { CYC_BUF, CYC_HDR, FIRST_EMITTED_CYC_KIND, inlineAllocSupported } from "./alloc.js";
+import { hasLoneSurrogate, llvmBytes as llBytes, wtf8Bytes } from "../literals.js";
 import { InternalCompilerError } from "../../errors.js";
 import { createHash } from "node:crypto";
 import { endsWithJump, matchStringSelfConcat, streamTypedRefEligible, undefinedArmTag, } from "../../ir/analysis.js";
 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 { CAUGHT, ffiCallbackType, isDynTypedRefType, isFfiContextParam, isRefCounted, isUnitType, POINTER_KINDS, RUNTIME_EMITTER_CLASS, RUNTIME_EVENT_CLASS, RUNTIME_EVENT_TARGET_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, typeEquals, typeKey, STRING, VOID, } from "../../ir/ir.js";
 import { moduleRuntimeFeatures } from "../../ir/runtime-features.js";
 import { matchIntegerArrayForLoop, matchIntegerBytesForLoop, matchIntegerCountedForLoop, } from "../../ir/integer-loops.js";
 import { emitCountedLoopLimit } from "./counted-loops.js";
@@ -16,6 +18,7 @@ import { findBytesBounds } from "./bytes-bounds.js";
 import { emitByteWindowGuard, findInitializedByteLoopBindings, matchByteWindow, } from "./byte-windows.js";
 import { canDeferSplitPiece, emitSplitSpanNext, materializeSplitPiece, emitSplitCursor, emitSplitNext, emitSplitScratch, emitSplitSnapshot, findPrivateSplitLocals, loadSplitSnapshot, storeSplitSnapshot, stringSplit, } from "./split-loops.js";
 import { scalarizeNumericRecords } from "../../ir/scalar-records.js";
+import { RESULT_ENTRY_PREFIX, addRecordResultEntries } from "./record-results.js";
 import { specializeNumericCalls } from "../../ir/numeric-call-specialization.js";
 import { everyExpr, everyExprChild, everyStmtChild, everyStmtList } from "../../ir/traverse.js";
 import { analyzeIntegerRanges, INT32_RANGE } from "../../ir/integer-ranges.js";
@@ -24,7 +27,7 @@ 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 { findInt32Abis, INT32_ABI_SUFFIX, SCALAR_UNION_DUMMY, SCALAR_UNION_RESULT, } from "./int32-abi.js";
 import { findInt32Locals } from "./int32-locals.js";
 import { exactInteger, narrowInteger } from "./integer-values.js";
 import { findInitializerBindings, withInitializerBindings } from "../../ir/initializer-bindings.js";
@@ -35,9 +38,11 @@ import { computeMayThrow } from "../may-throw.js";
 import { mangleArgPack, mangleAsyncAdoptCall, mangleAsyncAwaitCall, mangleAsyncSpawn, mangleBorrowedFunction, mangleClassObj, mangleClassStruct, mangleFnClosure, mangleFunction, mangleGenDrop, mangleGenSpawn, mangleGlobal, mangleLocal, mangleRecordStruct, mangleTrampoline, mangleWrapper, mangleBorrowingWrapper, mangleVtInstance, } from "../mangle.js";
 import { analyzeCallLifetimes } from "./call-lifetimes.js";
 import { canStackUnion, emitStackUnion, findLocalStackUnions } from "./stack-unions.js";
-import { allocateLocalUnion, findLocalUnionStorage, storeLocalUnion, } from "./local-union-storage.js";
+import { emitStackObject, findLocalStackObjects, findReassignedStackObjects, stackObjectStruct, } from "./stack-objects.js";
+import { allocateLocalUnion, emitScalarOptional, findLocalUnionStorage, isScalarOptionalSource, storeLocalUnion, } from "./local-union-storage.js";
 import { BlockBuilder } from "./blocks.js";
 import { NullableRefFields } from "./nullable-fields.js";
+import { InlineUnionFields, loadInlineUnion, presentBits, stackUnionBox, storeInlineUnion, unionBoxBits, } from "./inline-unions.js";
 import { emitLocalArrayRead, emitProjectedArrayRead, emitBorrowedArrayRead, findLocalArrayReads, findCallArrayReads, OptionalArrayReads, } from "./local-array-reads.js";
 import { CheckedNarrows, emitCheckedNarrowReceiver } from "./checked-narrows.js";
 import { emitDenseArrayGet, emitDenseArraySet } from "./dense-array-access.js";
@@ -50,7 +55,8 @@ import { ReferenceEffects } from "./reference-effects.js";
 import { ReferenceWrites } from "./reference-writes.js";
 import { LlvmDebugInfo } from "./debug-info.js";
 import { StackCallbacks } from "./stack-callbacks.js";
-import { findLoopArrayBorrows } from "./loop-array-borrows.js";
+import { dynHoleRead, findLoopArrayBorrows } from "./loop-array-borrows.js";
+import { findAppendedArrayLiterals } from "./appended-array-literals.js";
 import { AmbientReceiverReaders, findConstantCallbacks } from "./constant-callbacks.js";
 import { findScalarStringSlices, emitStringSliceSnapshot, } from "./string-slices.js";
 import { LazyCaptures } from "./lazy-captures.js";
@@ -67,7 +73,7 @@ import { computeImmutableFields, stableGlobals } from "../immutability.js";
 import { computePublishedTypes } from "../publication.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 { streamDataAdapter, streamDoneFnFor, cryptoBytesThunkFor, cryptoIntThunkFor, 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";
 import { emitIntegerLoopIndex, emitBytesIndex, emitBytesData, emitBytesLength, emitBytesGet, emitToUint32, emitBytesSet, emitBytesIntrinsic, } from "./expr-bytes.js";
 import { emitRegexIntrinsic, emitRecordKeyGet, keyedRecordReadInto } from "./expr-records.js";
@@ -77,7 +83,8 @@ import { emitChildProcessLibCall, emitAsyncContextLibCall, emitProcessLibCall, e
 import { emitStreamLibCall } from "./lib-stream.js";
 import { emitNetworkHttpLibCall } from "./lib-network.js";
 import { emitAssertInspectLibCall, emitIoLibCall, emitGenericLibCall, emitLibCall, } from "./lib-dispatch.js";
-import { buildClassGraph, classMembershipIntervals, emitClassMembershipHelper, classEnvironmentIndex, classFieldIndex, classStructSym, } from "./classes.js";
+import { buildClassGraph, classMembershipIntervals, emitClassMembershipHelper, classEnvironmentIndex, classFieldIndex, classStructSym, programLifetimeClass, } from "./classes.js";
+import { LifetimeRegions, REGION_TYPES } from "./regions.js";
 import { LlDyn } from "./dyn.js";
 import { VirtualBorrows } from "./virtual-borrows.js";
 import { LlvmUnsupportedError } from "./unsupported.js";
@@ -85,10 +92,10 @@ import { LlWalkers } from "./walkers.js";
 import { isObjectArm, NULLABLE_ABSENT, NULLABLE_NULL, NullableUnions } from "./nullable-unions.js";
 import { emitNullablePresent, emitUnionPeek, emitUnionTag } from "./union-repr.js";
 import { literalCapWord, literalCapWord32 } from "./string-key-hash.js";
-import { NUMBER_MAP_ENTRY_DECL, STRING_MAP_ENTRY_DECL } from "./map-number-lookup.js";
-import { STRING_READ_HELPERS } from "./string-reads.js";
+import { MAP_ITER_DECL, NUMBER_MAP_ENTRY_DECL, STRING_MAP_ENTRY_DECL, } from "./map-number-lookup.js";
+import { STRING_READ_HELPERS, stringScanDecl } from "./string-reads.js";
 import { emitConcatInputs, emitMixedConcat, numberPart, stringParts, } from "./string-construction.js";
-import { arrNewCall, boxAccess, boxNewCall, boxReleaseSym, computeTraced, elemAccess, emitInlineRcHelpers, emitNullableRetainWrappers, FN_ATTRS, inlineRcDecls, llFieldType, releaseSym, retainSym, traceArg, typedRefConstructor, vAdapters, } from "./shapes.js";
+import { arrNewCall, boxAccess, boxNewCall, boxReleaseSym, computeTraced, elemAccess, emitInlineRcHelpers, emitNullableRetainWrappers, FN_ATTRS, inlineRcDecls, limitInlineDynReleases, 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) {
@@ -122,14 +129,14 @@ export function emitLlvmModule(input, options = {}) {
     const mod = unshareNodes(input);
     // Keep source storage intact for debugger inspection in dev builds.
     return new LlEmitter(options.debugSources === undefined
-        ? scalarizeNumericRecords(specializeNumericCalls(foldConstantGlobals(mod), mangleFunction))
+        ? addRecordResultEntries(scalarizeNumericRecords(specializeNumericCalls(foldConstantGlobals(mod), mangleFunction)))
         : mod, options).emit();
 }
 /** Keep large translation units below the host's single-string limit. */
 export function emitLlvmModuleSource(input, options = {}) {
     const mod = unshareNodes(input);
     const parts = new LlEmitter(options.debugSources === undefined
-        ? scalarizeNumericRecords(specializeNumericCalls(foldConstantGlobals(mod), mangleFunction))
+        ? addRecordResultEntries(scalarizeNumericRecords(specializeNumericCalls(foldConstantGlobals(mod), mangleFunction)))
         : mod, options).emitParts();
     const length = parts.reduce((total, part) => total + part.length, Math.max(0, parts.length - 1));
     if (length <= 256 * 1024 * 1024)
@@ -137,7 +144,7 @@ export function emitLlvmModuleSource(input, options = {}) {
     return parts.flatMap((part, index) => (index === 0 ? [part] : ["\n", part]));
 }
 function llStrBytes(text) {
-    return llBytes(Buffer.from(text, "utf8"));
+    return llBytes(wtf8Bytes(text));
 }
 const NO_BORROWED = new Set();
 /** Whether any node of `e` names the local (reads, writes, declarations,
@@ -181,6 +188,10 @@ export class LlEmitter {
     scalarStringSlices = new Map();
     stringSlices = new Map();
     localStackUnions = new Map();
+    localStackObjects = new Map();
+    reassignedStackObjects = new Set();
+    /** The binding slot of each reassigned stack-object local. */
+    stackObjectSlots = new Map();
     localUnionStorageProofs = new Map();
     localUnionStorage = new Map();
     integerArrayBindings = new Set();
@@ -203,6 +214,18 @@ export class LlEmitter {
         }
         this.fieldPointerTags.set(ptr, tag);
     }
+    /** The alias tag of a runtime word that emitted code reads and writes
+     * outside every field (the lifetime-region count, owner and cursors). */
+    memoryAliasAttachment(category) {
+        if (this.debug !== null)
+            return "";
+        let tag = this.fieldAliasTags.get(category);
+        if (tag === undefined) {
+            tag = 2 + this.fieldAliasTags.size * 2;
+            this.fieldAliasTags.set(category, tag);
+        }
+        return `, !tbaa !${tag}`;
+    }
     fieldAliasAttachment(ptr) {
         const tag = this.fieldPointerTags.get(ptr);
         return tag === undefined ? "" : `, !tbaa !${tag}`;
@@ -217,10 +240,12 @@ export class LlEmitter {
         return lines;
     }
     debug;
+    /** Projection-only scalar objects may live in frame storage (stack-objects.ts). */
+    stackObjects;
     debugScope = null;
     sizeType;
     ffiExtendNarrowIntegers;
-    cycleBufferedOffset;
+    cycleBufOffset;
     /** Emitted ScrCycType descriptors so far (their collector statistics
      * indices; see ShapeHost.nextCycKind). */
     cycKinds = 0;
@@ -264,6 +289,8 @@ export class LlEmitter {
     unitInstances = new Map();
     /** unionId → symbol of the union's immortal ABSENT field-slot instance. */
     absentInstances = new Map();
+    /** The zeroed box an inline store reads for a NULL union dummy. */
+    needsUnionNone = false;
     /** 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. */
@@ -306,7 +333,11 @@ export class LlEmitter {
     /** Inline RC fast-path helpers requested by call sites (shapes.ts); null
      * when inline RC is off. */
     rcHelpers;
+    rcMode;
+    rcHelpersNoinline;
     fnByName = new Map();
+    /** Empty literals that construct with inline slots (appended-array-literals.ts). */
+    appendedArrayLiterals = new Set();
     /** Emitted LLVM text of every IR function body, by function name: the
      * fiberless-async analysis scans it for suspension entry points. */
     fnDefText = new Map();
@@ -318,6 +349,8 @@ export class LlEmitter {
      * whose bindings end with the list (emitBlock and function bodies). */
     stmtCursor = null;
     optionalArrayReads;
+    /** Union sources a binding or projection can hold in a stack box. */
+    unionSources;
     checkedNarrows;
     callArrayReads = new Map();
     mapReadLifetimes = { locals: new Map(), arguments: new Map() };
@@ -413,6 +446,10 @@ export class LlEmitter {
      * typeKey → thunk symbol. */
     resolveThunks = new Map();
     resolveThunkDefs = [];
+    /** Inline array searches used by the module (array-search.ts). */
+    arraySearchKinds = new Set();
+    /** Typed-ref recipe constants by type key (lazy receivers). */
+    typedRefRecipes = new Map();
     /** ReadableStream.from adapters keep typed arrays by reference and box
      * one current element per pull. */
     streamFromArrayAdapters = new Map();
@@ -424,6 +461,7 @@ export class LlEmitter {
     dynPromiseAdapters = new Map();
     unionsById = new Map();
     nullableFields;
+    inlineUnions;
     /** Unions whose values are nullable arm pointers (nullable-unions.ts). */
     nullableUnions;
     /** The union table without nullable unions: the stack-box analyses. */
@@ -530,6 +568,9 @@ export class LlEmitter {
     currentReturnType = VOID;
     /** The current body returns its number result as i32. */
     currentInt32Result = false;
+    /** The function's i32 entry returns its scalar union result as tag and
+     * payload bits (Int32Abi.union). */
+    currentUnionResult = false;
     /** Active only while emitting a body lowered with LLVM's
      * switched-coroutine intrinsics (wasm32 async bodies and generators,
      * native synchronous generators; see coroLowered). */
@@ -538,6 +579,8 @@ export class LlEmitter {
      * generator bodies): yieldExpr emission reads them, and emitTryCatch's
      * catch prologue emits the GENRET sentinel re-unwind exactly here. */
     currentGenerator = null;
+    /** The function being emitted is an async generator body. */
+    currentAsyncGenerator = false;
     /** Active optional-chain bind slots, by chain id (chainRecv reads). */
     chainSlots = new Map();
     logArgSlots = 0;
@@ -565,6 +608,7 @@ export class LlEmitter {
             options.wasi === true || ffiExtendsNarrowIntegers(options.targetTriple);
         this.wasi = options.wasi === true;
         this.stacklessGenerators = !this.wasi && mod.workers !== true && this.debug === null;
+        this.stackObjects = this.debug === null;
         // An empty triple targets the host, as for executableTls below: the
         // Node-hosted CLI passes none, the native CLI passes its toolchain's, and
         // both must emit the same module for the same target.
@@ -590,16 +634,17 @@ export class LlEmitter {
         this.emitLibraryIdentity = options.emitLibraryIdentity !== false;
         this.runtimeAbiMarker = options.runtimeAbiMarker === true;
         this.detachedExit = options.detachedExit === true;
-        this.rcHelpers = options.inlineRc === true ? new Set() : null;
-        // ScrCycHdr.buffered sits 6 bytes behind every object. The wasm32
-        // header pads before its descriptor so its payload remains
-        // double-aligned without changing this ABI offset.
-        this.cycleBufferedOffset = 6;
+        this.rcHelpers = options.inlineRc !== undefined ? new Set() : null;
+        this.rcMode = options.inlineRc;
+        this.rcHelpersNoinline = options.rcHelpersNoinline === true;
+        // ScrCycHdr.buf sits 4 bytes behind every object on every target.
+        this.cycleBufOffset = CYC_HDR - CYC_BUF;
         this.ffiCallbackAdapters = allocateFfiCallbackAdapters(mod.ffiImports ?? []);
         this.ffiHasRetainedCallback = hasRetainedFfiCallback(mod.ffiImports ?? []);
         this.ffiHasForeignCallback = hasForeignFfiCallback(mod.ffiImports ?? []);
         for (const fn of mod.functions)
             this.fnByName.set(fn.name, fn);
+        this.appendedArrayLiterals = findAppendedArrayLiterals(mod);
         for (const entry of mod.ffiImports ?? []) {
             this.ffiByName.set(entry.name, entry);
         }
@@ -629,10 +674,21 @@ export class LlEmitter {
         this.immortalValues.add("null");
         this.immortalValues.add(NULLABLE_NULL);
         this.nullableFields = new NullableRefFields(mod.classes ?? [], this.boxedUnionsById);
+        this.inlineUnions = new InlineUnionFields(this.boxedUnionsById, mod.classes ?? []);
+        for (const r of mod.records ?? [])
+            this.recordsById.set(r.id, r);
         // Optional array reads also cover nullable unions: emitLocalArrayRead
         // then yields the (borrowed or owned) element pointer, not a stack box.
         // Arrays of such a union are read the same way.
         this.optionalArrayReads = new OptionalArrayReads(this.fnByName, this.unionsById, (id) => this.nullableUnions.has(id));
+        this.unionSources = {
+            unions: this.boxedUnionsById,
+            receiverUnions: this.unionsById,
+            nullableField: (e) => this.nullableFieldGet(e) !== null,
+            inlineField: (e) => this.inlineFieldGet(e),
+            arrayRead: (e) => this.optionalArrayReads.get(e) !== null,
+            scalarCall: (e) => this.scalarResultCall(e),
+        };
         this.checkedNarrows = new CheckedNarrows(this.fnByName);
         this.referenceEffects = new ReferenceEffects(this.fnByName, (call) => this.optionalArrayReads.get(call) !== null, mod.classes ?? []);
         if (this.debug === null)
@@ -678,23 +734,26 @@ export class LlEmitter {
                 walkParameters.set(fn.name, indexes);
             }
         }
-        this.callLifetimes = analyzeCallLifetimes(this.fnByName, (className, field) => this.nullableFields.get(className, field) !== null, walkParameters);
+        this.callLifetimes = analyzeCallLifetimes(this.fnByName, (className, field) => this.nullableFields.get(className, field) !== null, walkParameters, new Set([...this.int32Abis].filter(([, abi]) => abi.union).map(([name]) => name)), {
+            record: (shapeId, field) => this.recordFieldInline(shapeId, field),
+            classField: (className, field) => this.inlineUnions.classField(className, field),
+        });
         this.constantCallbacks = findConstantCallbacks(mod, this.callLifetimes);
         this.stackCallbacks = new StackCallbacks(this.fnByName);
         this.receiverReaders = new AmbientReceiverReaders(this.fnByName);
         this.stackCaptures = new StackCaptures(this.fnByName, this.callLifetimes, this.stackCallbacks);
         this.lazyCaptures = new LazyCaptures(this.fnByName);
-        for (const r of mod.records ?? [])
-            this.recordsById.set(r.id, r);
         const traced = computeTraced(mod);
         this.tracedShapes = traced.shapes;
         this.tracedUnions = traced.unions;
         this.shapeHost = {
             sizeType: this.sizeType,
-            cycleBufferedOffset: this.cycleBufferedOffset,
+            cycleBufOffset: this.cycleBufOffset,
             tracedShapes: this.tracedShapes,
             tracedUnions: this.tracedUnions,
             nullableUnions: this.nullableUnions,
+            inlineUnions: this.inlineUnions,
+            unionNoneRef: () => this.unionNoneRef(),
             recordsById: this.recordsById,
             recordCloneShapes: this.recordCloneShapes,
             objectAudit: options.objectAudit !== false,
@@ -708,6 +767,8 @@ export class LlEmitter {
             // paths address its thread-local state.
             threadLocalAlloc: mod.workers === true,
             rcHelpers: this.rcHelpers,
+            ...(this.rcMode !== undefined ? { rcMode: this.rcMode } : {}),
+            ...(this.rcHelpersNoinline ? { rcHelpersNoinline: true } : {}),
             nextCycKind: () => FIRST_EMITTED_CYC_KIND + this.cycKinds++,
             unionsById: this.unionsById,
             declare: (decl) => this.declare(decl),
@@ -723,6 +784,7 @@ export class LlEmitter {
             liveDynUnionRefAdapter: (type) => this.liveDynUnionRefAdapter(type),
             dynPromiseAdapter: (type) => this.dynPromiseAdapter(type),
             isErrorClass: (name) => this.classMeta.get(name)?.root.def.name === "%Error",
+            classRootOf: (name) => this.classMeta.get(name)?.root.def.name,
             classSubtypes: (name) => {
                 const target = this.classMetaOf(name);
                 const intervals = classMembershipIntervals(this.classMeta, target.def.name);
@@ -733,6 +795,7 @@ export class LlEmitter {
             pendingTestLines: (dest) => this.pendingTestLines(dest),
             virtualEntry: (implFn) => this.virtualEntry(implFn),
             programLifetime: this.programLifetime,
+            regionAliasTag: (word) => this.memoryAliasAttachment(`region.${word}`),
         };
         this.walkers = new LlWalkers(this.shapeHost);
         this.dyn = new LlDyn(this.shapeHost);
@@ -755,13 +818,16 @@ export class LlEmitter {
                 this.tdzGlobals.set(g.id, g.name);
         }
         this.stableGlobals = stableGlobals(mod);
-        // Runtime error, EventEmitter, and stream classes have known layouts.
-        // Subclasses embed the ScrEmitter/ScrStream prefixes from classes.ts.
+        // Runtime error, EventEmitter, stream, EventTarget and Event classes
+        // have known layouts. Subclasses embed the runtime prefixes from
+        // classes.ts.
         const classes = mod.classes ?? [];
         for (const cls of classes) {
             if (cls.runtime &&
                 !RUNTIME_ERROR_CLASSES.has(cls.name) &&
                 cls.name !== RUNTIME_EMITTER_CLASS &&
+                cls.name !== RUNTIME_EVENT_TARGET_CLASS &&
+                cls.name !== RUNTIME_EVENT_CLASS &&
                 !RUNTIME_STREAM_CLASSES.has(cls.name)) {
                 throw new LlvmUnsupportedError(`classDef:${cls.name}`, cls.loc);
             }
@@ -770,6 +836,17 @@ export class LlEmitter {
         // whole-program preorder numbering for instanceof over runtime and
         // compiled error objects, and the per-hierarchy virtual slot lists.
         this.classMeta = buildClassGraph(mod, this.fnByName);
+        if (mod.lifetimeRegions === true) {
+            this.regions = new LifetimeRegions(this.shapeHost, mod, this.classMeta, (meta) => programLifetimeClass(this.shapeHost, meta), this.nullableFields);
+            const regions = this.regions;
+            // Member names differ from LifetimeRegions' own, which keeps the
+            // record from reading as that class's protocol.
+            this.shapeHost.regions = {
+                rcBody: (fnName, ret, comment) => regions.countBody(fnName, ret, comment),
+                newAlloc: (className, sizeOf) => regions.allocLines(className, sizeOf),
+                classDefinitions: (cls, sizeOf) => regions.classDefs(cls, sizeOf),
+            };
+        }
         for (const [name, rec] of RUNTIME_ERROR_CLASSES) {
             const meta = this.classMeta.get(name);
             if (!meta)
@@ -1110,7 +1187,7 @@ export class LlEmitter {
         return this.emitParts().join("\n");
     }
     emitParts() {
-        const parts = this.emitModuleParts();
+        const parts = limitInlineDynReleases(this.emitModuleParts());
         if (!this.executableTls)
             return parts;
         // A worker executable's thread-locals all live in the executable's own
@@ -1163,7 +1240,7 @@ export class LlEmitter {
         // 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
-        // absorb the duplicates silently, LLVM rejects redefinition, so the
+        // accept the duplicates without an error, LLVM rejects redefinition, so the
         // storage AND the release emit once per id here.
         const seenGlobalIds = new Set();
         const globals = (this.mod.globals ?? []).filter((g) => {
@@ -1399,9 +1476,11 @@ export class LlEmitter {
         // write/abort declarations).
         const helpers = [
             ...this.helperDefs(),
+            ...emitArraySearchHelpers(this.arraySearchKinds, this.sizeType, (line) => this.declare(line)),
             ...emitClassMembershipHelper(this.classMeta, this.sizeType),
             ...(this.publishWalkersCache?.defs() ?? []),
             ...this.publishedClassNamesDefs(),
+            ...(this.regions?.moduleDefs() ?? []),
         ];
         if (this.constantNumericTables.size > 0)
             this.declare(`declare double @scr_arr_get_number(ptr, double)`);
@@ -1447,17 +1526,22 @@ 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): 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)
+            // inline number-key lookup (sc_map_entry_f64) and the inline
+            // iteration steps (sc_map_iter_entry): field 9 is the entry count,
+            // field 11 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) ||
+                this.decls.has(MAP_ITER_DECL)
                 ? [
                     `%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
             // scr_map_entry_str returns (map-number-lookup.ts).
-            ...(this.decls.has(NUMBER_MAP_ENTRY_DECL) || this.decls.has(STRING_MAP_ENTRY_DECL)
+            ...(this.decls.has(NUMBER_MAP_ENTRY_DECL) ||
+                this.decls.has(STRING_MAP_ENTRY_DECL) ||
+                this.decls.has(MAP_ITER_DECL)
                 ? [`%ScrMapEntry = type { i64, i64, i64 }`]
                 : []),
             // The runtime error prefix { rc, vt, name, message, code, cause } and the
@@ -1471,6 +1555,13 @@ export class LlEmitter {
             // The runtime stream layout { rc, vt, reg, cls, st } — one struct
             // for all five stream classes; stream subclasses embed it.
             `%ScrStream = type { ${this.sizeType}, ptr, ptr, ptr, ptr }`,
+            // The EventTarget and Event subclass prefixes { rc, vt, state, cls }.
+            ...(this.classMeta.has(RUNTIME_EVENT_TARGET_CLASS)
+                ? [`%ScrEventTargetObj = type { ${this.sizeType}, ptr, ptr, ptr }`]
+                : []),
+            ...(this.classMeta.has(RUNTIME_EVENT_CLASS)
+                ? [`%ScrEventObj = type { ${this.sizeType}, ptr, ptr, ptr }`]
+                : []),
             // The catch-binding snapshot box { rc, kind, f64, b, payload,
             // retain_fn, release_fn, trace_fn } — caughtTest kind reads and
             // caughtNarrow payload extraction GEP through it (offsets match
@@ -1529,8 +1620,8 @@ export class LlEmitter {
             // half carries the precomputed Map key hash (SCR_STR_HASH_CACHE).
             // Bit 31 marks all-ASCII literals (SCR_STR_ASCII_BIT) on every target.
             const capWord = this.sizeType === "i64"
-                ? literalCapWord(Buffer.from(text, "utf8"))
-                : literalCapWord32(Buffer.from(text, "utf8"));
+                ? literalCapWord(wtf8Bytes(text))
+                : literalCapWord32(wtf8Bytes(text));
             out.push(`@${lit.sym} = internal global { ${this.sizeType}, ${this.sizeType}, ${this.sizeType}, [${lit.len + 1} x i8] } ` +
                 `{ ${this.sizeType} -1, ${this.sizeType} ${lit.len}, ${this.sizeType} ${capWord}, [${lit.len + 1} x i8] c"${llStrBytes(text)}" }`);
         }
@@ -1583,6 +1674,8 @@ export class LlEmitter {
         }
         if (this.absentInstances.size > 0)
             out.push(``);
+        if (this.needsUnionNone)
+            out.push(`@sc_union_none = internal constant %ScrUnion zeroinitializer ; NULL union dummy read by inline stores`, ``);
         if (this.nullableUnions.usesNullSentinel) {
             // `null` in every `C | null | undefined` union (NULL is undefined):
             // one module-scope immortal object like the ABSENT sentinel.
@@ -1693,6 +1786,12 @@ export class LlEmitter {
         }
         if (this.streamIntervals.length > 0)
             out.push(``);
+        if ([...this.literals.keys(), ...this.cstrs.keys()].some(hasLoneSurrogate)) {
+            // The runtime skips surrogate work until a lone surrogate may exist
+            // (scr_wtf8_any); its own producers note one, and literals do here.
+            out.push(`declare void @scr_wtf8_note()`, ``);
+            stamps.push(`  call void @scr_wtf8_note()`);
+        }
         if (this.errorIntervals.length > 0 && this.tracedShapes.has("object:%Error")) {
             // The cycle fixpoint marked the Error hierarchy (a user subclass
             // holds cycle-capable fields — capability is hierarchy-uniform), so
@@ -1991,7 +2090,7 @@ export class LlEmitter {
                     case "i64":
                         // Inbound declared-integer edge (ask 4): the helper converts
                         // exactly or delivers the host-contract trap (past ±(2^53−1)
-                        // the value cannot ride f64 without silent rounding).
+                        // the value cannot ride f64 without rounding).
                         params.push(`i64 %a${i}`);
                         body.push(`  %c${i} = call double @scr_library_i64_in(i64 %a${i}, ptr @sc_lib_int_trap_${e.symbol})`);
                         args.push(`double %c${i}`);
@@ -2099,6 +2198,15 @@ export class LlEmitter {
                 ? `  %i = add i64 ${mapIndex.wide}, 0`
                 : `  %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`, `}`, ``);
         }
+        // Map/Set iteration steps read the entries array inline: an index is
+        // live when it is below the entry count and its entry's cached hash is
+        // nonzero (a tombstone's is zero), as scr_map_iter_live decides. The
+        // entry count is read again at every step, so entries appended during
+        // the iteration are visited.
+        if (this.decls.has(MAP_ITER_DECL)) {
+            const sz = this.sizeType;
+            defs.push(`define internal ptr @sc_map_iter_entry(ptr %m, double %i) ${FN_ATTRS} {`, `entry:`, `  %np = getelementptr inbounds %ScrMapIx, ptr %m, i32 0, i32 9`, `  %n = load ${sz}, ptr %np`, `  %nf = uitofp ${sz} %n to double`, `  %lo = fcmp oge double %i, 0.0`, `  %hi = fcmp olt double %i, %nf`, `  %in = and i1 %lo, %hi`, `  br i1 %in, label %load, label %none`, `load:`, `  %ix = fptoui double %i to ${sz}`, `  %ep = getelementptr inbounds %ScrMapIx, ptr %m, i32 0, i32 13`, `  %entries = load ptr, ptr %ep`, `  %e = getelementptr inbounds %ScrMapEntry, ptr %entries, ${sz} %ix`, `  %hp = getelementptr inbounds %ScrMapEntry, ptr %e, i32 0, i32 2`, `  %h = load i64, ptr %hp`, `  %live = icmp ne i64 %h, 0`, `  br i1 %live, label %yes, label %none`, `yes:`, `  ret ptr %e`, `none:`, `  ret ptr null`, `}`, ``, `define internal double @sc_map_iter_count(ptr %m) ${FN_ATTRS} {`, `entry:`, `  %np = getelementptr inbounds %ScrMapIx, ptr %m, i32 0, i32 9`, `  %n = load ${sz}, ptr %np`, `  %nf = uitofp ${sz} %n to double`, `  ret double %nf`, `}`, ``);
+        }
         // 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
@@ -2140,16 +2248,24 @@ export class LlEmitter {
             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), ``);
+            defs.push(...literalEqualityDefinition(name, wtf8Bytes(text), this.internLiteral(text), this.sizeType, FN_ATTRS), ``);
         }
         // String length and charCodeAt read proven-ASCII strings inline: bit 31
         // of the capacity word (SCR_STR_ASCII_BIT, the low half's sign bit on
         // little-endian targets) makes UTF-16 units bytes. Unproven strings and
         // anything but an in-range index take the runtime's UTF-16 mapping.
+        // A scan's receiver reads inline too where runtime state is ordinary
+        // global storage (ScrStrScan; SCR_TL makes it thread-local otherwise).
+        const scanInline = this.mod.workers !== true && this.mod.lib?.threadInstances !== true;
+        let scanDeclared = false;
         for (const helper of STRING_READ_HELPERS) {
             if (!this.decls.has(helper.decl))
                 continue;
-            defs.push(...helper.define(this.sizeType, FN_ATTRS), ``);
+            if (scanInline && !scanDeclared) {
+                defs.push(stringScanDecl(this.sizeType), ``);
+                scanDeclared = true;
+            }
+            defs.push(...helper.define(this.sizeType, FN_ATTRS, scanInline), ``);
         }
         // Ordering also decides inline when the first bytes differ: byte order
         // is the plain comparison's order, and the UTF-16 order whenever both
@@ -2331,7 +2447,7 @@ export class LlEmitter {
      * programs keep fibers too: their fiber epilogue owns context
      * termination (a stopping worker rejects and observes the promise), which
      * the fiberless wrapper does not reproduce. A missed suspension still
-     * cannot reorder silently: the runtime traps when a context parks while a
+     * cannot reorder execution undetected: the runtime traps when a context parks while a
      * fiberless body is on its stack. */
     fiberlessAsyncFunctions() {
         const eligible = new Set();
@@ -2983,8 +3099,13 @@ export class LlEmitter {
      * holding the ABSENT state surfaces as the ordinary undefined arm, so
      * absence never travels beyond its slot (a later `{ f: r.f }` is an
      * explicit, present property). */
-    loadRecordField(ptr, t) {
-        const v = this.loadField(ptr, t);
+    loadRecordField(ptr, t, inline) {
+        if (inline) {
+            const { tag, bits } = loadInlineUnion(this.B, ptr);
+            const present = presentBits(this.B, tag, bits, undefinedArmTag(t, this.unionsById));
+            return stackUnionBox(this.B, this.sizeType, tag, present);
+        }
+        const v = this.loadField(ptr, t, false);
         if (t.kind !== "union" || undefinedArmTag(t, this.unionsById) < 0)
             return v;
         const absent = this.fieldAbsentTest(v, t.unionId);
@@ -3197,11 +3318,13 @@ export class LlEmitter {
                     ? "ret void"
                     : this.currentInt32Result
                         ? "ret i32 0"
-                        : t === "double"
-                            ? `ret double ${f64Lit(0)}`
-                            : t === "i1"
-                                ? "ret i1 false"
-                                : "ret ptr null";
+                        : this.currentUnionResult
+                            ? `ret ${SCALAR_UNION_DUMMY}`
+                            : t === "double"
+                                ? `ret double ${f64Lit(0)}`
+                                : t === "i1"
+                                    ? "ret i1 false"
+                                    : "ret ptr null";
         }
         // Copy the entries now: later declarations extend these lexical scopes.
         // Release order and the handler are part of the shared block's identity.
@@ -3644,6 +3767,7 @@ export class LlEmitter {
             case "searchParams":
             case "stats":
             case "fileHandle":
+            case "dir":
             case "spawnRes":
             case "child":
             case "childStream":
@@ -3686,7 +3810,7 @@ export class LlEmitter {
     }
     /** Guard for helpers that build or read a union's `%ScrUnion` box
      * directly (library-shaped unions with fixed arms): a nullable union
-     * reaching one is an emitter bug, never a silent miscompile. */
+     * reaching one is an emitter bug and throws InternalCompilerError. */
     requireBoxedUnion(unionId) {
         if (this.nullableUnions.has(unionId))
             throw new InternalCompilerError(`llvm emitter bug: nullable union ${unionId} reached a tagged-box helper`);
@@ -3819,7 +3943,7 @@ export class LlEmitter {
         const p = this.B.tmp();
         this.B.line(`${p} = getelementptr inbounds %${classStructSym(className)}, ptr ${objName}, i64 0, i32 ${index}`);
         this.markFieldPointer(p, field);
-        return { ptr: p, type };
+        return { ptr: p, type, inline: this.inlineUnions.classField(className, field) };
     }
     /** `o->vt->pre` — the dynamic class's preorder number (borrowed object;
      * the static class names which struct spelling carries the vt word). */
@@ -3870,8 +3994,10 @@ export class LlEmitter {
                 if (index < 0)
                     throw new InternalCompilerError(`llvm emitter bug: missing union field ${field}`);
                 layout = "record:";
-                for (let i = 0; i <= index; i++)
-                    layout += `${llFieldType(shape.fields[i].type)};`;
+                for (let i = 0; i <= index; i++) {
+                    const type = shape.fields[i].type;
+                    layout += `${llFieldType(type, this.inlineUnions.record(type))};`;
+                }
             }
             const group = groups.get(layout);
             if (group)
@@ -3883,7 +4009,13 @@ export class LlEmitter {
         this.unionFieldReadGroups.set(key, result);
         return result;
     }
-    /** The field-slot pointer of a record member (rc header at index 0). */
+    /** The zeroed `%ScrUnion` constant (inline-unions.ts unionBoxBits). */
+    unionNoneRef() {
+        this.needsUnionNone = true;
+        return "@sc_union_none";
+    }
+    /** The field-slot pointer of a record member (rc header at index 0).
+     * `inline`: the slot stores a scalar union's tag and bits. */
     recordFieldPtr(objName, shapeId, field) {
         const shape = this.recordShape(shapeId);
         const idx = shape.fields.findIndex((f) => f.name === field);
@@ -3891,7 +4023,8 @@ export class LlEmitter {
             throw new InternalCompilerError(`llvm emitter bug: unknown field ${field} on shape ${shapeId}`);
         const p = this.B.tmp();
         this.B.line(`${p} = getelementptr inbounds %${mangleRecordStruct(shapeId)}, ptr ${objName}, i64 0, i32 ${idx + 1}`);
-        return { ptr: p, type: shape.fields[idx].type };
+        const type = shape.fields[idx].type;
+        return { ptr: p, type, inline: this.inlineUnions.record(type) };
     }
     /** The overflow map's slot pointer on an index-signature shape. */
     recordOvfPtr(objName, shapeId) {
@@ -3904,10 +4037,16 @@ export class LlEmitter {
         this.B.line(`${v} = load ptr, ptr ${p}`);
         return v;
     }
-    /** Loads a record field (i8-stored bools trunc to i1). */
-    loadField(ptr, t) {
+    /** Loads a record field (i8-stored bools trunc to i1). An inline union
+     * field answers a private stack box with the slot's own bits, ABSENT
+     * included: it may only be borrowed. */
+    loadField(ptr, t, inline) {
         const B = this.B;
-        const fieldTy = llFieldType(t);
+        if (inline) {
+            const { tag, bits } = loadInlineUnion(B, ptr);
+            return stackUnionBox(B, this.sizeType, tag, bits);
+        }
+        const fieldTy = llFieldType(t, false);
         const raw = B.tmp();
         B.line(`${raw} = load ${fieldTy}, ptr ${ptr}${this.fieldAliasAttachment(ptr)}`);
         if (fieldTy !== "i8")
@@ -3916,10 +4055,46 @@ export class LlEmitter {
         B.line(`${b} = trunc i8 ${raw} to i1`);
         return b;
     }
-    /** Stores a record field (i1 zext to the i8 storage). */
-    storeField(ptr, t, value) {
+    /** A record field of this shape stores its scalar union inline. */
+    recordFieldInline(shapeId, field) {
+        const type = this.recordShape(shapeId).fields.find((f) => f.name === field)?.type;
+        return type !== undefined && this.inlineUnions.record(type);
+    }
+    /** The value a field store writes: an inline union slot copies the tag
+     * and bits of a borrowed projection, so no box is built for it. */
+    emitFieldValue(value, inline) {
+        return inline ? this.emitUnionProjection(value) : this.emitExpr(value);
+    }
+    /** Overwrites a field with `v` (from emitFieldValue). A reference moves
+     * in, and the old value is released AFTER the field is overwritten. */
+    replaceField(ptr, type, inline, v) {
+        if (!inline && isRefCounted(type)) {
+            this.moveTemp(v);
+            const old = this.B.tmp();
+            this.B.line(`${old} = load ptr, ptr ${ptr}`);
+            this.storeField(ptr, type, v.name, false);
+            this.releaseValue(old, type);
+            return;
+        }
+        this.storeField(ptr, type, v.name, inline);
+    }
+    /** Stores `v` (from emitFieldValue) into a fresh field slot. */
+    initField(ptr, type, inline, v) {
+        if (!inline && isRefCounted(type))
+            this.moveTemp(v);
+        this.storeField(ptr, type, v.name, inline);
+    }
+    /** Stores a record field (i1 zext to the i8 storage). An inline union
+     * field copies the tag and bits of the union value, which its owner
+     * keeps. */
+    storeField(ptr, t, value, inline) {
         const B = this.B;
-        const fieldTy = llFieldType(t);
+        if (inline) {
+            const { tag, bits } = unionBoxBits(B, value, this.unionNoneRef());
+            storeInlineUnion(B, ptr, tag, bits);
+            return;
+        }
+        const fieldTy = llFieldType(t, false);
         if (fieldTy !== "i8") {
             B.line(`store ${fieldTy} ${value}, ptr ${ptr}${this.fieldAliasAttachment(ptr)}`);
             return;
@@ -4389,7 +4564,7 @@ export class LlEmitter {
         this.integerArrayBindings.clear();
         this.loopArrayBorrows =
             this.debug === null
-                ? findLoopArrayBorrows(fn, this.callLifetimes, this.referenceEffects, this.optionalArrayReads, this.referenceWrites)
+                ? findLoopArrayBorrows(fn, this.callLifetimes, this.referenceEffects, this.optionalArrayReads, this.referenceWrites, this.fnByName)
                 : new Set();
         this.localArrayReads = findLocalArrayReads(fn, this.fnByName, this.unionsById, this.referenceEffects.functions, this.callLifetimes, this.optionalArrayReads, this.loopArrayBorrows, this.debug === null ? this.referenceEffects : undefined);
         this.callArrayReads = findCallArrayReads(fn, this.optionalArrayReads, this.referenceEffects.functions, this.callLifetimes, this.debug === null ? this.referenceEffects : undefined);
@@ -4397,7 +4572,14 @@ export class LlEmitter {
             this.debug === null ? findScalarStringSlices(fn, this.callLifetimes) : new Map();
         this.mapReadLifetimes = findMapReadLifetimes(fn, this.boxedUnionsById, this.callLifetimes);
         this.localStackUnions = findLocalStackUnions(fn, this.callLifetimes, this.boxedUnionsById);
-        this.localUnionStorageProofs = findLocalUnionStorage(fn, this.callLifetimes, this.boxedUnionsById, (e) => this.nullableFieldGet(e) !== null);
+        this.localStackObjects = this.stackObjects
+            ? findLocalStackObjects(this, fn, this.callLifetimes)
+            : new Map();
+        this.reassignedStackObjects = this.stackObjects
+            ? findReassignedStackObjects(this, fn, this.callLifetimes)
+            : new Set();
+        this.stackObjectSlots = new Map();
+        this.localUnionStorageProofs = findLocalUnionStorage(fn, this.callLifetimes, this.unionSources);
         this.localUnionStorage = new Map();
         this.walkBorrows = this.walkBorrowsByFunction.get(fn.name) ?? new Set();
         this.integerRanges = analyzeIntegerRanges(numericFn, this.int32Slots.facts(fn.name));
@@ -4417,7 +4599,9 @@ export class LlEmitter {
         this.currentReturnType = fn.returnType;
         const int32Abi = this.int32Abis.get(fn.name);
         this.currentInt32Result = int32Abi?.result === true;
+        this.currentUnionResult = int32Abi?.union === true;
         this.currentGenerator = fn.generator ?? null;
+        this.currentAsyncGenerator = fn.async === true && fn.generator !== undefined;
         this.currentBorrowedReturn = this.borrowedReturns.has(fn.name);
         this.inConstructor = this.constructorFunctions.has(fn.name);
         this.currentCoro = null;
@@ -4604,6 +4788,9 @@ export class LlEmitter {
         // whose unwind released everything down to depth 0).
         if (fn.returnType.kind === "void" && !B.isTerminated()) {
             this.releaseScope(this.scopes[0]);
+            // Completing by falling off the end has nothing to await.
+            if (this.currentAsyncGenerator)
+                this.emitAsyncGenSettled();
             if (this.currentCoro !== null) {
                 this.emitWasiFulfill(null);
                 B.terminate(`br label %${this.currentCoro.finalLabel}`);
@@ -4681,7 +4868,11 @@ export class LlEmitter {
         // Lifted functions receive their closure first (the callValue ABI).
         if (fn.captures !== undefined)
             params.unshift("ptr %sc_env");
-        const ret = int32Abi?.result ? "i32" : this.llType(fn.returnType);
+        const ret = int32Abi?.result
+            ? "i32"
+            : int32Abi?.union
+                ? SCALAR_UNION_RESULT
+                : this.llType(fn.returnType);
         let attrs = coro !== null ? "#1" : FN_ATTRS;
         // The shared indexed-read helper (lowerSafeIndexRead) is a dense bounds
         // test, a state test and a load behind cold runtime fallbacks, called
@@ -4690,6 +4881,15 @@ export class LlEmitter {
         // a call, and an integer index converts to a double and back across it.
         if (fn.name.startsWith("%arr.idxOr."))
             attrs = `inlinehint ${attrs}`;
+        // Interface dispatch is a few key tests and direct calls ahead of the
+        // checked dynamic call. Keeping that fallback out of line leaves the
+        // tests small enough to inline at each call site.
+        if (fn.name.startsWith("%dyn.class.protocol.fallback."))
+            attrs = `noinline ${attrs}`;
+        else if (fn.name.startsWith("%dyn.class.protocol."))
+            attrs = `inlinehint ${attrs}`;
+        if (fn.name.startsWith(RESULT_ENTRY_PREFIX))
+            attrs = `inlinehint ${attrs}`;
         const debug = this.debugScope === null ? "" : ` !dbg ${this.debugScope}`;
         const symbol = borrowed ? mangleBorrowedFunction(fn.name) : mangleFunction(fn.name);
         let body = `define internal ${ret} @${symbol}${int32Abi ? INT32_ABI_SUFFIX : ""}(${params.join(", ")}) ${attrs}${debug} { ; ${fn.name}\n${B.render()}\n}`;
@@ -4721,7 +4921,19 @@ export class LlEmitter {
                 args.push(`${type} %p${index}`);
         });
         const ret = this.llType(fn.returnType);
-        const call = `call ${abi.result ? "i32" : ret} @${symbol}${INT32_ABI_SUFFIX}(${args.join(", ")})`;
+        const entry = `@${symbol}${INT32_ABI_SUFFIX}(${args.join(", ")})`;
+        if (abi.union) {
+            // Box the register pair for every caller of the ordinary ABI.
+            const B = new BlockBuilder();
+            this.B = B;
+            for (const line of lines)
+                B.line(line.trim());
+            const pair = B.tmp();
+            B.line(`${pair} = call ${SCALAR_UNION_RESULT} ${entry}`);
+            B.terminate(`ret ptr ${this.boxScalarUnion(pair, fn.returnType)}`);
+            return `define internal ptr @${symbol}(${params.join(", ")}) ${FN_ATTRS} {\n${B.render()}\n}`;
+        }
+        const call = `call ${abi.result ? "i32" : ret} ${entry}`;
         if (ret === "void")
             lines.push(`  ${call}`, "  ret void");
         else if (abi.result)
@@ -4730,6 +4942,85 @@ export class LlEmitter {
             lines.push(`  %r = ${call}`, `  ret ${ret} %r`);
         return `define internal ${ret} @${symbol}(${params.join(", ")}) ${FN_ATTRS} {\nentry:\n${lines.join("\n")}\n}`;
     }
+    /** The SCALAR_UNION_RESULT pair of a `%ScrUnion` box of `type`. */
+    scalarUnionPair(box, type) {
+        const B = this.B;
+        const unionId = type.kind === "union" ? type.unionId : "";
+        const tag = this.unionTag(box, unionId);
+        const payload = B.tmp(), bits = B.tmp(), partial = B.tmp(), pair = B.tmp();
+        B.line(`${payload} = getelementptr inbounds %ScrUnion, ptr ${box}, i32 0, i32 5`);
+        B.line(`${bits} = load i64, ptr ${payload}`);
+        B.line(`${partial} = insertvalue ${SCALAR_UNION_RESULT} poison, i32 ${tag}, 0`);
+        B.line(`${pair} = insertvalue ${SCALAR_UNION_RESULT} ${partial}, i64 ${bits}, 1`);
+        return pair;
+    }
+    /** A private stack box holding a SCALAR_UNION_RESULT pair of `type`. */
+    stackScalarUnion(pair, type) {
+        const B = this.B;
+        const box = B.slot(), tagSlot = B.slot(), payloadSlot = B.slot();
+        B.entryAllocas.push(`${box} = alloca %ScrUnion`);
+        B.entryAllocas.push(`${tagSlot} = getelementptr inbounds %ScrUnion, ptr ${box}, i32 0, i32 1`);
+        B.entryAllocas.push(`${payloadSlot} = getelementptr inbounds %ScrUnion, ptr ${box}, i32 0, i32 5`);
+        const tag = B.tmp(), bits = B.tmp();
+        B.line(`${tag} = extractvalue ${SCALAR_UNION_RESULT} ${pair}, 0`);
+        B.line(`${bits} = extractvalue ${SCALAR_UNION_RESULT} ${pair}, 1`);
+        B.line(`store i32 ${tag}, ptr ${tagSlot}`);
+        B.line(`store i64 ${bits}, ptr ${payloadSlot}`);
+        return { name: box, type };
+    }
+    /** A direct call whose i32 entry returns its scalar union in registers. */
+    scalarResultCall(e) {
+        return e.kind === "call" && this.int32Abis.get(e.callee)?.union === true;
+    }
+    /** A fresh heap box (+1) for a SCALAR_UNION_RESULT pair of `type`; the
+     * exception dummy (tag -1) answers NULL. */
+    boxScalarUnion(pair, type) {
+        const B = this.B;
+        const tag = B.tmp(), bits = B.tmp();
+        B.line(`${tag} = extractvalue ${SCALAR_UNION_RESULT} ${pair}, 0`);
+        B.line(`${bits} = extractvalue ${SCALAR_UNION_RESULT} ${pair}, 1`);
+        return this.boxScalarUnionBits(tag, bits, type);
+    }
+    /** A fresh heap box (+1) for an inline union field's value; the ABSENT
+     * state reads as the undefined arm. */
+    inlineFieldUnion(ptr, type) {
+        const { tag, bits } = loadInlineUnion(this.B, ptr);
+        return this.boxScalarUnionBits(tag, bits, type);
+    }
+    /** boxScalarUnion over a separate tag and payload bits. Unit arms answer
+     * their immortal instances whatever the bits. */
+    boxScalarUnionBits(tag, bits, type) {
+        const B = this.B;
+        const unionId = type.kind === "union" ? type.unionId : "";
+        const arms = this.unionsById.get(unionId).arms;
+        const join = B.newLabel("union.box.join"), none = B.newLabel("union.box.none");
+        const labels = arms.map(() => B.newLabel("union.box.arm"));
+        B.terminate(`switch i32 ${tag}, label %${none} [ ${labels.map((label, armTag) => `i32 ${armTag}, label %${label}`).join(" ")} ]`);
+        const incoming = [];
+        arms.forEach((arm, armTag) => {
+            B.startBlock(labels[armTag]);
+            let value;
+            if (isUnitType(arm))
+                value = this.unitInstanceRef(unionId, armTag);
+            else {
+                const payload = B.tmp();
+                if (arm.kind === "bool")
+                    B.line(`${payload} = trunc i64 ${bits} to i1`);
+                else
+                    B.line(`${payload} = bitcast i64 ${bits} to double`);
+                value = this.unionNewOwned(unionId, armTag, { name: payload, type: arm });
+            }
+            incoming.push(`[ ${value}, %${B.currentLabel()} ]`);
+            B.br(join);
+        });
+        B.startBlock(none);
+        incoming.push(`[ null, %${none} ]`);
+        B.br(join);
+        B.startBlock(join);
+        const box = B.tmp();
+        B.line(`${box} = phi ptr ${incoming.join(", ")}`);
+        return box;
+    }
     /** The i32 bits of a number proven an int32 (a direct call's i32
      * argument or an i32 result): its exact integer when the value carries
      * one, else the conversion the proof makes exact. */
@@ -4808,6 +5099,12 @@ export class LlEmitter {
     canBorrowCallArgument(value) {
         if (value.kind === "strLit")
             return true;
+        // An exact capsule owns its instance while the capsule's binding holds it.
+        if (value.kind === "dynCheck" && value.exact)
+            return value.value.kind === "varRef" && this.canBorrowCallArgument(value.value);
+        // An inline union field has no box to lend.
+        if (this.inlineFieldGet(value))
+            return false;
         // Class casts reinterpret the same pointer (prefix layouts).
         if ((value.kind === "upcast" || value.kind === "downcast") &&
             value.value.type.kind === "object")
@@ -5000,6 +5297,12 @@ export class LlEmitter {
         this.finallyStack = savedFinally;
         this.tryStack = savedTry;
     }
+    /** An async generator completing without a further turn: its request
+     * settles as the body returns (scr_async_gen_hop_done). */
+    emitAsyncGenSettled() {
+        this.declare(`declare void @scr_async_gen_hop_done()`);
+        this.B.line(`call void @scr_async_gen_hop_done()`);
+    }
     /** `return x` of a local whose slot is an owned scope entry of the same
      * type: the return can take over the local's reference. */
     movableReturn(value) {
@@ -5200,6 +5503,17 @@ export class LlEmitter {
                     this.scopes[this.scopes.length - 1].push({ slot: snapshot.sourceSlot, type: STRING }, { slot: snapshot.separatorSlot, type: STRING });
                     break;
                 }
+                const stackObject = this.localStackObjects.get(s.localId);
+                if (stackObject) {
+                    B.line(`store ptr ${emitStackObject(this, stackObject).name}, ptr ${b.slot}`);
+                    break;
+                }
+                if (s.init && this.reassignedStackObjects.has(s.localId)) {
+                    const slot = this.stackObjectSlot(s.localId, s.init.type);
+                    emitStackObject(this, s.init, slot);
+                    B.line(`store ptr ${slot}, ptr ${b.slot}`);
+                    break;
+                }
                 const localUnion = this.localStackUnions.get(s.localId);
                 if (localUnion) {
                     const union = emitStackUnion(this, localUnion);
@@ -5303,6 +5617,24 @@ export class LlEmitter {
                     emitBorrowedArrayRead(this, s.init, b.slot);
                     break;
                 }
+                const holeRead = this.loopArrayBorrows.has(s) ? dynHoleRead(s.init) : null;
+                if (holeRead && s.init.kind === "ternary") {
+                    // A hole reads as the immortal undefined value, which needs no owner.
+                    const present = this.emitExpr(s.init.cond);
+                    const filled = B.newLabel("borrow.hole.filled"), missing = B.newLabel("borrow.hole.missing"), done = B.newLabel("borrow.hole.done");
+                    B.condBr(present.name, filled, missing);
+                    B.startBlock(filled);
+                    emitBorrowedArrayRead(this, holeRead, b.slot);
+                    B.br(done);
+                    B.startBlock(missing);
+                    this.declare("declare ptr @scr_dyn_undefined()");
+                    const undef = B.tmp();
+                    B.line(`${undef} = call ptr @scr_dyn_undefined()`);
+                    B.line(`store ptr ${undef}, ptr ${b.slot}`);
+                    B.br(done);
+                    B.startBlock(done);
+                    break;
+                }
                 // A stable lexical alias cannot outlive its unchanged local owner.
                 // Whole-value uses still retain their own copies, so returning or
                 // storing the alias preserves the ordinary heap representation.
@@ -5347,15 +5679,23 @@ export class LlEmitter {
                     B.line(`store ptr ${v.name}, ptr ${owner}`);
                     break;
                 }
+                if (this.reassignedStackObjects.has(s.localId)) {
+                    // The new value may read the old one: build it apart, then copy.
+                    const struct = stackObjectStruct(s.value.type);
+                    const value = emitStackObject(this, s.value);
+                    const bits = B.tmp();
+                    B.line(`${bits} = load ${struct}, ptr ${value.name}`);
+                    B.line(`store ${struct} ${bits}, ptr ${this.stackObjectSlot(s.localId, s.value.type)}`);
+                    break;
+                }
                 const localStorage = this.localUnionStorage.get(s.localId);
                 if (localStorage) {
                     storeLocalUnion(this, localStorage, s.value);
                     break;
                 }
-                const concat = s.value;
-                const suffix = matchStringSelfConcat(s.localId, concat);
-                if (suffix && concat.kind === "strConcat") {
-                    this.emitStringSelfConcatAssign(s.localId, concat.left, suffix, false);
+                const self = matchStringSelfConcat(s.localId, s.value);
+                if (self) {
+                    this.emitStringSelfConcatAssign(s.localId, self.left, self.suffix, false);
                     break;
                 }
                 const b = this.binding(s.localId);
@@ -5520,24 +5860,17 @@ export class LlEmitter {
                     break;
                 }
                 const obj = this.emitStableReceiver(s.obj, [s.value]);
-                const v = this.emitExpr(s.value);
+                const v = this.emitFieldValue(s.value, s.kind === "recordSet"
+                    ? this.recordFieldInline(s.shapeId, s.field)
+                    : this.inlineUnions.classField(s.className, s.field));
                 if (s.kind === "fieldSet")
                     this.emitStoreGuard(obj.name, s);
                 else if (this.publishedTypes?.recordGuarded(s.shapeId) === true)
                     this.emitPublishedFieldGuard(obj.name, null, s.field);
-                const { ptr, type } = s.kind === "fieldSet"
+                const { ptr, type, inline } = s.kind === "fieldSet"
                     ? this.classFieldPtr(obj.name, s.className, s.field)
                     : this.recordFieldPtr(obj.name, s.shapeId, s.field);
-                if (isRefCounted(type)) {
-                    this.moveTemp(v);
-                    const old = B.tmp();
-                    B.line(`${old} = load ptr, ptr ${ptr}`);
-                    this.storeField(ptr, type, v.name);
-                    this.releaseValue(old, type);
-                }
-                else {
-                    this.storeField(ptr, type, v.name);
-                }
+                this.replaceField(ptr, type, inline, v);
                 if (s.kind === "fieldSet" &&
                     s.field === "name" &&
                     this.classMeta.get(s.className)?.root.def.name === "%Error") {
@@ -5638,15 +5971,20 @@ export class LlEmitter {
                         const lw = B.newLabel("rks.w");
                         B.condBr(pend, join, lw);
                         B.startBlock(lw);
-                        const { ptr, type } = this.recordFieldPtr(obj.name, s.shapeId, f.name);
-                        if (isRefCounted(type)) {
+                        const { ptr, type, inline } = this.recordFieldPtr(obj.name, s.shapeId, f.name);
+                        if (inline) {
+                            // The slot copies the checked value's bits; nv is released below.
+                            this.storeField(ptr, type, nv, true);
+                            this.releaseValue(nv, type);
+                        }
+                        else if (isRefCounted(type)) {
                             const old = B.tmp();
                             B.line(`${old} = load ptr, ptr ${ptr}`);
-                            this.storeField(ptr, type, nv);
+                            this.storeField(ptr, type, nv, false);
                             this.releaseValue(old, type);
                         }
                         else {
-                            this.storeField(ptr, type, nv);
+                            this.storeField(ptr, type, nv, false);
                         }
                         B.br(join);
                         B.startBlock(ln);
@@ -5669,15 +6007,20 @@ export class LlEmitter {
                     const ln = B.newLabel("rks.n");
                     B.condBr(hit, lh, ln);
                     B.startBlock(lh);
-                    const { ptr, type } = this.recordFieldPtr(obj.name, s.shapeId, f.name);
-                    if (isRefCounted(type)) {
+                    const { ptr, type, inline } = this.recordFieldPtr(obj.name, s.shapeId, f.name);
+                    if (inline) {
+                        // The write owns the moved-in value; the slot copies its bits.
+                        this.storeField(ptr, type, v.name, true);
+                        this.releaseValue(v.name, type);
+                    }
+                    else if (isRefCounted(type)) {
                         const old = B.tmp();
                         B.line(`${old} = load ptr, ptr ${ptr}`);
-                        this.storeField(ptr, type, v.name);
+                        this.storeField(ptr, type, v.name, false);
                         this.releaseValue(old, type);
                     }
                     else {
-                        this.storeField(ptr, type, v.name);
+                        this.storeField(ptr, type, v.name, false);
                     }
                     B.br(join);
                     B.startBlock(ln);
@@ -6199,8 +6542,16 @@ export class LlEmitter {
                     break;
                 }
                 let v = null;
-                const moved = this.finallyStack.length === 0 ? this.movableReturn(s.value) : null;
-                if (moved !== null) {
+                const moved = this.finallyStack.length === 0 && !this.currentUnionResult
+                    ? this.movableReturn(s.value)
+                    : null;
+                if (s.value !== null && this.currentUnionResult) {
+                    // The tag and payload bits leave in registers; a heap box the
+                    // value needed is released with its frame below.
+                    const box = this.emitUnionProjection(s.value);
+                    v = { name: this.scalarUnionPair(box.name, s.value.type), type: s.value.type };
+                }
+                else if (moved !== null) {
                     // Returning an owned local hands its reference to the caller: no
                     // retain now and no release of the local below.
                     const t = B.tmp();
@@ -6230,9 +6581,22 @@ export class LlEmitter {
                     v = this.emitExpr(s.value);
                     this.moveTemp(v);
                 }
+                // An async generator's `return v` awaits v before any crossed
+                // finally runs. Past finally regions that turn is taken here and
+                // the request settles at completion; otherwise the completion's
+                // own turn is the await (nothing runs in between).
+                const genSettles = this.currentAsyncGenerator && (s.awaited === true || this.finallyStack.length > 0);
+                if (this.currentAsyncGenerator && s.awaited !== true && this.finallyStack.length > 0) {
+                    if (this.wasi)
+                        this.emitWasiSuspend(null);
+                    else {
+                        this.declare(`declare void @scr_await_hop()`);
+                        B.line(`call void @scr_await_hop()`);
+                    }
+                }
                 if (this.finallyStack.length > 0) {
                     let pretSlot = null;
-                    if (v !== null && isRefCounted(v.type)) {
+                    if (v !== null && isRefCounted(v.type) && !this.currentUnionResult) {
                         pretSlot = B.slot();
                         B.entryAllocas.push(`${pretSlot} = alloca ptr ; pending return (through finally)`);
                         B.line(`store ptr ${v.name}, ptr ${pretSlot}`);
@@ -6265,6 +6629,8 @@ export class LlEmitter {
                     this.releaseForJump(0, 0);
                 }
                 if (!B.isTerminated()) {
+                    if (genSettles)
+                        this.emitAsyncGenSettled();
                     if (this.currentCoro !== null) {
                         this.emitWasiFulfill(v);
                         B.terminate(`br label %${this.currentCoro.finalLabel}`);
@@ -6273,6 +6639,8 @@ export class LlEmitter {
                         B.terminate("ret void");
                     else if (this.currentInt32Result)
                         B.terminate(`ret i32 ${this.int32Argument(v, s.value)}`);
+                    else if (this.currentUnionResult)
+                        B.terminate(`ret ${SCALAR_UNION_RESULT} ${v.name}`);
                     else
                         B.terminate(`ret ${this.llType(s.value.type)} ${v.name}`);
                 }
@@ -6313,7 +6681,7 @@ export class LlEmitter {
                 break;
             default: {
                 // Statement coverage is now total (bytesSet closed the set) —
-                // keep the loud refusal for any future IR statement kind.
+                // keep throwing LlvmUnsupportedError for any future IR statement kind.
                 const rest = s;
                 const k = rest.kind;
                 throw new LlvmUnsupportedError(`stmt:${k}`, rest.loc);
@@ -6659,7 +7027,11 @@ export class LlEmitter {
         if (e.kind === "seqExpr" &&
             isRefCounted(e.result.type) &&
             e.result.kind !== "strLit" &&
-            this.discardableRead(e.result)) {
+            (this.discardableRead(e.result) ||
+                // A function-local binding's read has no effect of its own (a
+                // compound assignment's result, say); a module binding's read may
+                // throw before initialization, so it stays.
+                (e.result.kind === "varRef" && this.binding(e.result.localId).kind === "local"))) {
             this.emitSequence(() => {
                 for (const s of e.stmts)
                     this.emitStmt(s);
@@ -6690,8 +7062,11 @@ export class LlEmitter {
         // of first building the suffix as a separate string.
         const parts = stringParts(suffix);
         const mixed = parts.length > 1 || numberPart(parts[0]) !== null;
+        const charCode = mixed ? null : this.emitSingleCharCode(suffix);
         const inputs = mixed ? emitConcatInputs(this, parts) : [];
-        const right = mixed ? null : this.emitExpr(suffix);
+        // The concat only reads the suffix; relinquishing the binding below
+        // runs no code that could rebind a borrowed local.
+        const right = mixed || charCode !== null ? null : emitStringInputs(this, [suffix])[0];
         const b = this.binding(localId);
         const B = this.B;
         if (b.kind === "boxed") {
@@ -6705,7 +7080,14 @@ export class LlEmitter {
             this.releaseValue(old, b.type);
         }
         let raw;
-        if (right === null) {
+        if (charCode !== null) {
+            // The snapshot moves into the consuming character append.
+            this.moveTemp(snapshot);
+            this.declare(`declare ptr @scr_str_concat_move_char_code(ptr, double)`);
+            raw = B.tmp();
+            B.line(`${raw} = call ptr @scr_str_concat_move_char_code(ptr ${snapshot.name}, double ${charCode.name})`);
+        }
+        else if (right === null) {
             raw = emitMixedConcat(this, snapshot.name, inputs);
         }
         else {
@@ -6730,6 +7112,17 @@ export class LlEmitter {
         }
         return result;
     }
+    /** The code of a one-argument `String.fromCharCode(c)` suffix, emitted, so
+     * `s += String.fromCharCode(c)` appends the character without building
+     * the one-character string; null for any other suffix. */
+    emitSingleCharCode(suffix) {
+        if (suffix.kind !== "libCall" || suffix.fn !== "string.fromCharCode")
+            return null;
+        const packed = suffix.args[0];
+        if (packed?.kind !== "arrayLit" || packed.elems.length !== 1 || packed.spreads?.length)
+            return null;
+        return this.emitExpr(packed.elems[0]);
+    }
     /** `local = local + suffix` when the suffix cannot read or write the
      * local (an unboxed binding is only reachable through this function's own
      * expressions): reading the binding after the suffix gives the value the
@@ -6749,14 +7142,21 @@ export class LlEmitter {
             return null;
         const parts = stringParts(suffix);
         const mixed = parts.length > 1 || numberPart(parts[0]) !== null;
+        const charCode = mixed ? null : this.emitSingleCharCode(suffix);
         const inputs = mixed ? emitConcatInputs(this, parts) : [];
-        const right = mixed ? null : this.emitExpr(suffix);
+        // The concat only reads the suffix, which may stay borrowed.
+        const right = mixed || charCode !== null ? null : emitStringInputs(this, [suffix])[0];
         this.materializeSplitLocal(localId);
         const B = this.B;
         const head = B.tmp();
         B.line(`${head} = load ptr, ptr ${b.slot}`);
         let raw;
-        if (right === null) {
+        if (charCode !== null) {
+            this.declare(`declare ptr @scr_str_concat_move_char_code(ptr, double)`);
+            raw = B.tmp();
+            B.line(`${raw} = call ptr @scr_str_concat_move_char_code(ptr ${head}, double ${charCode.name})`);
+        }
+        else if (right === null) {
             raw = emitMixedConcat(this, head, inputs, true);
         }
         else {
@@ -6787,8 +7187,45 @@ export class LlEmitter {
     emitIntrinsicExpr(e) {
         if (e.name === "threads.publish")
             return this.emitPublish(e);
+        if (e.name === "region.create" ||
+            e.name === "region.enter" ||
+            e.name === "region.leave" ||
+            e.name === "region.release")
+            return this.emitRegionIntrinsic(e);
         return emitIntrinsicExpr(this, e);
     }
+    /** Lifetime regions in modules with lifetimeRegions (llvm/regions.ts).
+     * Created with the class graph; null elsewhere. */
+    regions = null;
+    /** LifetimeRegion's runtime calls: create answers the region id, enter
+     * and leave bracket run(), release condemns. */
+    emitRegionIntrinsic(e) {
+        if (this.regions === null)
+            throw new InternalCompilerError(`llvm emitter bug: ${e.name} without lifetimeRegions`);
+        const args = e.args.map((a) => this.emitExpr(a));
+        if (this.B.isTerminated())
+            return { name: "", type: e.type };
+        switch (e.name) {
+            case "region.create": {
+                this.declare(`declare double @scr_region_create(ptr)`);
+                const id = this.B.tmp();
+                this.B.line(`${id} = call double @scr_region_create(ptr ${REGION_TYPES})`);
+                return { name: id, type: e.type };
+            }
+            case "region.enter":
+                this.declare(`declare void @scr_region_enter(double)`);
+                this.B.line(`call void @scr_region_enter(double ${args[0].name})`);
+                break;
+            case "region.leave":
+                this.declare(`declare void @scr_region_leave()`);
+                this.B.line(`call void @scr_region_leave()`);
+                break;
+            default:
+                this.declare(`declare void @scr_region_release(double)`);
+                this.B.line(`call void @scr_region_release(double ${args[0].name})`);
+        }
+        return { name: "", type: e.type };
+    }
     publishWalkersCache = null;
     /** Per-type publication walkers, created on the first publish. */
     get publishWalkers() {
@@ -6802,6 +7239,7 @@ export class LlEmitter {
             tracedShapes: this.tracedShapes,
             unionsById: this.unionsById,
             recordsById: this.recordsById,
+            inlineUnions: this.inlineUnions,
             nullableArm: (t) => this.nullableUnions.of(t)?.arm ?? null,
             classInfo: (className) => {
                 const meta = this.classMetaOf(className);
@@ -6811,11 +7249,16 @@ export class LlEmitter {
                     pre: meta.pre,
                     post: meta.post,
                     runtimeRooted: meta.root.def.runtime === true,
-                    fields: meta.def.fields.map((f) => ({
-                        name: f.name,
-                        index: classFieldIndex(meta, f.name).index,
-                        type: this.nullableFields.storageType(className, f.name, f.type),
-                    })),
+                    // Inline scalar-union fields are plain bits: nothing to push.
+                    fields: meta.def.fields.flatMap((f) => this.inlineUnions.classField(className, f.name)
+                        ? []
+                        : [
+                            {
+                                name: f.name,
+                                index: classFieldIndex(meta, f.name).index,
+                                type: this.nullableFields.storageType(className, f.name, f.type),
+                            },
+                        ]),
                 };
             },
             classesInInterval: (pre, post) => byPre.filter((m) => m.pre >= pre && m.pre <= post).map((m) => m.def.name),
@@ -6982,6 +7425,8 @@ export class LlEmitter {
             this.B.line(`${value} = load ptr, ptr ${binding.slot}`);
             return { name: value, type: e.type };
         }
+        if (e.kind === "dynCheck" && e.exact)
+            return this.emitExactCapsuleObject(e.value, e.type);
         if (e.kind === "chainRecv") {
             // The chain's bind slot holds its receiver unchanged until the body
             // finishes, owned by the slot itself or by the chain's receiver.
@@ -7042,13 +7487,14 @@ export class LlEmitter {
         if (e.kind === "recordGet" || e.kind === "fieldGet") {
             const receiver = this.emitReadReceiver(e.obj);
             if (e.kind === "recordGet") {
-                const { ptr, type } = this.recordFieldPtr(receiver.name, e.shapeId, e.field);
-                return { name: this.loadRecordField(ptr, type), type: e.type };
+                // An inline union field answers a private stack box.
+                const { ptr, type, inline } = this.recordFieldPtr(receiver.name, e.shapeId, e.field);
+                return { name: this.loadRecordField(ptr, type, inline), type: e.type };
             }
-            const { ptr, type } = this.classFieldPtr(receiver.name, e.className, e.field);
+            const { ptr, type, inline } = this.classFieldPtr(receiver.name, e.className, e.field);
             if (this.int32Slots.isField(e.className, e.field))
                 return this.loadInt32Field(ptr, e.type);
-            return { name: this.loadField(ptr, type), type: e.type };
+            return { name: this.loadField(ptr, type, inline), type: e.type };
         }
         if (e.kind === "ternary" && this.canBorrowReceiver(e.then) && this.canBorrowReceiver(e.else_)) {
             // Checked projections lower to a ternary with an always-throwing
@@ -7075,10 +7521,30 @@ export class LlEmitter {
             B.line(`${value} = load ptr, ptr ${slot}`);
             return { name: value, type: e.type };
         }
+        // Scalar optional values and register results answer a private stack
+        // box. A ternary of borrowable arms above keeps lending its arm.
+        if ((e.kind === "optChain" ||
+            e.kind === "nullish" ||
+            e.kind === "ternary" ||
+            e.kind === "arrIntrinsic") &&
+            isScalarOptionalSource(e, this.unionSources))
+            return emitScalarOptional(this, e);
+        if (e.kind === "call" && this.scalarResultCall(e))
+            return emitCallExpr(this, e, false, true);
         if (e.kind === "call" && this.canBorrowReceiver(e))
             return emitBorrowedResultCall(this, e);
         return this.emitExpr(e);
     }
+    /** The frame slot a reassigned stack-object local keeps for its value. */
+    stackObjectSlot(localId, type) {
+        let slot = this.stackObjectSlots.get(localId);
+        if (slot === undefined) {
+            slot = this.B.slot();
+            this.B.entryAllocas.push(`${slot} = alloca ${stackObjectStruct(type)}, align 8`);
+            this.stackObjectSlots.set(localId, slot);
+        }
+        return slot;
+    }
     /** A private stack union source with an independently owned payload. */
     canStackReceiver(e) {
         return this.isStackUnionSource(e);
@@ -7090,7 +7556,17 @@ export class LlEmitter {
             return false;
         return (canStackUnion(e, this.boxedUnionsById) ||
             matchMapRead(e, this.boxedUnionsById) !== null ||
-            this.optionalArrayReads.get(e) !== null);
+            this.optionalArrayReads.get(e) !== null ||
+            isScalarOptionalSource(e, this.unionSources) ||
+            this.scalarResultCall(e) ||
+            this.inlineFieldGet(e));
+    }
+    /** A read of a record or class field that stores its scalar union
+     * inline. */
+    inlineFieldGet(e) {
+        if (e.kind === "recordGet")
+            return this.recordFieldInline(e.shapeId, e.field);
+        return e.kind === "fieldGet" && this.inlineUnions.classField(e.className, e.field);
     }
     /** The nullable-pointer representation behind a union-typed class field
      * read, or null for every other expression. */
@@ -7229,6 +7705,15 @@ export class LlEmitter {
             this.localArrayReads.has(localId) ||
             this.mapReadLifetimes.locals.has(localId));
     }
+    /** The instance of a capsule known to hold exactly this class (borrowed). */
+    emitExactCapsuleObject(value, type) {
+        const capsule = this.emitReadReceiver(value);
+        const slot = this.B.tmp();
+        const object = this.B.tmp();
+        this.B.line(`${slot} = getelementptr inbounds i8, ptr ${capsule.name}, i64 16 ; ->v.typed_ref.ptr`);
+        this.B.line(`${object} = load ptr, ptr ${slot}`);
+        return { name: object, type };
+    }
     canBorrowReceiver(e) {
         switch (e.kind) {
             case "chainRecv":
@@ -7246,9 +7731,11 @@ export class LlEmitter {
             case "downcast":
             case "upcast":
                 return this.canBorrowReceiver(e.value);
+            // An inline union field has no box to lend: projections read it
+            // through emitReadReceiver's private stack box.
             case "fieldGet":
             case "recordGet":
-                return this.canBorrowReceiver(e.obj);
+                return !this.inlineFieldGet(e) && this.canBorrowReceiver(e.obj);
             case "ternary":
                 return this.canBorrowReceiver(e.then) && this.canBorrowReceiver(e.else_);
             case "seqExpr": {
@@ -7484,8 +7971,11 @@ export class LlEmitter {
     fsRenameThunkFor(cbT) {
         return fsRenameThunkFor(this, cbT);
     }
-    cryptoBytesThunkFor(cbT, arrayBuffer = false) {
-        return cryptoBytesThunkFor(this, cbT, arrayBuffer);
+    cryptoBytesThunkFor(cbT, arrayBuffer = false, valueMode = "buffer") {
+        return cryptoBytesThunkFor(this, cbT, arrayBuffer, valueMode);
+    }
+    cryptoIntThunkFor(cbT) {
+        return cryptoIntThunkFor(this, cbT);
     }
     zlibBytesThunkFor(cbT) {
         return zlibBytesThunkFor(this, cbT);