@scriptc/compiler 0.3.2 → 0.3.3

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,6 +42,7 @@ 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";
@@ -52,7 +55,7 @@ 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";
@@ -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";
@@ -89,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 { 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();
@@ -439,6 +446,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 +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. */
@@ -624,7 +634,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 +674,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 +685,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 +734,15 @@ 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),
+        });
         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 +752,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 +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),
@@ -763,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);
@@ -796,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);
             }
@@ -1162,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
@@ -1215,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) => {
@@ -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}`);
@@ -2158,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
@@ -2398,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();
@@ -3050,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);
@@ -3713,6 +3767,7 @@ export class LlEmitter {
             case "searchParams":
             case "stats":
             case "fileHandle":
+            case "dir":
             case "spawnRes":
             case "child":
             case "childStream":
@@ -3755,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`);
@@ -3888,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). */
@@ -3939,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)
@@ -3952,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);
@@ -3960,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) {
@@ -3973,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")
@@ -3985,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;
@@ -4458,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);
@@ -4775,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}`;
@@ -4861,11 +4976,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 +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")
@@ -5484,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.
@@ -5542,10 +5693,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);
@@ -5710,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") {
@@ -5828,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);
@@ -5859,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);
@@ -6528,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);
@@ -6874,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);
@@ -6905,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") {
@@ -6920,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 {
@@ -6945,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
@@ -6964,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 {
@@ -7054,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);
@@ -7063,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),
@@ -7234,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.
@@ -7294,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
@@ -7364,7 +7558,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 +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":
@@ -7520,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": {
@@ -7758,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);