@scriptc/compiler 0.3.2 → 0.3.4

package/dist/backend/llvm/emitter.js

@@ -1,3 +1,5 @@
+import { emitArraySearchHelpers } from "./array-search.js";
+import { emitStringInputs } from "./string-lifetimes.js";
 import { emitLlvmLayouts } from "./layouts.js";
 import { compileRegexMatcher } from "./regex-matchers.js";
 import { CYC_BUF, CYC_HDR, FIRST_EMITTED_CYC_KIND, inlineAllocSupported } from "./alloc.js";
@@ -7,7 +9,7 @@ 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,7 +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 { addRecordResultEntries } from "./record-results.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";
@@ -40,25 +42,26 @@ import { emitStackObject, findLocalStackObjects, findReassignedStackObjects, sta
 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";
-import { emitStackMapRead, findMapReadLifetimes, matchMapRead, } from "./map-read-lifetimes.js";
+import { emitStackMapRead, findMapReadLifetimes, findReadNumberMapWrites, matchMapRead, } from "./map-read-lifetimes.js";
 import { emitBorrowedFieldSequence, guardedValue } from "./borrowed-receivers.js";
-import { borrowableInputs, emitBorrowedInput } from "./borrowed-inputs.js";
+import { borrowableInputs, emitBorrowedInput, emitBorrowedInputs } from "./borrowed-inputs.js";
 import { analyzeWalks, findWalkBorrows } from "./walk-borrows.js";
 import { findReboundParameters } from "./rebound-parameters.js";
 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";
 import { StackCaptures } from "./stack-captures.js";
-import { ABSENT_FIELD_PAYLOAD, emitFieldAbsentTest, exactIndexLines, f64Lit, ffiNativeTypeLl, ffiNativeParamLl, ffiNativeReturnLl, llvmCommentText, } from "./common.js";
+import { ABSENT_FIELD_PAYLOAD, emitFieldAbsentTest, exactIndexLines, f64Lit, ffiNativeTypeLl, ffiNativeParamLl, ffiNativeReturnLl, llvmCommentText, sizeToDouble, } from "./common.js";
 import { ffiExtendsNarrowIntegers } from "../targets.js";
 import { emitLiteralExpr, emitOperatorExpr, emitStringExpr, emitContainerExpr, emitRecordExpr, } from "./expr-primitives.js";
 import { emitControlExpr } from "./expr-control.js";
@@ -70,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";
@@ -82,17 +85,17 @@ import { emitNetworkHttpLibCall } from "./lib-network.js";
 import { emitAssertInspectLibCall, emitIoLibCall, emitGenericLibCall, emitLibCall, } from "./lib-dispatch.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 { LlDyn, recordDynKeepsIdentity } from "./dyn.js";
 import { VirtualBorrows } from "./virtual-borrows.js";
 import { LlvmUnsupportedError } from "./unsupported.js";
 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 { 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) {
@@ -286,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. */
@@ -328,6 +333,8 @@ 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();
@@ -347,6 +354,7 @@ export class LlEmitter {
     checkedNarrows;
     callArrayReads = new Map();
     mapReadLifetimes = { locals: new Map(), arguments: new Map() };
+    readNumberMapWrites = new Set();
     callLifetimes;
     constantCallbacks;
     currentConstantCallbacks = new Map();
@@ -439,6 +447,8 @@ 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
@@ -452,6 +462,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. */
@@ -624,7 +635,9 @@ 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;
+        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 ?? []);
@@ -662,6 +675,9 @@ 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.
@@ -670,6 +686,7 @@ export class LlEmitter {
             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),
         };
@@ -718,14 +735,18 @@ export class LlEmitter {
                 walkParameters.set(fn.name, indexes);
             }
         }
-        this.callLifetimes = analyzeCallLifetimes(this.fnByName, (className, field) => this.nullableFields.get(className, field) !== null, walkParameters, new Set([...this.int32Abis].filter(([, abi]) => abi.union).map(([name]) => name)));
+        this.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),
+        }, (shapeId) => {
+            const shape = this.recordsById.get(shapeId);
+            return shape !== undefined && !recordDynKeepsIdentity(shape);
+        });
         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;
