@scriptc/compiler 0.2.9 → 0.3.0

package/dist/backend/llvm/emitter.js

@@ -2,30 +2,12 @@ import { emitLlvmLayouts } from "./layouts.js";
 import { FIRST_EMITTED_CYC_KIND, inlineAllocSupported } from "./alloc.js";
 import { llvmBytes as llBytes } from "../literals.js";
 import { InternalCompilerError } from "../../errors.js";
-/** Lower typed IR to LLVM, using the runtime's C ABI.
- *
- * Reference-counted temporaries own one reference. Declarations, assignments,
- * returns and arguments move that ownership; frame and scope exits release
- * everything remaining. Slot-backed entries release the slot's current value.
- *
- * Exceptions use a pending flag and explicit cleanup edges. Throwing calls
- * test scr_exc_pending before consuming results, release the scopes crossed,
- * and branch to the innermost handler or return to the caller. Catch bindings
- * hold ScrCaught snapshots; finally runs on normal, throwing and returning
- * paths. This keeps ownership cleanup intact without nonlocal jumps.
- *
- * Program objects are emitted by the packaged LLVM helper and linked with
- * runtime packs. Sanitizer development builds use an external LLVM driver.
- * Dynamic values and islands share the runtime ABI; embedded npm modules use
- * compressed source tables that the runtime inflates on demand.
- */
 import { createHash } from "node:crypto";
-import { deflateRawSync } from "node:zlib";
 import { endsWithJump, matchStringSelfConcat, streamTypedRefEligible, undefinedArmTag, } from "../../ir/analysis.js";
 import { emitLibraryIdentityLines } from "../library-identity-markers.js";
 import { loopTestsEveryIteration } from "../loop-polls.js";
 import { CAUGHT, ffiCallbackType, isDynTypedRefType, isFfiContextParam, isRefCounted, isUnitType, POINTER_KINDS, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, typeEquals, typeKey, STRING, VOID, } from "../../ir/ir.js";
-import { moduleRuntimeFeatures, moduleEmbedsBuiltin, moduleEmbedsCompressedNpm, NPM_COMPRESS_MIN, } from "../../ir/runtime-features.js";
+import { moduleRuntimeFeatures } from "../../ir/runtime-features.js";
 import { matchIntegerArrayForLoop, matchIntegerBytesForLoop, matchIntegerCountedForLoop, } from "../../ir/integer-loops.js";
 import { emitCountedLoopLimit } from "./counted-loops.js";
 import { emitLiteralSwitch } from "./switch-dispatch.js";
@@ -36,6 +18,7 @@ import { scalarizeNumericRecords } from "../../ir/scalar-records.js";
 import { specializeNumericCalls } from "../../ir/numeric-call-specialization.js";
 import { everyExprChild, everyStmtChild, everyStmtList } from "../../ir/traverse.js";
 import { analyzeIntegerRanges, INT32_RANGE } from "../../ir/integer-ranges.js";
+import { unshareNodes } from "../../ir/unshare.js";
 import { analyzeInt32Slots } from "../../ir/int32-slots.js";
 import { analyzeFinalFields, constructorClass } from "../../ir/final-fields.js";
 import { foldConstantGlobals } from "../../ir/constant-globals.js";
@@ -56,10 +39,11 @@ 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 { emitBorrowedFieldSequence, guardedValue } from "./borrowed-receivers.js";
-import { emitBorrowedInput } from "./borrowed-inputs.js";
+import { borrowableInputs, emitBorrowedInput } 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";
@@ -75,9 +59,9 @@ import { emitBorrowedResultCall, emitCallExpr } from "./expr-calls.js";
 import { emitDynamicExpr } from "./expr-dynamic.js";
 import { emitIntrinsicExpr, emitSerializationExpr, emitAsyncExpr } from "./expr-async.js";
 import { PublishWalkers } from "./publish.js";
+import { computeImmutableFields, stableGlobals } from "../immutability.js";
 import { computePublishedTypes } from "../publication.js";
-import { emitJsInteropExpr, emitExpr } from "./expr-dispatch.js";
-import { emitJsMarshal, emitJsOp, emitJsExit, islandAdapter, islandTypedAdapter, } from "./expr-island.js";
+import { emitExpr } from "./expr-dispatch.js";
 import { dynKind, raceAdapterFor, genResultThunkFor, childExitThunkFor, childExitSignalThunkFor, childDataThunkFor, execFileThunkFor, ipcMessageThunkFor, ipcSendThunkFor, emitterFixedAdapter, wrapEmitterListener, unwrapNullableClosure, closeBindThunkFor, closeOverrideWrapFor, } from "./expr-callbacks.js";
 import { streamDataAdapter, streamDoneFnFor, cryptoBytesThunkFor, fsRenameThunkFor, streamCbThunkFor, zlibBytesThunkFor, } from "./expr-stream-callbacks.js";
 import { emitStableReceiver, resolveThunkFor, tagInSet, arrPush, emitArrayCopyLoop, emitStrIntrinsic, emitArrIntrinsic, emitDiscardedSplice, wrapNullable, emitMapNew, mapSet, emitMapLikeIntrinsic, emitSetNew, } from "./expr-containers.js";
@@ -97,7 +81,7 @@ 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 } from "./map-number-lookup.js";
+import { NUMBER_MAP_ENTRY_DECL, STRING_MAP_ENTRY_DECL } from "./map-number-lookup.js";
 import { STRING_READ_HELPERS } from "./string-reads.js";
 import { emitConcatInputs, emitMixedConcat, numberPart, stringParts, } from "./string-construction.js";
 import { arrNewCall, boxAccess, boxNewCall, boxReleaseSym, computeTraced, elemAccess, emitInlineRcHelpers, emitNullableRetainWrappers, FN_ATTRS, inlineRcDecls, llFieldType, releaseSym, retainSym, traceArg, typedRefConstructor, vAdapters, } from "./shapes.js";
@@ -127,14 +111,18 @@ function ffiCallbackDummyLl(callback) {
             return "i32 0";
     }
 }