@@ -735,6 +756,8 @@ export class LlEmitter {
             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,
@@ -748,6 +771,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),
@@ -763,6 +788,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);
@@ -796,13 +822,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);
             }
@@ -1162,7 +1191,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
@@ -1215,7 +1244,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) => {
@@ -1388,21 +1417,17 @@ export class LlEmitter {
             if (!asyncEntry)
                 return [];
             const lines = [];
+            // finish_top_level noted 13 unless the program set process.exitCode.
+            // A failed node:test run outranks either before exit listeners run.
             if (usesNodeTest) {
-                lines.push(`  %tla_program_exit = call i32 @scr_test_exit_code()`);
+                lines.push(`  %tla_program_exit = call i32 @scr_test_exit_code()`, `  %tla_program_exit_zero = icmp eq i32 %tla_program_exit, 0`, `  %tla_hint = call i32 @scr_exit_code_hint_get()`, `  %tla_exit_status = select i1 %tla_program_exit_zero, i32 %tla_hint, i32 %tla_program_exit`, `  call void @scr_exit_code_note(i32 %tla_exit_status)`);
             }
-            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 ? "%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);
             for (const line of topPendingReleases)
                 lines.push(line);
-            lines.push(`  ret i32 ${exitStatus}`);
+            // An exit listener may set process.exitCode again, as in Node.
+            lines.push(`  %tla_exit_code = call i32 @scr_exit_code_hint_get()`, `  ret i32 %tla_exit_code`);
             return lines;
         };
         // LIBRARY mode: the runtime entry points the generated library
@@ -1451,6 +1476,7 @@ 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(),
@@ -1500,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
@@ -1524,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
@@ -1636,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.
@@ -2050,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}`);
@@ -2145,9 +2185,13 @@ export class LlEmitter {
         // Number-key Map/Set lookups probe the runtime's direct index inline:
         // while ndense is nonzero every live key is an integer below it, so an
         // in-range integral key reads its slot (entry index + 1, 0 = absent) and
-        // any other key is absent. Maps without the index (ndense 0) and every
-        // non-integral probe outside the table take the runtime lookup, which
-        // keeps the complete SameValueZero semantics.
+        // any other key is absent. Maps without the index (ndense 0) hash the
+        // key in sc_map_entry_f64_hashed, which scans the entries of a small map
+        // or probes a compact bucket table as scr_map_find_f64 does, and calls
+        // the runtime lookup for a wide table. It stays out of line so that the
+        // direct-index path stays small at every call site. Both only read
+        // memory, so LLVM merges lookups of one key when nothing is stored in
+        // between (a has() followed by get(), for example).
         if (this.decls.has(NUMBER_MAP_ENTRY_DECL)) {
             const sz = this.sizeType;
             let mapTmp = 0;
@@ -2156,7 +2200,24 @@ export class LlEmitter {
             // 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 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`, `}`, ``);
+                : `  %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:`, `  %hashed = call ptr @sc_map_entry_f64_hashed(ptr %m, double %k)`, `  ret ptr %hashed`, `}`, ``, 
+            // Hashing (scr_map_find_f64): the SameValueZero key word, its
+            // scr_key_mix hash (zero remapped to one) and the absent-key filter.
+            `define internal ptr @sc_map_entry_f64_hashed(ptr %m, double %k) noinline ${FN_ATTRS} {`, `entry:`, `  %nan = fcmp uno double %k, %k`, `  %zero = fcmp oeq double %k, 0.0`, `  %kz = select i1 %zero, double 0.0, double %k`, `  %kzb = bitcast double %kz to i64`, `  %kb = select i1 %nan, i64 9221120237041090560, i64 %kzb`, `  %x1s = lshr i64 %kb, 30`, `  %x1 = xor i64 %kb, %x1s`, `  %x2 = mul i64 %x1, -4658895280553007687`, `  %x3s = lshr i64 %x2, 27`, `  %x3 = xor i64 %x2, %x3s`, `  %x4 = mul i64 %x3, -7723592293110705685`, `  %x5s = lshr i64 %x4, 31`, `  %x5 = xor i64 %x4, %x5s`, `  %hz = icmp eq i64 %x5, 0`, `  %h = select i1 %hz, i64 1, i64 %x5`, `  %f1s = lshr i64 %h, 44`, `  %f1a = and i64 %f1s, 63`, `  %f1 = shl i64 1, %f1a`, `  %f2s = lshr i64 %h, 50`, `  %f2a = and i64 %f2s, 63`, `  %f2 = shl i64 1, %f2a`, `  %fb = or i64 %f1, %f2`, `  %fp = getelementptr inbounds %ScrMapIx, ptr %m, i32 0, i32 11`, `  %filter = load i64, ptr %fp`, `  %fm = and i64 %filter, %fb`, `  %fin = icmp eq i64 %fm, %fb`, `  br i1 %fin, label %table, label %miss`, `table:`, `  %nbp = getelementptr inbounds %ScrMapIx, ptr %m, i32 0, i32 14`, `  %nb = load ${sz}, ptr %nbp`, `  %eps = getelementptr inbounds %ScrMapIx, ptr %m, i32 0, i32 13`, `  %ents = load ptr, ptr %eps`, `  %linear = icmp eq ${sz} %nb, 0`, `  br i1 %linear, label %scan, label %buckets`, 
+            // Small maps keep no bucket table: scan the cached entry hashes.
+            `scan:`, `  %nep = getelementptr inbounds %ScrMapIx, ptr %m, i32 0, i32 9`, `  %ne = load ${sz}, ptr %nep`, `  br label %scan.loop`, `scan.loop:`, `  %si = phi ${sz} [ 0, %scan ], [ %si.next, %scan.next ]`, `  %sdone = icmp eq ${sz} %si, %ne`, `  br i1 %sdone, label %miss, label %scan.entry`, `scan.entry:`, `  %se = getelementptr inbounds %ScrMapEntry, ptr %ents, ${sz} %si`, `  %seh = getelementptr inbounds %ScrMapEntry, ptr %se, i32 0, i32 2`, `  %sh = load i64, ptr %seh`, `  %sk = load i64, ptr %se`, `  %shq = icmp eq i64 %sh, %h`, `  %skq = icmp eq i64 %sk, %kb`, `  %sq = and i1 %shq, %skq`, `  br i1 %sq, label %scan.found, label %scan.next`, `scan.found:`, `  ret ptr %se`, `scan.next:`, `  %si.next = add ${sz} %si, 1`, `  br label %scan.loop`, 
+            // Compact tables tag each 24-bit entry index (+1) with the hash's
+            // top byte; wider tables take the runtime lookup.
+            `buckets:`, `  %wide = icmp ugt ${sz} %nb, 16777216`, `  br i1 %wide, label %runtime, label %probe`, `probe:`, `  %bp = getelementptr inbounds %ScrMapIx, ptr %m, i32 0, i32 15`, `  %bk = load ptr, ptr %bp`, `  %mask = sub ${sz} %nb, 1`, `  %ht = lshr i64 %h, 32`, `  %ht32 = trunc i64 %ht to i32`, `  %tag = and i32 %ht32, -16777216`, sz === "i64" ? `  %hi = add i64 %h, 0` : `  %hi = trunc i64 %h to ${sz}`, `  %i0 = and ${sz} %hi, %mask`, `  br label %probe.loop`, `probe.loop:`, `  %pi = phi ${sz} [ %i0, %probe ], [ %pi.next, %probe.next ]`, `  %bep = getelementptr inbounds i32, ptr %bk, ${sz} %pi`, `  %b = load i32, ptr %bep`, `  %bempty = icmp eq i32 %b, 0`, `  br i1 %bempty, label %miss, label %probe.tag`, `probe.tag:`, `  %bt = and i32 %b, -16777216`, `  %btq = icmp eq i32 %bt, %tag`, `  br i1 %btq, label %probe.entry, label %probe.next`, `probe.entry:`, `  %bix = and i32 %b, 16777215`, `  %bix1 = sub i32 %bix, 1`, sz === "i32" ? `  %bi = add i32 %bix1, 0` : `  %bi = zext i32 %bix1 to ${sz}`, `  %pe = getelementptr inbounds %ScrMapEntry, ptr %ents, ${sz} %bi`, `  %peh = getelementptr inbounds %ScrMapEntry, ptr %pe, i32 0, i32 2`, `  %ph = load i64, ptr %peh`, `  %pk = load i64, ptr %pe`, `  %phq = icmp eq i64 %ph, %h`, `  %pkq = icmp eq i64 %pk, %kb`, `  %pq = and i1 %phq, %pkq`, `  br i1 %pq, label %probe.found, label %probe.next`, `probe.found:`, `  ret ptr %pe`, `probe.next:`, `  %pi.inc = add ${sz} %pi, 1`, `  %pi.next = and ${sz} %pi.inc, %mask`, `  br label %probe.loop`, `miss:`, `  ret ptr null`, `runtime:`, `  %r = call ptr @scr_map_entry_f64(ptr %m, double %k) memory(read) nounwind willreturn`, `  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
@@ -2398,7 +2459,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();
@@ -3050,8 +3111,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);
@@ -3550,6 +3616,11 @@ export class LlEmitter {
         this.B.line(`store i32 0, ptr ${slot}`);
         return slot;
     }
+    /** The amortized cancellation poll, emitted on the loop's back edge (the
+     * continue target), after the body. A poll in the header would be a loop
+     * exit ahead of the body; LLVM then cannot rotate the loop, so loads that
+     * the body repeats on every iteration (a typed array's length, for one)
+     * stay in the loop. */
     emitWorkerLoopCheck(slot) {
         if (slot === null)
             return;
@@ -3713,6 +3784,7 @@ export class LlEmitter {
             case "searchParams":
             case "stats":
             case "fileHandle":
+            case "dir":
             case "spawnRes":
             case "child":
             case "childStream":
@@ -3755,7 +3827,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`);
@@ -3888,7 +3960,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). */
@@ -3939,8 +4011,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)
@@ -3952,7 +4026,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);
@@ -3960,7 +4040,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) {
@@ -3973,10 +4054,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")
@@ -3985,10 +4072,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;
@@ -4458,13 +4581,14 @@ 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);
         this.scalarStringSlices =
             this.debug === null ? findScalarStringSlices(fn, this.callLifetimes) : new Map();
         this.mapReadLifetimes = findMapReadLifetimes(fn, this.boxedUnionsById, this.callLifetimes);