-export function emitLlvmModule(mod, options = {}) {
+export function emitLlvmModule(input, options = {}) {
+    // Facts are keyed by node identity: emit the same module whether it was
+    // lowered in memory or read back from its serialized form.
+    const mod = unshareNodes(input);
     // Keep source storage intact for debugger inspection in dev builds.
     return new LlEmitter(options.debugSources === undefined
         ? scalarizeNumericRecords(specializeNumericCalls(foldConstantGlobals(mod), mangleFunction))
         : mod, options).emit();
 }
 /** Keep large translation units below the host's single-string limit. */
-export function emitLlvmModuleSource(mod, options = {}) {
+export function emitLlvmModuleSource(input, options = {}) {
+    const mod = unshareNodes(input);
     const parts = new LlEmitter(options.debugSources === undefined
         ? scalarizeNumericRecords(specializeNumericCalls(foldConstantGlobals(mod), mangleFunction))
         : mod, options).emitParts();
@@ -302,6 +290,12 @@ export class LlEmitter {
      * fiberless-async analysis scans it for suspension entry points. */
     fnDefText = new Map();
     referenceEffects;
+    /** Field-sensitive reference writes (null in debug builds). */
+    referenceWrites = null;
+    borrowedReturnKeyCache = new Map();
+    /** The statement list being emitted and the current index, for blocks
+     * whose bindings end with the list (emitBlock and function bodies). */
+    stmtCursor = null;
     optionalArrayReads;
     checkedNarrows;
     callArrayReads = new Map();
@@ -345,6 +339,9 @@ export class LlEmitter {
     ffiHasRetainedCallback;
     ffiHasForeignCallback;
     globalTypes = new Map();
+    /** Module constants that keep one value once initialized
+     * (immutability.ts stableGlobals). */
+    stableGlobals = new Set();
     tdzGlobals = new Map();
     constantNumericTables;
     /** May-throw analysis (computeMayThrow): pending
@@ -360,6 +357,13 @@ export class LlEmitter {
     /** Static types whose values can be published (@scriptc/threads): their
      * stores carry the frozen-object guard. Null without publish calls. */
     publishedTypes;
+    /** Construction-only class and record fields (immutability.ts); null
+     * where the facts are disabled. */
+    immutableFields;
+    /** Constructor function names: their bodies may still write their own
+     * `this`'s construction-only fields. */
+    constructorFunctions;
+    inConstructor = false;
     /** Method names with at least one may-throw implementation — the
      * virtualCall pending check's key. */
     mayThrowMethods = new Set();
@@ -436,6 +440,12 @@ export class LlEmitter {
     initializerBindings;
     /** Whole-program int32 storage and parameter/result facts. */
     int32Slots;
+    /** Immutable module constants (contract types) whose graphs become
+     * immortal once initialized: their reads need no reference counting. */
+    immortalGlobals;
+    /** ProgramLifetime hierarchy roots (contract types): their instances are
+     * immortal from construction (classes.ts programLifetimeClass). */
+    programLifetime;
     numericLocals = new Map();
     captureIds = new Set();
     /** Active induction bindings retain their width independently of size_t. */
@@ -495,6 +505,8 @@ export class LlEmitter {
         this.constantNumericTables = findConstantNumericTables(mod);
         this.initializerBindings = findInitializerBindings(mod);
         this.int32Slots = analyzeInt32Slots(mod);
+        this.immortalGlobals = new Set(mod.contracts?.immortalGlobals ?? []);
+        this.programLifetime = new Set(mod.contracts?.programLifetime ?? []);
         this.finalFields = analyzeFinalFields(mod);
         this.sizeType = options.pointerBits === 32 ? "i32" : "i64";
         this.ffiExtendNarrowIntegers =
@@ -549,6 +561,8 @@ export class LlEmitter {
         this.workerEntryPolls = mt.workerEntryPolls ?? null;
         this.stackChecks = mt.stackChecks ?? null;
         this.publishedTypes = computePublishedTypes(mod);
+        this.immutableFields = computeImmutableFields(mod);
+        this.constructorFunctions = new Set((mod.classes ?? []).map((c) => `%${c.name}.constructor`));
         this.indirectMayThrow = mt.indirect || mod.workers === true;
         for (const cls of mod.classes ?? []) {
             for (const m of cls.methods ?? []) {
@@ -568,6 +582,8 @@ export class LlEmitter {
         this.optionalArrayReads = new OptionalArrayReads(this.fnByName, this.unionsById, (id) => this.nullableUnions.has(id));
         this.checkedNarrows = new CheckedNarrows(this.fnByName);
         this.referenceEffects = new ReferenceEffects(this.fnByName, (call) => this.optionalArrayReads.get(call) !== null, mod.classes ?? []);
+        if (this.debug === null)
+            this.referenceWrites = new ReferenceWrites(this.fnByName, mod.classes ?? [], (call) => this.optionalArrayReads.get(call) !== null, new Set((mod.globals ?? []).map((g) => g.id)), { unions: mod.unions, records: mod.records }, this.immutableFields);
         const walkParameters = new Map();
         if (this.debug === null) {
             const host = {
@@ -575,9 +591,10 @@ export class LlEmitter {
                 borrowsWithoutOwning: (e) => this.borrowsWithoutOwning(e),
             };
             for (const fn of this.fnByName.values()) {
-                if (!this.referenceEffects.functions.has(fn.name))
+                const preserving = this.referenceEffects.functions.has(fn.name);
+                if (!preserving && this.referenceWrites === null)
                     continue;
-                const walks = findWalkBorrows(fn, host);
+                const walks = findWalkBorrows(fn, preserving ? host : this.unwrittenWalkHost(fn, host));
                 if (walks.size === 0)
                     continue;
                 this.walkBorrowsByFunction.set(fn.name, walks);
@@ -661,6 +678,7 @@ export class LlEmitter {
             },
             pendingTestLines: (dest) => this.pendingTestLines(dest),
             virtualEntry: (implFn) => this.virtualEntry(implFn),
+            programLifetime: this.programLifetime,
         };
         this.walkers = new LlWalkers(this.shapeHost);
         this.dyn = new LlDyn(this.shapeHost);
@@ -682,6 +700,7 @@ export class LlEmitter {
             if (g.tdz)
                 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.
         const classes = mod.classes ?? [];
@@ -1087,23 +1106,6 @@ export class LlEmitter {
         const asyncDefs = this.emitAsyncScaffolding();
         const ffiCallbacks = this.emitFfiCallbackDefs();
         const hasNoInlineRecordClone = [...this.recordCloneShapes].some((shapeId) => (this.recordsById.get(shapeId)?.fields.length ?? 0) >= 16);
-        const embedded = this.mod.embedded;
-        const usesIsland = embedded !== undefined && embedded.modules.length > 0;
-        const storeNpmText = (text) => {
-            const plain = Buffer.from(text, "utf8");
-            if (text.length < NPM_COMPRESS_MIN)
-                return { bytes: plain, raw: 0 };
-            const deflated = deflateRawSync(plain, { level: 9 });
-            return deflated.length < plain.length
-                ? { bytes: deflated, raw: plain.length }
-                : { bytes: plain, raw: 0 };
-        };
-        const npmStored = usesIsland
-            ? embedded.modules.map((m) => ({
-                src: storeNpmText(m.source),
-                esm: m.esm === undefined ? null : storeNpmText(m.esm),
-            }))
-            : [];
         // Module globals, FIRST OCCURRENCE per id: a class-expression static
         // instantiated through several mixin applications registers one global
         // id several times (2041-mixin-values) — C's tentative definitions
@@ -1167,24 +1169,14 @@ export class LlEmitter {
         const usesDgram = runtimeFeatures.dgram;
         const usesHttp2 = runtimeFeatures.http2;
         const usesHttp = runtimeFeatures.http;
-        // Fetch-referencing programs register the native fetch bridge before
-        // any island entry (the engine's lazy boot consults it) — native/executable.ts
-        // compiles scr_fetch.c on the same predicate.
+        // Fetch-referencing programs register native fetch before main.
+        // Runtime selection compiles scr_fetch.c on the same predicate.
         const usesFetch = runtimeFeatures.fetch;
-        const embedsZlib = moduleEmbedsBuiltin(this.mod, "node:zlib");
-        const embedsNet = moduleEmbedsBuiltin(this.mod, "node:http") ||
-            moduleEmbedsBuiltin(this.mod, "node:https") ||
-            moduleEmbedsBuiltin(this.mod, "node:net") ||
-            moduleEmbedsBuiltin(this.mod, "node:tls");
-        const snapshotsTlsCa = runtimeFeatures.tls ||
-            runtimeFeatures.tlsCa ||
-            moduleEmbedsBuiltin(this.mod, "node:https") ||
-            moduleEmbedsBuiltin(this.mod, "node:tls");
+        const snapshotsTlsCa = runtimeFeatures.tls || runtimeFeatures.tlsCa;
         // The process verdict has the same precedence as the C reference
         // emitter: node:test owns the final status when present; otherwise an
         // embedded process.exitCode owns it; ordinary programs return zero.
         const usesNodeTest = runtimeFeatures.nodeTest;
-        const programExitUsesIsland = !usesNodeTest && usesIsland;
         // Declared NOW — the extern block flushes before main assembles.
         if (usesEvents)
             this.declare(`declare void @scr_events_install()`);
@@ -1221,19 +1213,6 @@ export class LlEmitter {
             this.declare(`declare void @scr_http_dyn_install()`);
         if (usesFetch)
             this.declare(`declare void @scr_fetch_install()`);
-        if (embedsZlib)
-            this.declare(`declare void @scr_zlib_island_install()`);
-        if (embedsNet)
-            this.declare(`declare void @scr_net_island_install()`);
-        if (usesIsland) {
-            this.declare(`declare void @scr_island_modules(ptr, ${this.sizeType}, ptr, ${this.sizeType})`);
-            this.declare(`declare void @scr_island_entry_module(ptr)`);
-            this.declare(`declare i32 @scr_island_exit_code()`);
-            if (moduleEmbedsCompressedNpm(this.mod)) {
-                this.declare(`declare void @scr_island_set_inflate(ptr)`);
-                this.declare(`declare zeroext i1 @scr_zlib_inflate_exact(ptr, ${this.sizeType}, ptr, ${this.sizeType})`);
-            }
-        }
         if (usesNodeTest)
             this.declare(`declare i32 @scr_test_exit_code()`);
         if (snapshotsTlsCa) {
@@ -1272,7 +1251,6 @@ export class LlEmitter {
         // fibers as abandoned, so the RC audit downgrades exactly like the
         // async loop-exhaustion story.
         const runsLoop = this.usesTimers ||
-            usesIsland ||
             this.ffiHasForeignCallback ||
             this.mod.functions.some((f) => f.async === true || f.generator !== undefined);
         const uncaughtReleases = entryMayThrow && !asyncEntry ? globalReleaseLines("gu") : [];
@@ -1299,9 +1277,6 @@ export class LlEmitter {
             this.declare(`declare void @scr_promise_rethrow_top_level(ptr)`);
             this.declare(`declare void @scr_promise_release(ptr)`);
             this.declare(`declare void @scr_exit_code_note(i32)`);
-            if (programExitUsesIsland && inlineExitListeners) {
-                this.declare(`declare ${this.sizeType} @scr_island_exit_code_version()`);
-            }
         }
         const topPendingExitLines = () => {
             if (!asyncEntry)
@@ -1310,28 +1285,18 @@ export class LlEmitter {
             if (usesNodeTest) {
                 lines.push(`  %tla_program_exit = call i32 @scr_test_exit_code()`);
             }
-            else if (usesIsland) {
-                lines.push(`  %tla_program_exit = call i32 @scr_island_exit_code()`);
-            }
-            if (usesNodeTest || usesIsland) {
+            if (usesNodeTest) {
                 lines.push(`  %tla_program_exit_zero = icmp eq i32 %tla_program_exit, 0`, `  %tla_exit_status = select i1 %tla_program_exit_zero, i32 %tla_status, i32 %tla_program_exit`);
             }
-            const exitStatus = usesNodeTest || usesIsland ? "%tla_exit_status" : "%tla_status";
-            const tracksIslandExit = programExitUsesIsland && inlineExitListeners;
-            if (tracksIslandExit) {
-                lines.push(`  %tla_exit_version = call ${this.sizeType} @scr_island_exit_code_version()`);
-            }
+            const exitStatus = usesNodeTest ? "%tla_exit_status" : "%tla_status";
             // finish_top_level initially notes 13. Replace that hint before exit
             // listeners run when a higher-priority verdict was already selected.
             lines.push(`  call void @scr_exit_code_note(i32 ${exitStatus})`);
             for (const line of exitListenerLines("xp"))
                 lines.push(line);
-            if (tracksIslandExit) {
-                lines.push(`  %tla_exit_version_after = call ${this.sizeType} @scr_island_exit_code_version()`, `  %tla_exit_changed = icmp ne ${this.sizeType} %tla_exit_version_after, %tla_exit_version`, `  br i1 %tla_exit_changed, label %tla_exit_updated, label %tla_exit_unchanged`, `tla_exit_updated:`, `  %tla_listener_exit = call i32 @scr_island_exit_code()`, `  call void @scr_exit_code_note(i32 %tla_listener_exit)`, `  br label %tla_exit_done`, `tla_exit_unchanged:`, `  br label %tla_exit_done`, `tla_exit_done:`, `  %tla_final_exit = phi i32 [ %tla_listener_exit, %tla_exit_updated ], [ ${exitStatus}, %tla_exit_unchanged ]`);
-            }
             for (const line of topPendingReleases)
                 lines.push(line);
-            lines.push(`  ret i32 ${tracksIslandExit ? "%tla_final_exit" : exitStatus}`);
+            lines.push(`  ret i32 ${exitStatus}`);
             return lines;
         };
         // LIBRARY mode: the runtime entry points the generated library
@@ -1403,12 +1368,14 @@ export class LlEmitter {
             `%ScrFfiTable = type { ptr, ${this.sizeType}, ${this.sizeType}, ptr, i8, ptr, ptr, ${this.sizeType}, ${this.sizeType}, ${this.sizeType}, ptr, ptr }`,
             `%ScrRegex = type { ${this.sizeType}, ptr, ptr, ptr, double, ptr, ptr }`,
             // ScrArr mirrors scr_runtime.h field-for-field: { rc, len, cap, elem,
-            // elem_retain, elem_release, elem_trace, data, present, ext }, where
-            // ext points at the out-of-line sparse, property and metadata storage
-            // (NULL until first used). Live dynamic stream commits swap its dense,
-            // presence and out-of-line storage while preserving the target
-            // object's identity.
-            `%ScrArr = type { ${this.sizeType}, ${this.sizeType}, ${this.sizeType}, i32, ptr, ptr, ptr, ptr, ptr, ptr }`,
+            // cyc, ops, data, present, ext } (field numbers in SCR_ARR_FIELD),
+            // where ops points at the element type's constant RC descriptor
+            // (%ScrArrOps, SCR_ELEM_REF only) and ext at the out-of-line sparse,
+            // property and metadata storage (NULL until first used). Live dynamic
+            // stream commits swap its dense, presence and out-of-line storage while
+            // preserving the target object's identity.
+            `%ScrArr = type { ${this.sizeType}, ${this.sizeType}, ${this.sizeType}, i32, i32, ptr, ptr, ptr, ptr }`,
+            `%ScrArrOps = type { ptr, ptr, ptr }`,
             // The ScrMap prefix { rc, key_kind, val_kind, val_retain, val_release,
             // val_trace, key_retain, key_release, key_trace } — the inline RC
             // fast paths test the two trace slots (shapes.ts).
@@ -1416,14 +1383,19 @@ export class LlEmitter {
                 ? []
                 : [`%ScrMapRc = type { ${this.sizeType}, i32, i32, ptr, ptr, ptr, ptr, ptr, ptr }`]),
             // The complete ScrMap and its { key, val, hash } entry, read by the
-            // inline number-key lookup (sc_map_entry_f64): entries is field 12,
-            // the direct index and its length fields 18 and 19.
-            ...(this.decls.has(NUMBER_MAP_ENTRY_DECL)
+            // inline number-key lookup (sc_map_entry_f64): field 11 is the i64
+            // absent-key filter, entries is field 13, the direct index and its
+            // length fields 19 and 20.
+            ...(this.decls.has(NUMBER_MAP_ENTRY_DECL) || this.decls.has(STRING_MAP_ENTRY_DECL)
                 ? [
-                    `%ScrMapIx = type { ${this.sizeType}, i32, i32, ptr, ptr, ptr, ptr, ptr, ptr, ${this.sizeType}, ${this.sizeType}, ${this.sizeType}, ptr, ${this.sizeType}, ptr, ${this.sizeType}, ptr, ptr, ptr, ${this.sizeType} }`,
-                    `%ScrMapEntry = type { i64, i64, i64 }`,
+                    `%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)
+                ? [`%ScrMapEntry = type { i64, i64, i64 }`]
+                : []),
             // The runtime error prefix { rc, vt, name, message, code, cause } and the
             // class-object shape { rc, pre, post, ctor, name } — field reads on
             // builtin errors and classval loads GEP through these.
@@ -1551,56 +1523,16 @@ export class LlEmitter {
             // strings — a no-op.
             const n = inst.slots.length;
             const present = n === 0 ? "zeroinitializer" : `[ ${inst.slots.map(() => "i8 1").join(", ")} ]`;
-            out.push(`@${inst.sym}_data = internal constant [${n} x ptr] [ ${inst.slots.map((s) => `ptr ${s}`).join(", ")} ]`, `@${inst.sym}_present = internal constant [${n} x i8] ${present}`, `@${inst.sym} = internal global %ScrArr { ${this.sizeType} -1, ${this.sizeType} ${n}, ${this.sizeType} ${n}, i32 2, ptr null, ptr null, ptr null, ptr @${inst.sym}_data, ptr @${inst.sym}_present, ptr null }`);
+            out.push(`@${inst.sym}_data = internal constant [${n} x ptr] [ ${inst.slots.map((s) => `ptr ${s}`).join(", ")} ]`, `@${inst.sym}_present = internal constant [${n} x i8] ${present}`, `@${inst.sym} = internal global %ScrArr { ${this.sizeType} -1, ${this.sizeType} ${n}, ${this.sizeType} ${n}, i32 2, i32 0, ptr null, ptr @${inst.sym}_data, ptr @${inst.sym}_present, ptr null }`);
         }
         if (this.templateStringsInstances.size > 0)
             out.push(``);
-        const islandEntryPath = usesIsland ? this.cstr(this.mod.sourceFile) : null;
         for (const [text, c] of this.cstrs) {
             // NUL-terminated byte-array constants for scr_jb_puts and indentation.
             out.push(`@${c.sym} = internal constant [${c.len + 1} x i8] c"${llStrBytes(text)}"`);
         }
         if (this.cstrs.size > 0)
             out.push(``);
-        if (usesIsland) {
-            const fmt = { esm: 0, cjs: 1, json: 2 };
-            const edgeKind = { any: 0, import: 1, require: 2 };
-            embedded.modules.forEach((m, i) => {
-                const stored = npmStored[i];
-                const key = Buffer.from(m.key, "utf8");
-                out.push(`@sc_npm_key_${i} = internal constant [${key.length + 1} x i8] c"${llBytes(key)}"`, `@sc_npm_src_${i} = internal constant [${stored.src.bytes.length + 1} x i8] c"${llBytes(stored.src.bytes)}"`);
-                if (stored.esm !== null) {
-                    out.push(`@sc_npm_esm_${i} = internal constant [${stored.esm.bytes.length + 1} x i8] c"${llBytes(stored.esm.bytes)}"`);
-                }
-            });
-            const moduleRows = embedded.modules.map((m, i) => {
-                const stored = npmStored[i];
-                const esm = stored.esm === null
-                    ? `ptr null, ${this.sizeType} 0, ${this.sizeType} 0`
-                    : `ptr @sc_npm_esm_${i}, ${this.sizeType} ${stored.esm.bytes.length}, ${this.sizeType} ${stored.esm.raw}`;
-                return (`%ScrIslandModule { ptr @sc_npm_key_${i}, ptr @sc_npm_src_${i}, ` +
-                    `${this.sizeType} ${stored.src.bytes.length}, ${this.sizeType} ${stored.src.raw}, ` +
-                    `i32 ${fmt[m.format]}, ${esm} }`);
-            });
-            out.push(`@sc_npm_modules = internal constant [${moduleRows.length} x %ScrIslandModule] [ ${moduleRows.join(", ")} ]`);
-            embedded.edges.forEach((edge, i) => {
-                const parts = [
-                    ["from", edge.from],
-                    ["spec", edge.specifier],
-                    ["to", edge.to],
-                ];
-                for (const [part, text] of parts) {
-                    const bytes = Buffer.from(text, "utf8");
-                    out.push(`@sc_npm_edge_${i}_${part} = internal constant [${bytes.length + 1} x i8] c"${llBytes(bytes)}"`);
-                }
-            });
-            if (embedded.edges.length > 0) {
-                const edgeRows = embedded.edges.map((edge, i) => `%ScrIslandEdge { ptr @sc_npm_edge_${i}_from, ptr @sc_npm_edge_${i}_spec, ` +
-                    `ptr @sc_npm_edge_${i}_to, i32 ${edgeKind[edge.kind]} }`);
-                out.push(`@sc_npm_edges = internal constant [${edgeRows.length} x %ScrIslandEdge] [ ${edgeRows.join(", ")} ]`);
-            }
-            out.push(``);
-        }
         for (const line of ffiCallbacks.globals)
             out.push(line);
         if (ffiCallbacks.globals.length > 0)
@@ -1714,16 +1646,7 @@ export class LlEmitter {
             : []), 
         // fs.watch programs fill the loop's watch hooks the same way —
         // scr_watch.c links only when this line is emitted.
-        ...(usesFsWatch ? [`  call void @scr_watch_install()`] : []), ...(this.ffiHasForeignCallback ? [`  call void @scr_ffi_install()`] : []), ...(snapshotsTlsCa ? [`  call void @scr_tls_ca_install()`] : []), ...(usesFetch ? [`  call void @scr_fetch_install()`] : []), ...(embedsZlib ? [`  call void @scr_zlib_island_install()`] : []), ...(embedsNet ? [`  call void @scr_net_island_install()`] : []), ...(usesNet ? [`  call void @scr_net_install()`, `  call void @scr_net_dyn_install()`] : []), ...(usesHttp ? [`  call void @scr_http_dyn_install()`] : []), ...(usesDgram ? [`  call void @scr_dgram_install()`] : []), ...(usesHttp2 ? [`  call void @scr_http2_dyn_install()`] : []), ...(usesStream ? [`  call void @scr_stream_install()`] : []), `  call void @scr_lib_init(i32 %argc, ptr %argv)`, ...(usesIsland
-            ? [
-                `  call void @scr_island_entry_module(ptr ${islandEntryPath})`,
-                ...(moduleEmbedsCompressedNpm(this.mod)
-                    ? [`  call void @scr_island_set_inflate(ptr @scr_zlib_inflate_exact)`]
-                    : []),
-                `  call void @scr_island_modules(ptr @sc_npm_modules, ${this.sizeType} ${embedded.modules.length}, ` +
-                    `ptr ${embedded.edges.length > 0 ? "@sc_npm_edges" : "null"}, ${this.sizeType} ${embedded.edges.length})`,
-            ]
-            : []), ...(asyncEntry
+        ...(usesFsWatch ? [`  call void @scr_watch_install()`] : []), ...(this.ffiHasForeignCallback ? [`  call void @scr_ffi_install()`] : []), ...(snapshotsTlsCa ? [`  call void @scr_tls_ca_install()`] : []), ...(usesFetch ? [`  call void @scr_fetch_install()`] : []), ...(usesNet ? [`  call void @scr_net_install()`, `  call void @scr_net_dyn_install()`] : []), ...(usesHttp ? [`  call void @scr_http_dyn_install()`] : []), ...(usesDgram ? [`  call void @scr_dgram_install()`] : []), ...(usesHttp2 ? [`  call void @scr_http2_dyn_install()`] : []), ...(usesStream ? [`  call void @scr_stream_install()`] : []), `  call void @scr_lib_init(i32 %argc, ptr %argv)`, ...(asyncEntry
             ? [`  %top = call ptr @${mangleAsyncSpawn(this.mod.entry)}()`]
             : [`  call void @${mangleFunction(this.mod.entry)}()`]), 
         // Uncaught exception from top-level code: Node exits 1.
@@ -1810,9 +1733,7 @@ export class LlEmitter {
             ]
             : []), ...exitListenerLines("xn"), ...globalReleases, ...(usesNodeTest
             ? [`  %test_exit = call i32 @scr_test_exit_code()`, `  ret i32 %test_exit`]
-            : usesIsland
-                ? [`  %island_exit = call i32 @scr_island_exit_code()`, `  ret i32 %island_exit`]
-                : [`  %native_exit = call i32 @scr_exit_code_hint_get()`, `  ret i32 %native_exit`]), `}`, ``, ...this.inlineRcTail(flushedDecls), 
+            : [`  %native_exit = call i32 @scr_exit_code_hint_get()`, `  ret i32 %native_exit`]), `}`, ``, ...this.inlineRcTail(flushedDecls), 
         // sanitize_address is inert under the plain pipeline; the sanitized
         // lane's -fsanitize=address link activates instrumentation over the
         // emitted functions too (the runtime TUs get theirs from clang).
@@ -2078,11 +1999,44 @@ export class LlEmitter {
             const sz = this.sizeType;
             let mapTmp = 0;
             const mapIndex = exactIndexLines("%k", "%nd", sz, () => `%ix${mapTmp++}`);
-            defs.push(`define internal ptr @sc_map_entry_f64(ptr %m, double %k) ${FN_ATTRS} {`, `entry:`, `  %ndp = getelementptr inbounds %ScrMapIx, ptr %m, i32 0, i32 19`, `  %nd = load ${sz}, ptr %ndp`, 
+            defs.push(`define internal ptr @sc_map_entry_f64(ptr %m, double %k) ${FN_ATTRS} {`, `entry:`, `  %ndp = getelementptr inbounds %ScrMapIx, ptr %m, i32 0, i32 20`, `  %nd = load ${sz}, ptr %ndp`, 
             // A non-integral key inside the table is as absent as one outside it.
             ...mapIndex.lines.map((line) => `  ${line}`), `  br i1 ${mapIndex.ok}, label %slot, label %outside`, `slot:`, sz === "i64"
                 ? `  %i = add i64 ${mapIndex.wide}, 0`
-                : `  %i = trunc i64 ${mapIndex.wide} to ${sz}`, `  %dp = getelementptr inbounds %ScrMapIx, ptr %m, i32 0, i32 18`, `  %dense = load ptr, ptr %dp`, `  %sp = getelementptr inbounds i32, ptr %dense, ${sz} %i`, `  %s = load i32, ptr %sp`, `  %empty = icmp eq i32 %s, 0`, `  br i1 %empty, label %miss, label %hit`, `hit:`, `  %e32 = sub i32 %s, 1`, sz === "i32" ? `  %e = add i32 %e32, 0` : `  %e = zext i32 %e32 to ${sz}`, `  %ep = getelementptr inbounds %ScrMapIx, ptr %m, i32 0, i32 12`, `  %entries = load ptr, ptr %ep`, `  %found = getelementptr inbounds %ScrMapEntry, ptr %entries, ${sz} %e`, `  ret ptr %found`, `miss:`, `  ret ptr null`, `outside:`, `  %dense.any = icmp ne ${sz} %nd, 0`, `  br i1 %dense.any, label %miss, label %slow`, `slow:`, `  %r = call ptr @scr_map_entry_f64(ptr %m, double %k)`, `  ret ptr %r`, `}`, ``);
+                : `  %i = trunc i64 ${mapIndex.wide} to ${sz}`, `  %dp = getelementptr inbounds %ScrMapIx, ptr %m, i32 0, i32 19`, `  %dense = load ptr, ptr %dp`, `  %sp = getelementptr inbounds i32, ptr %dense, ${sz} %i`, `  %s = load i32, ptr %sp`, `  %empty = icmp eq i32 %s, 0`, `  br i1 %empty, label %miss, label %hit`, `hit:`, `  %e32 = sub i32 %s, 1`, sz === "i32" ? `  %e = add i32 %e32, 0` : `  %e = zext i32 %e32 to ${sz}`, `  %ep = getelementptr inbounds %ScrMapIx, ptr %m, i32 0, i32 13`, `  %entries = load ptr, ptr %ep`, `  %found = getelementptr inbounds %ScrMapEntry, ptr %entries, ${sz} %e`, `  ret ptr %found`, `miss:`, `  ret ptr null`, `outside:`, `  %dense.any = icmp ne ${sz} %nd, 0`, `  br i1 %dense.any, label %miss, label %slow`, `slow:`, `  %r = call ptr @scr_map_entry_f64(ptr %m, double %k)`, `  ret ptr %r`, `}`, ``);
+        }
+        // String-key Map/Set lookups test the map's absent-key filter inline
+        // (scr_map.c scr_map_filter_bits): a key whose two filter bits are not
+        // both set is absent, so most misses on small and medium maps return
+        // without a call. On 64-bit targets the key's cached hash h is the high
+        // half of its capacity word, the runtime's widened hash is (h << 32) | h,
+        // and the filter reads its bits 44..55, which are the capacity word's
+        // own. A key without a cached hash, and every possible hit, take the
+        // runtime lookup.
+        if (this.decls.has(STRING_MAP_ENTRY_DECL)) {
+            defs.push(`define internal ptr @sc_map_entry_str(ptr %m, ptr %k) ${FN_ATTRS} {`, `entry:`, ...(this.sizeType === "i64"
+                ? [
+                    `  %fp = getelementptr inbounds %ScrMapIx, ptr %m, i32 0, i32 11`,
+                    `  %filter = load i64, ptr %fp`,
+                    `  %capp = getelementptr inbounds %ScrStr, ptr %k, i32 0, i32 2`,
+                    `  %cap = load i64, ptr %capp`,
+                    `  %cached = icmp uge i64 %cap, 4294967296`,
+                    `  br i1 %cached, label %test, label %slow`,
+                    `test:`,
+                    `  %s1 = lshr i64 %cap, 44`,
+                    `  %i1 = and i64 %s1, 63`,
+                    `  %b1 = shl i64 1, %i1`,
+                    `  %s2 = lshr i64 %cap, 50`,
+                    `  %i2 = and i64 %s2, 63`,
+                    `  %b2 = shl i64 1, %i2`,
+                    `  %bits = or i64 %b1, %b2`,
+                    `  %have = and i64 %filter, %bits`,
+                    `  %maybe = icmp eq i64 %have, %bits`,
+                    `  br i1 %maybe, label %slow, label %absent`,
+                    `absent:`,
+                    `  ret ptr null`,
+                ]
+                : [`  br label %slow`]), `slow:`, `  %r = call ptr @scr_map_entry_str(ptr %m, ptr %k)`, `  ret ptr %r`, `}`, ``);
         }
         // String comparisons enter through small internal wrappers that LLVM
         // inlines at each site: interned literals and shared values compare by
@@ -2261,8 +2215,8 @@ export class LlEmitter {
      * mentions (transitively), contains no suspension entry point. Such a
      * body always completes before the call returns, which is exactly the
      * behavior of a fiber that never suspends. Excluded conservatively:
-     * wasm32 (its coroutine lowering owns async bodies), programs embedding
-     * the dynamic engine, module-evaluation bodies (their promise caches),
+     * wasm32 (its coroutine lowering owns async bodies), module-evaluation
+     * bodies (their promise caches),
      * `dyn` results (resolution may adopt a thenable), and every program
      * that uses node:test subtests — `t.test()` runs a subtest inline and
      * awaits it on the CURRENT fiber even from synchronous code. Worker
@@ -2275,9 +2229,6 @@ export class LlEmitter {
         const eligible = new Set();
         if (this.wasi || this.mod.workers === true)
             return eligible;
-        const embedded = this.mod.embedded;
-        if (embedded !== undefined && embedded.modules.length > 0)
-            return eligible;
         const suspends = /@scr_(?:await_|module_await\b|promise_await_settled\b|test_sub\b|gen_yield_|async_gen_|fiber_)/;
         for (const decl of this.decls)
             if (/@scr_test_sub\b/.test(decl))
@@ -3280,15 +3231,6 @@ export class LlEmitter {
             this.declare(`declare void @scr_dyn_throw(ptr)`);
             B.line(`call void @scr_dyn_throw(ptr ${v.name})`);
         }
-        else if (t.kind === "jsval") {
-            const rc = vAdapters(this.shapeHost, t);
-            const test = "scr_jsval_is_object";
-            this.declare(`declare zeroext i1 @${test}(ptr)`);
-            this.declare(`declare void @scr_throw_ref_classified(ptr, ptr, ptr, ptr, i1 zeroext)`);
-            const object = B.tmp();
-            B.line(`${object} = call zeroext i1 @${test}(ptr ${v.name})`);
-            B.line(`call void @scr_throw_ref_classified(ptr ${v.name}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${traceArg(this.shapeHost, t)}, i1 zeroext ${object})`);
-        }
         else {
             const rc = vAdapters(this.shapeHost, t);
             this.declare(`declare void @scr_throw_ref(ptr, ptr, ptr, ptr)`);
@@ -3326,7 +3268,7 @@ export class LlEmitter {
                 else if (arm.kind === "string") {
                     valueName = this.unionPeek(v.name, unionId);
                 }
-                else if (arm.kind === "bigint" || arm.kind === "dyn" || arm.kind === "jsval") {
+                else if (arm.kind === "bigint" || arm.kind === "dyn") {
                     valueName = this.unionPeek(v.name, unionId);
                 }
                 const truthy = this.truthyOf(arm.kind, valueName, true);
@@ -3420,14 +3362,6 @@ export class LlEmitter {
                 B.line(`${truthy} = call zeroext i1 @scr_dyn_truthy(ptr ${valueName})`);
                 return truthy;
             }
-            case "jsval": {
-                this.declare(`declare i32 @scr_jsval_truthy(ptr)`);
-                const raw = B.tmp();
-                const truthy = B.tmp();
-                B.line(`${raw} = call i32 @scr_jsval_truthy(ptr ${valueName})`);
-                B.line(`${truthy} = icmp ne i32 ${raw}, 0`);
-                return truthy;
-            }
             default:
                 throw new LlvmUnsupportedError(`truthy:${unionArm ? "union:" : ""}${kind}`);
         }
@@ -4086,6 +4020,7 @@ export class LlEmitter {
         const numericFn = withInitializerBindings(fn, initializerBindings);
         this.numericLocals = new Map(numericFn.locals.map((l) => [l.id, l]));
         this.borrowedParameters.clear();
+        this.referenceWrites?.enter(fn);
         this.reboundOwnerSlots.clear();
         this.projectedParameters.clear();
         const projectedParameterIndexes = this.callLifetimes.parameters.get(fn.name);
@@ -4117,7 +4052,7 @@ export class LlEmitter {
         this.integerArrayBindings.clear();
         this.loopArrayBorrows =
             this.debug === null
-                ? findLoopArrayBorrows(fn, this.callLifetimes, this.referenceEffects, this.optionalArrayReads)
+                ? findLoopArrayBorrows(fn, this.callLifetimes, this.referenceEffects, this.optionalArrayReads, this.referenceWrites)
                 : 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);
@@ -4137,6 +4072,7 @@ export class LlEmitter {
         this.currentReturnType = fn.returnType;
         this.currentGenerator = fn.generator ?? null;
         this.currentBorrowedReturn = this.borrowedReturns.has(fn.name);
+        this.inConstructor = this.constructorFunctions.has(fn.name);
         this.currentWasiCoro = null;
         this.logArgSlots = 0;
         if (this.wasi && (fn.async === true || fn.generator !== undefined)) {
@@ -4297,7 +4233,7 @@ export class LlEmitter {
             this.emitStackCheck();
         if (this.workerEntryPolls?.has(fn.name))
             this.emitPendingCheck(undefined, true);
-        this.emitStmts(fn.body);
+        this.emitStmts(fn.body, true);
         // Implicit exit of a void function: release the function scope unless
         // the body already terminated its final block (return, or a throw
         // whose unwind released everything down to depth 0).
@@ -4363,7 +4299,14 @@ export class LlEmitter {
         if (fn.captures !== undefined)
             params.unshift("ptr %sc_env");
         const ret = this.llType(fn.returnType);
-        const attrs = coro !== null ? "#1" : FN_ATTRS;
+        let attrs = coro !== null ? "#1" : FN_ATTRS;
+        // The shared indexed-read helper (lowerSafeIndexRead) is a dense bounds
+        // test, a state test and a load behind cold runtime fallbacks, called
+        // from every `a[i]` of one element type. Without the hint LLVM keeps the
+        // hot instances out of line once they have many callers: every read pays
+        // a call, and an integer index converts to a double and back across it.
+        if (fn.name.startsWith("%arr.idxOr."))
+            attrs = `inlinehint ${attrs}`;
         const debug = this.debugScope === null ? "" : ` !dbg ${this.debugScope}`;
         const symbol = borrowed ? mangleBorrowedFunction(fn.name) : mangleFunction(fn.name);
         const body = `define internal ${ret} @${symbol}(${params.join(", ")}) ${attrs}${debug} { ; ${fn.name}\n${B.render()}\n}`;
@@ -4460,6 +4403,10 @@ export class LlEmitter {
                 this.canBorrowReceiver(value.else_) &&
                 this.canBorrowCallArgument(value.then) &&
                 this.canBorrowCallArgument(value.else_));
+        // A construction-only field of a stable owner keeps its value until the
+        // owner dies: no later operand or callee can replace and release it.
+        if ((value.kind === "fieldGet" || value.kind === "recordGet") && this.immutableRead(value))
+            return this.canBorrowCallArgument(value.obj);
         // An optional chain's bound receiver stays unchanged until its body
         // finishes (see emitReadReceiver).
         if (value.kind === "chainRecv")
@@ -4467,6 +4414,9 @@ export class LlEmitter {
         if (value.kind !== "varRef")
             return false;
         const binding = this.binding(value.localId);
+        // A module constant owns its value for the rest of the program.
+        if (binding.kind === "global")
+            return this.stableGlobals.has(value.localId);
         return (binding.kind === "local" &&
             binding.local !== undefined &&
             (!binding.local.mutable ||
@@ -4476,15 +4426,212 @@ export class LlEmitter {
             !binding.local.boxed &&
             !binding.local.tdz);
     }
+    /** A plain-pointer read of a construction-only field outside any
+     * constructor (ImmutableFields). */
+    immutableRead(e) {
+        if (this.inConstructor || this.immutableFields === null)
+            return false;
+        const t = e.type.kind;
+        if (t !== "object" && t !== "record" && t !== "array" && t !== "string")
+            return false;
+        return e.kind === "fieldGet"
+            ? this.immutableFields.classField(e.className, e.field)
+            : this.immutableFields.recordField(e.shapeId, e.field);
+    }
+    /** A projection read whose locations nothing writes while a borrowed
+     * read of it is in use (ReferenceWrites), given the writes of that
+     * extent. The root binding itself must stay alive across it too, which
+     * its own location (`l:`, `g:`, `bx`) covers. */
+    unwrittenRead(e, writes) {
+        const rw = this.referenceWrites;
+        if (rw === null)
+            return false;
+        const keys = rw.readKeys(e, (call) => this.borrowedReturnKeys(call.callee));
+        return keys !== null && !rw.conflicts(keys, writes);
+    }
+    /** A stable binding initialized by a projection can borrow it when the
+     * rest of its block (its whole lifetime) writes none of the projection's
+     * locations: the source edge then keeps the value alive, and uses that
+     * escape still retain their own copies. */
+    unwrittenAlias(s) {
+        const cursor = this.stmtCursor;
+        const rw = this.referenceWrites;
+        if (rw === null || s.init === null || cursor === null || cursor.stmts[cursor.index] !== s)
+            return false;
+        if (!this.plainReference(s.init.type) ||
+            !this.canBorrowReceiver(s.init) ||
+            !this.unownedWalk(s.init))
+            return false;
+        const writes = rw.union([rw.expr(s.init), rw.stmts(cursor.stmts.slice(cursor.index + 1))]);
+        return this.unwrittenRead(s.init, writes);
+    }
+    /** An optional element read into a projection-only local can borrow the
+     * element when the rest of the block writes no array element and none of
+     * the locations keeping the array alive (which must itself be read
+     * without a frame owner). */
+    unwrittenLocalArrayRead(s, read) {
+        const cursor = this.stmtCursor;
+        const rw = this.referenceWrites;
+        if (rw === null || s.init === null || cursor === null || cursor.stmts[cursor.index] !== s)
+            return false;
+        if (!this.unownedWalk(read.array))
+            return false;
+        const keys = rw.readKeys(read.array);
+        if (keys === null || rw.expr(read.index) !== null)
+            return false;
+        const writes = rw.union([rw.expr(s.init), rw.stmts(cursor.stmts.slice(cursor.index + 1))]);
+        return !rw.conflicts(["a", ...keys], writes);
+    }
+    /** An optional element read passed to a projection-only parameter can
+     * borrow the element when the callee and later arguments (`writes`)
+     * write no array element and nothing keeping the array alive. */
+    unwrittenCallArrayRead(read, writes) {
+        const rw = this.referenceWrites;
+        if (rw === null)
+            return false;
+        const keys = rw.readKeys(read.array);
+        if (keys === null || rw.expr(read.index) !== null)
+            return false;
+        return !rw.conflicts(["a", ...keys], writes);
+    }
+    /** `return x` of a local whose slot is an owned scope entry of the same
+     * type: the return can take over the local's reference. */
+    movableReturn(value) {
+        if (value === null || value.kind !== "varRef" || !isRefCounted(value.type))
+            return null;
+        if (this.currentBorrowedReturn || this.currentWasiCoro !== null)
+            return null;
+        const binding = this.binding(value.localId);
+        if (binding.kind !== "local" || binding.local === undefined || binding.local.boxed)
+            return null;
+        if (!typeEquals(binding.type, value.type) || !typeEquals(this.currentReturnType, value.type))
+            return null;
+        for (const scope of this.scopes) {
+            const index = scope.findIndex((entry) => entry.slot === binding.slot);
+            if (index < 0)
+                continue;
+            const entry = scope[index];
+            if (entry.boxed || entry.lazy || !typeEquals(entry.type, value.type))
+                return null;
+            return { scope, entry, index };
+        }
+        return null;
+    }
+    /** A walk host for a body that may write the heap: each walk must read
+     * only locations the whole body (with its callees) never writes;
+     * rebinding the walk locals themselves releases nothing. */
+    unwrittenWalkHost(fn, host) {
+        return {
+            ...host,
+            unwritten: (value, candidates) => this.referenceWrites?.unwrittenWalk(fn, value, candidates, (call) => this.borrowedReturnKeys(call.callee)) ?? false,
+        };
+    }
+    /** emitReadReceiver yields a plain pointer for `e` that no statement
+     * frame owns, so it can outlive the statement (walk-borrows' walks, from
+     * any unboxed plain-pointer binding, plus element reads). */
+    unownedWalk(e) {
+        switch (e.kind) {
+            case "varRef": {
+                const binding = this.binding(e.localId);
+                if (binding.kind === "global")
+                    return this.plainReference(binding.type);
+                return (binding.kind === "local" &&
+                    binding.local !== undefined &&
+                    !binding.local.boxed &&
+                    !binding.local.tdz &&
+                    this.plainReference(binding.local.type) &&
+                    !this.stringSlices.has(e.localId) &&
+                    !this.storedSplits.has(e.localId) &&
+                    !this.localUnionStorage.has(e.localId));
+            }
+            case "fieldGet":
+            case "recordGet":
+                return this.borrowsWithoutOwning(e) && this.unownedWalk(e.obj);
+            case "unionNarrow":
+            case "downcast":
+            case "upcast":
+                return this.borrowsWithoutOwning(e) && this.unownedWalk(e.value);
+            case "unionWrap":
+                if (!this.borrowsWithoutOwning(e))
+                    return false;
+                return e.value.kind === "unitLit" || this.unownedWalk(e.value);
+            case "ternary": {
+                const arm = (v) => (v.kind === "libCall" && v.fn === "error.nodeThrow") || this.unownedWalk(v);
+                return this.borrowsWithoutOwning(e) && arm(e.then) && arm(e.else_);
+            }
+            case "call":
+                return (this.borrowsWithoutOwning(e) &&
+                    e.args.every((arg) => !isRefCounted(arg.type) || this.unownedWalk(arg)));
+            case "arrayGet":
+                return (!this.isStackUnionSource(e) &&
+                    this.optionalArrayReads.get(e) === null &&
+                    this.unownedWalk(e.arr));
+            case "seqExpr": {
+                const guarded = guardedValue(e);
+                return guarded !== null && this.unownedWalk(guarded);
+            }
+            default:
+                return false;
+        }
+    }
+    /** Every location a borrowed-return callee's walks can read (its body's
+     * field, record and element reads, through nested borrowed returns). */
+    borrowedReturnKeys(callee) {
+        if (!this.borrowedReturns.has(callee))
+            return null;
+        const known = this.borrowedReturnKeyCache.get(callee);
+        if (known)
+            return known;
+        const rw = this.referenceWrites;
+        const keys = new Set();
+        const seen = new Set([callee]);
+        const pending = [callee];
+        while (pending.length > 0) {
+            const fn = this.fnByName.get(pending.pop());
+            if (!fn)
+                continue;
+            everyStmtList(fn.body, {
+                stmt: () => true,
+                expr: (e) => {
+                    if (e.kind === "fieldGet")
+                        keys.add(rw.fieldKey(e.className, e.field));
+                    else if (e.kind === "recordGet") {
+                        keys.add(`r:${e.field}`);
+                        keys.add("r:*");
+                    }
+                    else if (e.kind === "arrayGet")
+                        keys.add("a");
+                    else if (e.kind === "call" && this.borrowedReturns.has(e.callee) && !seen.has(e.callee)) {
+                        seen.add(e.callee);
+                        pending.push(e.callee);
+                    }
+                    return true;
+                },
+            });
+        }
+        const result = [...keys];
+        this.borrowedReturnKeyCache.set(callee, result);
+        return result;
+    }
     // ── statements ──────────────────────────────────────────────────────────
-    emitStmts(stmts) {
-        for (const s of stmts) {
-            // Statements after a terminator are unreachable (dead code after
-            // return/break/continue). Skip them so no dropped SSA definition
-            // can leak forward.
-            if (this.B.isTerminated())
-                return;
-            this.emitStmt(s);
+    emitStmts(stmts, scoped = false) {
+        const saved = this.stmtCursor;
+        const cursor = scoped ? { stmts, index: 0 } : null;
+        try {
+            for (let i = 0; i < stmts.length; i++) {
+                // Statements after a terminator are unreachable (dead code after
+                // return/break/continue). Skip them so no dropped SSA definition
+                // can leak forward.
+                if (this.B.isTerminated())
+                    return;
+                if (cursor)
+                    cursor.index = i;
+                this.stmtCursor = cursor;
+                this.emitStmt(stmts[i]);
+            }
+        }
+        finally {
+            this.stmtCursor = saved;
         }
     }
     /** Emits a block in its own lexical scope (refcounted locals released at
@@ -4496,7 +4643,7 @@ export class LlEmitter {
         const scope = [];
         this.scopes.push(scope);
         setup?.(scope);
-        this.emitStmts(stmts);
+        this.emitStmts(stmts, true);
         const ended = endsWithJump(stmts);
         this.scopes.pop();
         if (!ended)
@@ -4558,7 +4705,9 @@ export class LlEmitter {
                 }
                 const localRead = this.localArrayReads.get(s.localId);
                 if (localRead) {
-                    const owner = emitLocalArrayRead(this, localRead, b.slot);
+                    const owner = emitLocalArrayRead(this, !localRead.borrow && this.unwrittenLocalArrayRead(s, localRead)
+                        ? { ...localRead, borrow: true }
+                        : localRead, b.slot);
                     if (owner)
                         this.scopes[this.scopes.length - 1].push(owner);
                     break;
@@ -4652,7 +4801,7 @@ export class LlEmitter {
                     b.local &&
                     isRefCounted(b.type) &&
                     this.stableCallBindings.has(s.localId) &&
-                    this.canBorrowCallArgument(s.init)) {
+                    (this.canBorrowCallArgument(s.init) || this.unwrittenAlias(s))) {
                     const v = this.emitReadReceiver(s.init);
                     B.line(`store ptr ${v.name}, ptr ${b.slot}`);
                     break;
@@ -4719,6 +4868,32 @@ export class LlEmitter {
                 }
                 B.line(`store ${this.llType(b.type)} ${v.name}, ptr ${b.slot}`);
                 this.storeIntegerView(s.localId, v, s.value);
+                if (b.kind === "global" && this.immortalGlobals.has(s.localId)) {
+                    // An Immutable module constant (contracts/check.ts proved it is
+                    // fresh, publishable and never written): its graph becomes
+                    // immortal, so reads skip reference counting and the collector
+                    // never visits it.
+                    const lines = this.publishWalkers.emitPublish(v.name, v.type, s.loc);
+                    for (const line of lines)
+                        B.line(line.trimStart());
+                    // Reads of this global skip retains from here on, which is only
+                    // sound once the graph really is immortal. Node.js never fails
+                    // here, so a refusal means the contract proof was wrong: stop
+                    // rather than keep running with a mortal graph read as immortal.
+                    if (lines.length > 0) {
+                        this.declare(`declare zeroext i1 @scr_exc_pending()`);
+                        this.declare(`declare void @scr_trap(ptr)`);
+                        const refused = B.tmp();
+                        B.line(`${refused} = call zeroext i1 @scr_exc_pending()`);
+                        const stop = B.newLabel("immutable.refused");
+                        const done = B.newLabel("immutable.published");
+                        B.condBr(refused, stop, done);
+                        B.startBlock(stop);
+                        B.line(`call void @scr_trap(ptr ${this.cstr("scriptc: internal error: an Immutable value could not be published\n")})`);
+                        B.terminate("unreachable");
+                        B.startBlock(done);
+                    }
+                }
                 break;
             }
             case "exprStmt":
@@ -4816,14 +4991,14 @@ export class LlEmitter {
                     const obj = this.emitStableReceiver(s.obj, [s.value]);
                     // (The guard precedes the value here: the nullable store
                     // evaluates it itself.)
-                    this.emitPublishedFieldGuard(obj.name, s.className, s.field);
+                    this.emitStoreGuard(obj.name, s);
                     this.emitNullableFieldStore(obj.name, s.className, s.field, nullable, s.value);
                     break;
                 }
                 if (s.kind === "fieldSet" && this.int32Slots.isField(s.className, s.field)) {
                     const obj = this.emitStableReceiver(s.obj, [s.value]);
                     const v = this.emitExpr(s.value);
-                    this.emitPublishedFieldGuard(obj.name, s.className, s.field);
+                    this.emitStoreGuard(obj.name, s);
                     const { ptr } = this.classFieldPtr(obj.name, s.className, s.field);
                     this.storeInt32Field(ptr, v, s.value);
                     break;
@@ -4831,7 +5006,7 @@ export class LlEmitter {
                 const obj = this.emitStableReceiver(s.obj, [s.value]);
                 const v = this.emitExpr(s.value);
                 if (s.kind === "fieldSet")
-                    this.emitPublishedFieldGuard(obj.name, s.className, s.field);
+                    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"
@@ -5194,7 +5369,11 @@ export class LlEmitter {
                     if (integerArrayLoop && s.init?.kind === "varDecl" && s.init.init) {
                         const value = this.emitExpr(s.init.init);
                         start = B.tmp();
-                        B.line(`${start} = fptoui double ${value.name} to ${this.sizeType}`);
+                        // The start is 0 or an enclosing array index plus one (at most
+                        // 2^32 - 1): on 64-bit targets the signed conversion is exact
+                        // and avoids x86-64's unsigned 64-bit conversion sequence.
+                        const conversion = this.sizeType === "i64" ? "fptosi" : "fptoui";
+                        B.line(`${start} = ${conversion} double ${value.name} to ${this.sizeType}`);
                         this.integerArrayBindings.add(integerLoop.localId);
                     }
                     B.line(`store ${this.sizeType} ${start}, ptr ${integerSlot}`);
@@ -5500,10 +5679,32 @@ export class LlEmitter {
                 // the actual ret. The parked value owns a synthetic slot-backed
                 // scope entry during each copy so a throwing finally releases it.
                 let v = null;
-                if (s.value !== null && this.currentBorrowedReturn) {
+                const moved = this.finallyStack.length === 0 ? this.movableReturn(s.value) : null;
+                if (moved !== null) {
+                    // Returning an owned local hands its reference to the caller: no
+                    // retain now and no release of the local below.
+                    const t = B.tmp();
+                    B.line(`${t} = load ptr, ptr ${moved.entry.slot}`);
+                    v = { name: t, type: s.value.type };
+                    moved.scope.splice(moved.scope.indexOf(moved.entry), 1);
+                    this.releaseForJump(0, 0);
+                    moved.scope.splice(moved.index, 0, moved.entry);
+                }
+                else if (s.value !== null && this.currentBorrowedReturn) {
                     // A borrowed-return body hands back its walk without a reference
-                    // (it has no try statements, so no finally can intervene).
-                    v = this.emitReadReceiver(s.value);
+                    // (it has no try statements, so no finally can intervene). An
+                    // optional element read lends the element its array keeps alive.
+                    const read = this.optionalArrayReads.get(s.value);
+                    if (read) {
+                        const slot = B.slot();
+                        B.entryAllocas.push(`${slot} = alloca ptr`);
+                        emitLocalArrayRead(this, { ...read, borrow: true }, slot);
+                        const t = B.tmp();
+                        B.line(`${t} = load ptr, ptr ${slot}`);
+                        v = { name: t, type: s.value.type };
+                    }
+                    else
+                        v = this.emitReadReceiver(s.value);
                 }
                 else if (s.value !== null) {
                     v = this.emitExpr(s.value);
@@ -5540,7 +5741,7 @@ export class LlEmitter {
                     this.finallyStack = savedFinally;
                     this.tryStack = savedTry;
                 }
-                else {
+                else if (moved === null) {
                     this.releaseForJump(0, 0);
                 }
                 if (!B.isTerminated()) {
@@ -5798,7 +5999,7 @@ export class LlEmitter {
         const caseLabels = s.cases.map(() => B.newLabel("sw.c"));
         const defaultIdx = s.cases.findIndex((c) => c.test === null);
         const fallback = defaultIdx >= 0 ? caseLabels[defaultIdx] : end;
-        if (!emitLiteralSwitch(this, disc, s.cases, caseLabels, fallback)) {
+        if (!emitLiteralSwitch(this, disc, s.disc, s.cases, caseLabels, fallback)) {
             s.cases.forEach((c, i) => {
                 if (c.test === null)
                     return;
@@ -6134,6 +6335,13 @@ export class LlEmitter {
             ``,
         ];
     }
+    /** The frozen-object guard of a class field store, unless the store
+     * provably targets a still-private `this` (PublishedTypes.privateStores). */
+    emitStoreGuard(obj, s) {
+        if (this.publishedTypes?.privateStores.has(s) === true)
+            return;
+        this.emitPublishedFieldGuard(obj, s.className, s.field);
+    }
     /** The frozen-object guard of a class field or record field store:
      * Node's "Cannot assign to read only property" TypeError when the target
      * is published. `className` null means a record (`#<Object>`). */
@@ -6200,9 +6408,6 @@ export class LlEmitter {
     emitAsyncExpr(e) {
         return emitAsyncExpr(this, e);
     }
-    emitJsInteropExpr(e) {
-        return emitJsInteropExpr(this, e);
-    }
     /** Read a receiver whose value is consumed immediately by a field or tag
      * load. No user code may run between this read and its consumer. Locals
      * and their projections already have an owner; other expressions keep
@@ -6273,6 +6478,10 @@ export class LlEmitter {
                 this.ownSlot(result.owner.slot, result.owner.type);
             return result.value;
         }
+        // A borrowed-return helper (such as an optional element read) lends its
+        // result like any borrowed-return call.
+        if (e.kind === "call" && this.borrowedReturns.has(e.callee) && this.canBorrowReceiver(e))
+            return emitBorrowedResultCall(this, e);
         const arrayRead = this.optionalArrayReads.get(e);
         if (arrayRead)
             return emitProjectedArrayRead(this, arrayRead);
@@ -6518,12 +6727,24 @@ export class LlEmitter {
                 const wrap = this.borrowableNullableWrap(e);
                 return wrap === "unit" || (wrap === "ref" && this.canBorrowReceiver(e.value));
             }
-            // A borrowed-return callee preserves edges, so its result stays
-            // reachable from borrowable arguments until the consumer runs.
-            case "call":
-                return (this.borrowedReturns.has(e.callee) &&
-                    e.args.every((arg) => (!isRefCounted(arg.type) || this.canBorrowReceiver(arg)) &&
-                        this.referenceEffects.preserves(arg)));
+            // A borrowed-return result stays reachable from its borrowed
+            // arguments until the consumer runs. Each argument is lent without a
+            // snapshot, so neither the callee nor a later argument may replace
+            // what it was read from: a callee that preserves every edge cannot,
+            // and any other one must leave the argument's locations unwritten.
+            case "call": {
+                if (!this.borrowedReturns.has(e.callee))
+                    return false;
+                if (!e.args.every((arg) => this.referenceEffects.preserves(arg)))
+                    return false;
+                const preserving = this.referenceEffects.functions.has(e.callee);
+                if (preserving)
+                    return e.args.every((arg) => !isRefCounted(arg.type) || this.canBorrowReceiver(arg));
+                if (this.referenceWrites === null)
+                    return false;
+                const lent = borrowableInputs(this, e.args, false, this.referenceWrites.summary(e.callee));
+                return e.args.every((arg, i) => !isRefCounted(arg.type) || lent[i] === true);
+            }
             // A required element read: the (borrowed) array owns the element
             // while an edge-preserving index computes.
             case "arrayGet":
@@ -6569,14 +6790,17 @@ export class LlEmitter {
         };
         const hostFor = (fn) => {
             const allowed = borrowedIds(fn);
-            return {
+            const host = {
                 pointerLocal: (local) => pointer(local.type),
                 borrowsWithoutOwning: (e) => this.borrowsWithoutOwning(e),
                 borrowedReturn: (callee) => this.borrowedReturns.has(callee),
                 parameterAllowed: (id) => allowed.has(id),
             };
+            return this.referenceEffects.functions.has(fn.name) ? host : this.unwrittenWalkHost(fn, host);
         };
-        const preserving = [...this.fnByName.values()].filter((fn) => this.referenceEffects.functions.has(fn.name));
+        // With ReferenceWrites, a body that writes none of its walks' locations
+        // qualifies like one that preserves every edge.
+        const preserving = [...this.fnByName.values()].filter((fn) => this.referenceEffects.functions.has(fn.name) || this.referenceWrites !== null);
         const candidates = preserving.filter((fn) => {
             if (!pointer(fn.returnType) || fn.async || fn.generator || fn.captures)
                 return false;
@@ -6597,6 +6821,8 @@ export class LlEmitter {
                 if (!analyzeWalks(fn, hostFor(fn)).returnsWalk)
                     continue;
                 this.borrowedReturns.add(fn.name);
+                // Nested borrowed returns extend the locations a caller depends on.
+                this.borrowedReturnKeyCache.clear();
                 changed = true;
             }
         }
@@ -6624,6 +6850,12 @@ export class LlEmitter {
                 return this.nullableFieldGet(e) === null;
             case "recordGet":
                 return true;
+            // emitReadReceiver lends a required element of a borrowed array when
+            // computing the index removes no edge.
+            case "arrayGet":
+                return (e.arr.type.kind === "array" &&
+                    this.optionalArrayReads.get(e) === null &&
+                    this.referenceEffects.preserves(e.index));
             case "unionNarrow":
                 return this.nullableUnions.has(e.unionId);
             case "downcast":
@@ -6665,21 +6897,6 @@ export class LlEmitter {
     emitExpr(e) {
         return emitExpr(this, e);
     }
-    emitJsMarshal(e) {
-        return emitJsMarshal(this, e);
-    }
-    emitJsOp(e) {
-        return emitJsOp(this, e);
-    }
-    emitJsExit(e) {
-        return emitJsExit(this, e);
-    }
-    islandAdapter(arity, retKind) {
-        return islandAdapter(this, arity, retKind);
-    }
-    islandTypedAdapter(fn) {
-        return islandTypedAdapter(this, fn);
-    }
     dynKind(d) {
         return dynKind(this, d);
     }