+        this.readNumberMapWrites = findReadNumberMapWrites(fn);
         this.localStackUnions = findLocalStackUnions(fn, this.callLifetimes, this.boxedUnionsById);
         this.localStackObjects = this.stackObjects
             ? findLocalStackObjects(this, fn, this.callLifetimes)
@@ -4775,6 +4899,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}`;
@@ -4861,11 +4994,23 @@ export class LlEmitter {
      * exception dummy (tag -1) answers NULL. */
     boxScalarUnion(pair, type) {
         const B = this.B;
-        const unionId = type.kind === "union" ? type.unionId : "";
-        const arms = this.unionsById.get(unionId).arms;
         const tag = B.tmp(), bits = B.tmp();
         B.line(`${tag} = extractvalue ${SCALAR_UNION_RESULT} ${pair}, 0`);
         B.line(`${bits} = extractvalue ${SCALAR_UNION_RESULT} ${pair}, 1`);
+        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(" ")} ]`);
@@ -4972,6 +5117,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")
@@ -5484,6 +5635,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.
@@ -5542,10 +5711,9 @@ export class LlEmitter {
                     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);
@@ -5646,7 +5814,7 @@ export class LlEmitter {
                 B.line(`${lenPtr} = getelementptr inbounds %ScrArr, ptr ${arr.name}, i32 0, i32 1`);
                 this.markMemoryPointer(lenPtr, "array:header");
                 B.line(`${len} = load ${this.sizeType}, ptr ${lenPtr}${this.fieldAliasAttachment(lenPtr)}`);
-                B.line(`${lenNumber} = sitofp ${this.sizeType} ${len} to double`);
+                B.line(`${lenNumber} = ${sizeToDouble(this.sizeType)} ${this.sizeType} ${len} to double`);
                 B.line(`${same} = fcmp oeq double ${length.name}, ${lenNumber}`);
                 B.condBr(same, done, resize);
                 B.startBlock(resize);
@@ -5710,24 +5878,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") {
@@ -5828,15 +5989,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);
@@ -5859,15 +6025,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);
@@ -5935,15 +6106,15 @@ export class LlEmitter {
                 const lc = B.newLabel("loop.c");
                 const lb = B.newLabel("loop.b");
                 const le = B.newLabel("loop.e");
+                const lp = workerBudget !== null ? B.newLabel("loop.p") : lc;
                 B.br(lc);
                 B.startBlock(lc);
-                this.emitWorkerLoopCheck(workerBudget);
                 B.condBr(this.emitCondition(s.cond), lb, le);
                 B.startBlock(lb);
                 this.jumpTargets.push({
                     kind: "loop",
                     brkLabel: le,
-                    contLabel: lc,
+                    contLabel: lp,
                     labels: s.labels,
                     frameDepth: this.frames.length,
                     scopeDepth: this.scopes.length,
@@ -5951,7 +6122,12 @@ export class LlEmitter {
                 });
                 this.emitBlock(s.body);
                 this.jumpTargets.pop();
-                B.br(lc);
+                B.br(lp);
+                if (lp !== lc) {
+                    B.startBlock(lp);
+                    this.emitWorkerLoopCheck(workerBudget);
+                    B.br(lc);
+                }
                 B.startBlock(le);
                 break;
             }
@@ -5963,7 +6139,6 @@ export class LlEmitter {
                 const le = B.newLabel("loop.e");
                 B.br(lb);
                 B.startBlock(lb);
-                this.emitWorkerLoopCheck(workerBudget);
                 this.jumpTargets.push({
                     kind: "loop",
                     brkLabel: le,
@@ -5977,6 +6152,7 @@ export class LlEmitter {
                 this.jumpTargets.pop();
                 B.br(lc);
                 B.startBlock(lc);
+                this.emitWorkerLoopCheck(workerBudget);
                 B.condBr(this.emitCondition(s.cond), lb, le);
                 B.startBlock(le);
                 break;
@@ -6136,12 +6312,11 @@ export class LlEmitter {
                         B.line(`store ptr ${fresh}, ptr ${slot}`);
                     }
                 };
-                const lu = s.update || capturedLets.length > 0 ? B.newLabel("loop.u") : lc;
-                freshenBindings();
                 const workerBudget = this.workerLoopBudget(s);
+                const lu = s.update || capturedLets.length > 0 || workerBudget !== null ? B.newLabel("loop.u") : lc;
+                freshenBindings();
                 B.br(lc);
                 B.startBlock(lc);
-                this.emitWorkerLoopCheck(workerBudget);
                 if (integerLoop && integerSlot) {
                     const receiver = this.emitStableReceiver(integerLoop.limitReceiver, []);
                     const lenPtr = B.tmp();
@@ -6182,6 +6357,7 @@ export class LlEmitter {
                 B.br(lu);
                 if (lu !== lc) {
                     B.startBlock(lu);
+                    this.emitWorkerLoopCheck(workerBudget);
                     freshenBindings();
                     if (integerLoop && integerSlot) {
                         const old = B.tmp();
@@ -6249,7 +6425,6 @@ export class LlEmitter {
                 const workerBudget = this.workerLoopBudget(s);
                 B.br(lc);
                 B.startBlock(lc);
-                this.emitWorkerLoopCheck(workerBudget);
                 const inBounds = B.tmp();
                 let cur;
                 if (snapshot && cursor && scratch) {
@@ -6265,7 +6440,7 @@ export class LlEmitter {
                     B.line(`${lenPtr} = getelementptr inbounds %ScrArr, ptr ${arr.name}, i32 0, i32 1`);
                     this.markMemoryPointer(lenPtr, "array:header");
                     B.line(`${rawLen} = load ${this.sizeType}, ptr ${lenPtr}${this.fieldAliasAttachment(lenPtr)}`);
-                    B.line(`${len} = sitofp ${this.sizeType} ${rawLen} to double`);
+                    B.line(`${len} = ${sizeToDouble(this.sizeType)} ${this.sizeType} ${rawLen} to double`);
                     B.line(`${inBounds} = fcmp olt double ${i}, ${len}`);
                     cur = i;
                 }
@@ -6323,6 +6498,7 @@ export class LlEmitter {
                 this.jumpTargets.pop();
                 B.br(lu);
                 B.startBlock(lu);
+                this.emitWorkerLoopCheck(workerBudget);
                 if (idxSlot) {
                     const i2 = B.tmp(), i3 = B.tmp();
                     B.line(`${i2} = load double, ptr ${idxSlot}`);
@@ -6528,7 +6704,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);
@@ -6874,7 +7050,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);
@@ -6905,8 +7085,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") {
@@ -6920,7 +7103,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 {
@@ -6945,6 +7135,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
@@ -6964,14 +7165,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 {
@@ -7007,8 +7215,122 @@ export class LlEmitter {
             e.name === "region.leave" ||
             e.name === "region.release")
             return this.emitRegionIntrinsic(e);
+        if (e.name.startsWith("itable."))
+            return this.emitInternTableIntrinsic(e);
         return emitIntrinsicExpr(this, e);
     }
+    /** InternTable's runtime calls (scr_itable.c). Table and entry handles
+     * are f64 values carrying pointer bits; entry values are 64-bit slots
+     * (double bits, a bool, or a pointer to an immortal value) that the
+     * table neither retains nor releases. Lookups and inserts of array keys
+     * throw a TypeError for keys longer than a table accepts. */
+    emitInternTableIntrinsic(e) {
+        const B = this.B;
+        // The runtime copies keys and stores published values without counts,
+        // so every operand is borrowed.
+        const args = emitBorrowedInputs(this, e.args);
+        if (B.isTerminated())
+            return { name: "", type: e.type };
+        const toPtr = (handle) => {
+            const bits = B.tmp(), ptr = B.tmp();
+            B.line(`${bits} = bitcast double ${handle} to i64`);
+            B.line(`${ptr} = inttoptr i64 ${bits} to ptr`);
+            return ptr;
+        };
+        const toHandle = (ptr) => {
+            const bits = B.tmp(), handle = B.tmp();
+            B.line(`${bits} = ptrtoint ptr ${ptr} to i64`);
+            B.line(`${handle} = bitcast i64 ${bits} to double`);
+            return { name: handle, type: e.type };
+        };
+        const keyCall = (op) => {
+            const kind = e.args[1].type.kind;
+            const key = kind === "string" ? "str" : kind === "array" ? "arr" : "f64";
+            const keyTy = key === "f64" ? "double" : "ptr";
+            const value = op === "insert" ? ", i64" : "";
+            this.declare(`declare ptr @scr_itable_${op}_${key}(ptr, ${keyTy}${value})`);
+            return `@scr_itable_${op}_${key}(ptr ${toPtr(args[0].name)}, ${keyTy} ${args[1].name}`;
+        };
+        switch (e.name) {
+            case "itable.open": {
+                this.declare(`declare ptr @scr_itable_open(ptr, i32)`);
+                const kind = B.tmp(), table = B.tmp();
+                B.line(`${kind} = fptosi double ${args[1].name} to i32`);
+                B.line(`${table} = call ptr @scr_itable_open(ptr ${args[0].name}, i32 ${kind})`);
+                return toHandle(table);
+            }
+            case "itable.find": {
+                const call = keyCall("find");
+                const entry = B.tmp();
+                B.line(`${entry} = call ptr ${call})`);
+                // Array keys longer than a table accepts throw a TypeError.
+                if (e.args[1].type.kind === "array")
+                    this.emitPendingCheck();
+                return toHandle(entry);
+            }
+            case "itable.insert": {
+                const value = args[2];
+                const ty = this.llType(value.type);
+                let slot = value.name;
+                if (ty === "double") {
+                    slot = B.tmp();
+                    B.line(`${slot} = bitcast double ${value.name} to i64`);
+                }
+                else if (ty === "i1") {
+                    slot = B.tmp();
+                    B.line(`${slot} = zext i1 ${value.name} to i64`);
+                }
+                else if (ty === "ptr") {
+                    slot = B.tmp();
+                    B.line(`${slot} = ptrtoint ptr ${value.name} to i64`);
+                }
+                else
+                    throw new InternalCompilerError(`llvm emitter bug: itable value of type ${ty}`);
+                const call = keyCall("insert");
+                const entry = B.tmp();
+                B.line(`${entry} = call ptr ${call}, i64 ${slot})`);
+                if (e.args[1].type.kind === "array")
+                    this.emitPendingCheck();
+                return toHandle(entry);
+            }
+            case "itable.value": {
+                // The handle's bits reach the address through memory: at -O0, x86
+                // FastISel folds inttoptr(bitcast double) into the load's address
+                // without moving the value out of its XMM register. Optimized
+                // builds turn the stack round trip back into one register move.
+                const carrier = B.slot();
+                B.entryAllocas.push(`${carrier} = alloca double`);
+                B.line(`store double ${args[0].name}, ptr ${carrier}`);
+                const bits = B.tmp(), entry = B.tmp();
+                B.line(`${bits} = load i64, ptr ${carrier}`);
+                B.line(`${entry} = inttoptr i64 ${bits} to ptr`);
+                const slot = B.tmp();
+                B.line(`${slot} = load i64, ptr ${entry}, align 8`);
+                const ty = this.llType(e.type);
+                const result = B.tmp();
+                if (ty === "double")
+                    B.line(`${result} = bitcast i64 ${slot} to double`);
+                else if (ty === "i1")
+                    B.line(`${result} = trunc i64 ${slot} to i1`);
+                else if (ty === "ptr")
+                    B.line(`${result} = inttoptr i64 ${slot} to ptr`);
+                else
+                    throw new InternalCompilerError(`llvm emitter bug: itable value of type ${ty}`);
+                // Stored values are immortal: owning one adds no count.
+                return isRefCounted(e.type)
+                    ? this.own({ name: result, type: e.type })
+                    : { name: result, type: e.type };
+            }
+            case "itable.size": {
+                this.declare(`declare double @scr_itable_size(ptr)`);
+                const size = B.tmp();
+                B.line(`${size} = call double @scr_itable_size(ptr ${toPtr(args[0].name)})`);
+                return { name: size, type: e.type };
+            }
+            default:
+                throw new InternalCompilerError(`llvm emitter bug: unknown intrinsic ${e.name}`);
+        }
+    }
     /** Lifetime regions in modules with lifetimeRegions (llvm/regions.ts).
      * Created with the class graph; null elsewhere. */
     regions = null;
@@ -7054,6 +7376,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);
@@ -7063,11 +7386,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),
@@ -7234,6 +7562,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.
@@ -7294,13 +7624,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
@@ -7364,7 +7695,15 @@ export class LlEmitter {
             matchMapRead(e, this.boxedUnionsById) !== null ||
             this.optionalArrayReads.get(e) !== null ||
             isScalarOptionalSource(e, this.unionSources) ||
-            this.scalarResultCall(e));
+            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. */
@@ -7503,6 +7842,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":
@@ -7520,9 +7868,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": {
@@ -7758,8 +8108,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);