@scriptc/compiler 0.4.7 → 0.4.8

package/dist/backend/llvm/emitter.js

@@ -7,7 +7,7 @@ import { JsIcSites } from "../../ir/js-ic.js";
 import {} from "./array-search.js";
 import { emitStringInputs } from "./string-lifetimes.js";
 import { emitThreadSlotsIntrinsic } from "./thread-slots.js";
-import { CYC_BUF, CYC_HDR, FIRST_EMITTED_CYC_KIND, inlineAllocSupported, RECORD_SOURCES_GATE, WEAK_KEYS_GATE, } from "./alloc.js";
+import { CYC_BUF, CYC_HDR, FIRST_EMITTED_CYC_KIND, inlineAllocSupported, RECORD_KEPT_GATE, RECORD_SOURCES_GATE, WEAK_KEYS_GATE, } from "./alloc.js";
 import { youngNurseryRequested } from "../young-nursery.js";
 import { llvmBytes as llBytes, wtf8Bytes } from "../literals.js";
 import { InternalCompilerError } from "../../errors.js";
@@ -27,12 +27,14 @@ import { addRecordResultEntries, resultEntryName } from "./record-results.js";
 import { specializeCallbackCalls } from "../../ir/callback-specialization.js";
 import { EmitJournal, registerReplay, renameChunk, replayJournal, } from "./emit-journal.js";
 import { specializeNumericCalls } from "../../ir/numeric-call-specialization.js";
+import { specializeTypedArguments } from "../../ir/typed-argument-clones.js";
 import { versionLoopBoundParameters } from "../../ir/parameter-versions.js";
 import { inlineExpressionFunctions } from "../../ir/expression-inlining.js";
 import { inlineArrayReads, NO_INLINE_ARRAYS, planInlineArrays, } from "../../ir/inline-arrays.js";
 import { inlineArraysApply, programLifetimeClassOf } from "./inline-arrays.js";
 import { pairRowSums } from "../../ir/row-pairs.js";
 import { jamSaturatingLoops } from "../../ir/saturating-loop-jams.js";
+import { jamRuntimeCountLoops } from "../../ir/runtime-jam-loops.js";
 import { allocatedLiteral, fillAllocationLength, int32ArrayKey, selectInt32Arrays, } from "../../ir/int32-arrays.js";
 import { everyExpr, everyExprChild, everyStmtChild, everyStmtList } from "../../ir/traverse.js";
 import { INT32_RANGE, withinInt32, } from "../../ir/integer-ranges.js";
@@ -47,6 +49,7 @@ import { dropUnwrittenPropertyBags } from "../../ir/property-bags.js";
 import { freezeInitOnlyGlobals } from "../../ir/init-only-globals.js";
 import { hoistFinalFieldReads } from "../../ir/field-values.js";
 import { holdCharLocalsAsUnits } from "../../ir/char-unit-locals.js";
+import { versionUnionArmLoops } from "../../ir/union-arm-loops.js";
 import { unitSafeFunctions } from "./string-unit-versions.js";
 import { stringScanInline } from "./string-reads.js";
 import { findInt32Abis, INT32_ABI_SUFFIX, SCALAR_UNION_DUMMY, SCALAR_UNION_RESULT, } from "./int32-abi.js";
@@ -73,6 +76,7 @@ import { borrowsCheckedNarrow, CheckedNarrows } from "./checked-narrows.js";
 import { emitDenseArraySet, emitDenseSlotUnlink, SCR_ELEM_I32, } from "./dense-array-access.js";
 import { matchMapRead, pointerMapGet } from "./map-read-lifetimes.js";
 import {} from "./map-entry-fusion.js";
+import {} from "./record-entry-fusion.js";
 import { emitBorrowedFieldSequence, guardedValue } from "./borrowed-receivers.js";
 import { emitBorrowedInputs } from "./borrowed-inputs.js";
 import { findWalkBorrows } from "./walk-borrows.js";
@@ -114,11 +118,12 @@ import { emitNetworkHttpLibCall } from "./lib-network.js";
 import { emitAssertInspectLibCall, emitIoLibCall, emitGenericLibCall, emitLibCall, } from "./lib-dispatch.js";
 import { assignCompactLayouts, buildClassGraph, classFieldTypes, classMembershipIntervals, classFieldIndex, compactRefLoadLines, compactRefStoreLines, classPreLines, classStructSym, programLifetimeClass, } from "./classes.js";
 import { LifetimeRegions, REGION_TYPES } from "./regions.js";
+import { planTreeClasses } from "../tree-classes.js";
 import { arenaAware, arenaCurrentAddress, arenaNewSym, arenasRequested, planArenas, } from "./arenas.js";
 import { children } from "./region-ir.js";
 import { LlDyn, recordDynKeepsIdentity } from "./dyn.js";
 import { VirtualBorrows } from "./virtual-borrows.js";
-import { planRecordViews, recordViewFieldPtr } from "./record-views.js";
+import { absentTrapLines, planRecordViews, recordViewFieldPtr, recordViewTestLines, } from "./record-views.js";
 import { LlvmUnsupportedError } from "./unsupported.js";
 import { LlWalkers } from "./walkers.js";
 import { isObjectArm, isPayloadTag, NULLABLE_ABSENT, NULLABLE_NULL, NullableUnions, pointerTagFn, } from "./nullable-unions.js";
@@ -171,16 +176,18 @@ export function lowRegionTarget(platform, sanitize) {
 /** Function versions on loop-bounding number parameters
  * (ir/parameter-versions.ts). Library builds have no int32 entries, and a
  * module that observes call stacks could see the version's frame. */
-function versionParameters(mod) {
-    if (mod.lib !== undefined || observesStacks(mod))
+function versionParameters(mod, nodes) {
+    if (mod.lib !== undefined || observesStacks(mod, nodes))
         return mod;
-    return versionLoopBoundParameters(mod, mangleFunction);
+    return versionLoopBoundParameters(mod, mangleFunction, nodes);
 }
 /** The int32 slot analysis of `mod`, with the inputs LlEmitter gives it.
  * With `revise`, the analysis revises the functions of candidates that drop
- * (Int32SlotInputs.revise), and `mod` is the module it started from. */
-function analyzeModuleInt32Slots(mod, revise) {
-    const nodeIndex = new IrNodeIndex(mod);
+ * (Int32SlotInputs.revise), and `mod` is the module it started from. The
+ * node index of `mod` takes the nodes `previous` recorded for the functions
+ * both hold. */
+function analyzeModuleInt32Slots(mod, previous, revise) {
+    const nodeIndex = new IrNodeIndex(mod, previous);
     const initializerBindings = findInitializerBindings(mod, nodeIndex);
     const dynamicStores = dynamicFieldStores(mod, undefined, undefined, nodeIndex);
     const slots = analyzeInt32Slots(mod, {
@@ -200,7 +207,7 @@ function keptInt32Arrays(analysis) {
  * node index of `mod`, and its initializer bindings and dynamic stores,
  * which must be the ones the analysis read. Null when they differ. */
 function revisedAnalysis(analysis, mod) {
-    const nodeIndex = new IrNodeIndex(mod);
+    const nodeIndex = new IrNodeIndex(mod, analysis.nodeIndex);
     const initializerBindings = findInitializerBindings(mod, nodeIndex);
     const dynamicStores = dynamicFieldStores(mod, undefined, undefined, nodeIndex);
     const read = analysis.initializerBindings;
@@ -249,16 +256,19 @@ function moduleEmitter(input, options) {
     // Each proof selectInt32Arrays asks for analyzes a marked module; the
     // emitter of the module it returns reuses the last one. A proof that
     // revised functions analyzed the module of the functions it ended with.
-    const rounds = { last: null, functions: null, revising: true };
+    // Each round's node index takes the recorded nodes of the functions it
+    // shares with the latest index (`nodes`).
+    const rounds = { last: null, functions: null, revising: true, nodes: undefined };
     const proven = (marked, revise) => {
         rounds.functions = null;
         if (revise === null || !rounds.revising) {
-            rounds.last = analyzeModuleInt32Slots(marked);
+            rounds.last = analyzeModuleInt32Slots(marked, rounds.nodes);
+            rounds.nodes = rounds.last.nodeIndex;
             return { kept: keptInt32Arrays(rounds.last), functions: null };
         }
         const latest = new Map();
         try {
-            rounds.last = analyzeModuleInt32Slots(marked, (fnName, dropped) => {
+            rounds.last = analyzeModuleInt32Slots(marked, rounds.nodes, (fnName, dropped) => {
                 const fn = revise(fnName, dropped);
                 latest.set(fnName, fn);
                 return fn;
@@ -270,6 +280,7 @@ function moduleEmitter(input, options) {
             rounds.last = null;
             return null;
         }
+        rounds.nodes = rounds.last.nodeIndex;
         if (latest.size === 0)
             return { kept: keptInt32Arrays(rounds.last), functions: null };
         rounds.functions = marked.functions.map((fn) => latest.get(fn.name) ?? fn);
@@ -279,7 +290,13 @@ function moduleEmitter(input, options) {
     if (options.debugSources !== undefined)
         return new LlEmitter(mod, options, null, null);
     const timing = options.timing ?? (() => { });
-    const passed = versionParameters(addRecordResultEntries(scalarizeLiteralResults(scalarizeNumericRecords(specializeCallbackCalls(specializeNumericCalls(pairRowSums(jamSaturatingLoops(inlineArraysPass(options, inlineExpressionFunctions(foldConstantGlobals(copyStableCaptures(resolveSelfCaptures(hoistFinalFieldReads(freezeInitOnlyGlobals(holdCharLocalsAsUnits(dropUnwrittenPropertyBags(runPairedWhileLoopsAsFor(mod)))))))))))), mangleFunction), mangleFunction)))));
+    // One index of the module the passes start from. Each pass skips the
+    // functions the index records without the node kinds it rewrites, and
+    // reads its scans of whole bodies from the index; it walks the functions
+    // an earlier pass rewrote, which the index does not record.
+    const nodes = new IrNodeIndex(mod);
+    rounds.nodes = nodes;
+    const passed = versionUnionArmLoops(versionParameters(addRecordResultEntries(scalarizeLiteralResults(scalarizeNumericRecords(specializeCallbackCalls(specializeNumericCalls(specializeTypedArguments(pairRowSums(jamRuntimeCountLoops(jamSaturatingLoops(inlineArraysPass(options, inlineExpressionFunctions(foldConstantGlobals(copyStableCaptures(resolveSelfCaptures(hoistFinalFieldReads(freezeInitOnlyGlobals(holdCharLocalsAsUnits(dropUnwrittenPropertyBags(runPairedWhileLoopsAsFor(mod, nodes), nodes), nodes), nodes), nodes), nodes), nodes), nodes), nodes)), nodes), nodes), nodes), mangleFunction, nodes), mangleFunction, nodes), mangleFunction, nodes)), nodes), nodes), nodes), nodes);
     timing("llvm-emit-rewrites");
     let emitted = selectInt32Arrays(passed, proven, resultEntryTargets);
     let prepared = rounds.last;
@@ -303,7 +320,7 @@ function moduleEmitter(input, options) {
     if (process.env["SCRIPTC_INT32_VERIFY"] === "1")
         verifyInt32Selection(passed, emitted, prepared?.mod === emitted ? prepared : null);
     timing("llvm-emit-int32");
-    const emitter = new LlEmitter(emitted, options, null, prepared?.mod === emitted ? prepared : null);
+    const emitter = new LlEmitter(emitted, options, null, prepared?.mod === emitted ? prepared : null, rounds.nodes);
     timing("llvm-emit-analyses");
     return emitter;
 }
@@ -313,13 +330,13 @@ function moduleEmitter(input, options) {
 function verifyInt32Selection(passed, emitted, analysis) {
     let last = null;
     const reference = selectInt32Arrays(passed, (marked) => {
-        last = analyzeModuleInt32Slots(marked);
+        last = analyzeModuleInt32Slots(marked, undefined);
         return { kept: keptInt32Arrays(last), functions: null };
     }, resultEntryTargets);
     const text = (mod) => serializeModuleParts(mod).join("");
     if (text(reference) !== text(emitted))
         throw new InternalCompilerError("int32 selection: the revised module differs from the rounds'");
-    const facts = (mod, prepared) => (prepared?.mod === mod ? prepared : analyzeModuleInt32Slots(mod)).slots.summary(mod);
+    const facts = (mod, prepared) => (prepared?.mod === mod ? prepared : analyzeModuleInt32Slots(mod, undefined)).slots.summary(mod);
     const expected = facts(reference, last);
     const actual = facts(emitted, analysis);
     if (expected !== actual) {
@@ -396,6 +413,25 @@ function isIdentifierByte(code) {
  * to its next suspension, which returns to the caller, and the body's own
  * bookkeeping calls do not suspend it. */
 export const SUSPENDS = /@(?:scr_(?:await_|module_await\b|promise_await_settled\b|test_sub\b|gen_yield_|async_gen_(?!new\b|next_|return_|throw\b|hop_done\b)|fiber_)|sc_a[wd]_)/;
+/** The literal text each SUSPENDS alternative starts with. The `@scr_` prefix
+ * is joined to each suffix here so that a prefix is not read as an emitted
+ * symbol name by the runtime ABI scan. */
+const SUSPEND_PREFIXES = [
+    "await_",
+    "module_await",
+    "promise_await_settled",
+    "test_sub",
+    "gen_yield_",
+    "async_gen_",
+    "fiber_",
+]
+    .map((suffix) => `@scr_${suffix}`)
+    .concat("@sc_aw_", "@sc_ad_");
+/** Whether `text` mentions a SUSPENDS entry point. The regex runs only on
+ * text that holds one of its prefixes, which most function bodies do not. */
+export function mentionsSuspension(text) {
+    return SUSPEND_PREFIXES.some((prefix) => text.includes(prefix)) && SUSPENDS.test(text);
+}
 /** The suspensions of a fiber body's own awaits, which its stackless
  * coroutine form suspends itself at instead. */
 const AWAIT_SUSPENSIONS = /@(?:scr_await_(?:void|f64|bool|str|ref|hop|dyn_value)\b|sc_a[wd]_[A-Za-z0-9_]+)/g;
@@ -504,6 +540,10 @@ export class LlEmitter {
     mod;
     /** Per-feature state (emitter-state.ts), indexed by each key's slot. */
     moduleStates = [];
+    /** The names of the functions that `versionLoopBoundParameters` versions
+     * for int32 loop bounds: the ones that keep their name and call the copy
+     * and the fallback. Computed on first use. */
+    int32Versioned = null;
     localArrayReads = new Map();
     loopArrayBorrows = new Set();
     scalarStringSlices = new Map();
@@ -527,7 +567,7 @@ export class LlEmitter {
     fieldAliasTags = new Map();
     fieldPointerTags = new Map();
     /** The field pointers (classFieldPtr) of this function whose fields hold
-     * 32-bit references to compact class instances (LlClassMeta.compressed):
+     * 32-bit references (LlClassMeta.compressed):
      * loadField/loadRef decode them and storeField/storeRef encode them. */
     compressedFieldPtrs = new Set();
     /** Compact class instances live in the program-lifetime region below
@@ -535,6 +575,12 @@ export class LlEmitter {
      * classes): main reserves it before compiled code runs (scr_plr_init), and
      * fields and arrays of compactRefType hold 32-bit references. */
     compactRegion = false;
+    /** A compact class has a field holding an array, a map, a set or a heap
+     * instance (windowRefType), so a reference to it is a 32-bit address of
+     * the allocator's window: main requires the window to serve every
+     * reference block (scr_sa_require_window), and ends the process when it
+     * cannot, rather than hand out an address a field would truncate. */
+    windowRefs = false;
     /** Native class fields with different property names cannot occupy the
      * same slot of one object. Inherited views of the same property share a
      * tag. Array storage has its own disjoint categories; untagged runtime
@@ -839,6 +885,9 @@ export class LlEmitter {
     sanitizeAttributes;
     /** LlvmTargetOptions.cpuDispatch, where it applies. */
     cpuDispatch;
+    /** How the program's functions are copied (cpu-dispatch.ts): for runtime
+     * dispatch, for an x86-64-v3 `targetCpu` ("target"), or not at all. */
+    cpuCopies;
     wasmBoundsChecks;
     /** Interned string literals: UTF-8 text → { symbol, byte length } —
      * first-use order, the runtime ABI’s determinism discipline. */
@@ -944,6 +993,8 @@ export class LlEmitter {
     numberMapKeyIntegers = new Map();
     /** The current function's fused string-key Map get-then-set pairs (map-entry-fusion.ts). */
     mapEntryFusion = null;
+    /** The current function's fused record get-then-set pairs (record-entry-fusion.ts). */
+    recordEntryFusion = null;
     callLifetimes;
     /** The locals whose value never leaves its frame (frame-escapes.ts), for
      * class instances with reference fields in frame storage. */
@@ -1105,6 +1156,11 @@ export class LlEmitter {
     arraySearchKinds = new Set();
     /** Typed-ref recipe constants by type key (lazy receivers). */
     typedRefRecipes = new Map();
+    /** The module links narrowed record copies to their sources
+     * (IrModule.recordLinks). */
+    hasRecordLinks() {
+        return (this.mod.recordLinks?.length ?? 0) > 0;
+    }
     /** ReadableStream.from adapters keep typed arrays by reference and box
      * one current element per pull. */
     streamFromArrayAdapters = new Map();
@@ -1140,6 +1196,18 @@ export class LlEmitter {
      * zero-initialized ScrJsIc per site (scr_js.h). */
     jsIcSiteCount = 0;
     jsIcSitesMemo;
+    /** Guard-group records of dynamic-tier functions (js-groups.ts): one
+     * zero-initialized ScrJsGroup per group, and the key arrays the probes
+     * read (scr_js.h). */
+    jsGroupCount = 0;
+    jsGroupKeysCount = 0;
+    jsGroupKeysByName = new Map();
+    jsGroupKeysByText = new Map();
+    /** The guard of each group the function being emitted has entered: the
+     * entry value, and the position of the member that comes next. */
+    groupRuns = new Map();
+    /** The guard groups of the function being emitted (ir/js-groups.ts). */
+    jsGroupPlan = null;
     /** The tier of the function being emitted. */
     currentTier = undefined;
     /** The class graph (buildClassGraph): preorder numbering, hierarchy
@@ -1413,7 +1481,7 @@ export class LlEmitter {
     journaled;
     /** Stack-trace mode: functions no capture can include (no frame push). */
     unframedFunctions;
-    constructor(mod, options, journal = null, int32Analysis = null) {
+    constructor(mod, options, journal = null, int32Analysis = null, previousIndex) {
         this.mod = mod;
         this.targetOptions = options;
         this.journal = journal;
@@ -1421,8 +1489,9 @@ export class LlEmitter {
             journal !== null ||
                 ((options.functionWorkers ?? 1) > 1 && options.forkPrimitives !== undefined);
         // One walk of every body, which the analyses below read instead of
-        // walking the bodies themselves.
-        this.nodeIndex = int32Analysis?.nodeIndex ?? new IrNodeIndex(mod);
+        // walking the bodies themselves. The functions `previousIndex` (an index
+        // of an earlier module) recorded are not walked again.
+        this.nodeIndex = int32Analysis?.nodeIndex ?? new IrNodeIndex(mod, previousIndex);
         this.initializerBindings =
             int32Analysis?.initializerBindings ?? findInitializerBindings(mod, this.nodeIndex);
         // One walk finds the dynamic field stores every analysis below consults.
@@ -1490,13 +1559,16 @@ export class LlEmitter {
         this.nodeIslandModuleData = options.nodeIslandModuleData ?? null;
         this.targetCpu = options.targetCpu;
         this.sanitizeAttributes = options.sanitizeAttributes !== false;
-        this.cpuDispatch =
-            options.cpuDispatch === true &&
-                options.targetCpu === undefined &&
-                !this.wasi &&
-                mod.lib === undefined &&
-                this.debug === null &&
-                /^(x86_64|amd64|x64)\b/.test(options.targetTriple || process.arch);
+        const copyable = !this.wasi &&
+            mod.lib === undefined &&
+            this.debug === null &&
+            /^(x86_64|amd64|x64)\b/.test(options.targetTriple || process.arch);
+        this.cpuDispatch = options.cpuDispatch === true && options.targetCpu === undefined && copyable;
+        this.cpuCopies = this.cpuDispatch
+            ? "dispatch"
+            : options.targetCpu === "x86-64-v3" && copyable
+                ? "target"
+                : null;
         this.wasmBoundsChecks =
             options.wasmBoundsChecks === true ||
                 wasmBoundsChecks({
@@ -1687,6 +1759,9 @@ export class LlEmitter {
         // The same holds for a class union's arms (class-unions.ts).
         classUnionHeaders(mod, this.nullableUnions.allClassUnions(), this.tracedShapes, this.tracedUnions);
         this.shapeHost = {
+            ...((mod.recordLinks?.length ?? 0) > 0
+                ? { recordSourcesGate: RECORD_KEPT_GATE, recordLinks: mod.recordLinks }
+                : {}),
             // Journal hooks only on emitters that can emit ranges (chunk
             // emitters, and emitters whose workers take a journal after the
             // fork), so the host's optional calls cost nothing otherwise.
@@ -1723,6 +1798,8 @@ export class LlEmitter {
             // Worker programs keep one allocator per script thread: the inline
             // paths address its thread-local state.
             threadLocalAlloc: mod.workers === true,
+            // Linux executables find a block's owner in the chunk map.
+            windowMap: options.lowRegion === true,
             rcHelpers: this.rcHelpers,
             ...(this.rcMode !== undefined ? { rcMode: this.rcMode } : {}),
             ...(this.rcHelpersNoinline ? { rcHelpersNoinline: true } : {}),
@@ -1886,12 +1963,14 @@ export class LlEmitter {
         // except where regions count them or a slot word follows the header.
         if (this.sizeType === "i64" && mod.lifetimeRegions !== true)
             assignCompactLayouts(this.classMeta, (root) => programLifetimeClass(this.shapeHost, root) && !root.threadSlot, (cls) => classFieldTypes(this.shapeHost, cls, this.int32Slots), 
-            // Executables whose region lies below 32 GiB hold compact class
-            // instances there (scr_plr_alloc), so fields referring to one store
-            // a 32-bit reference: the field's type, the class of a
-            // `C | undefined` or `C | null` pointer, or the reference arm of a
-            // nullable pointer field, is a compact class. `C | null | undefined`
-            // keeps the pointer: its null is a sentinel outside the region.
+            // Executables whose window lies below 32 GiB hold compact class
+            // instances there (scr_plr_alloc), and arrays, maps, sets and other
+            // class instances too, so fields referring to one store a 32-bit
+            // reference: the field's type, the class of a `C | undefined` or
+            // `C | null` pointer, or the reference arm of a nullable pointer
+            // field, is a compact class, or windowRefType holds. `C | null |
+            // undefined` keeps the pointer: its null is a sentinel outside the
+            // region.
             mod.lib === undefined && options.lowRegion === true
                 ? (cls, i, isCompact) => {
                     const f = cls.fields[i];
@@ -1899,6 +1978,10 @@ export class LlEmitter {
                         return false;
                     if (this.compactRefType(f.type, isCompact))
                         return true;
+                    if (this.windowRefType(f.type, isCompact)) {
+                        this.windowRefs = true;
+                        return true;
+                    }
                     const nullable = f.type.kind === "union" && this.nullableUnions.single(f.type.unionId) === null
                         ? this.nullableFields.get(cls.name, f.name)
                         : null;
@@ -1909,8 +1992,53 @@ export class LlEmitter {
             mod.lib === undefined &&
                 options.lowRegion === true &&
                 [...this.classMeta.values()].some((m) => m.compact);
+        for (const [name, rec] of RUNTIME_ERROR_CLASSES) {
+            const meta = this.classMeta.get(name);
+            if (!meta)
+                break; // hand-written IR without the builtin defs: no stamps
+            this.errorIntervals.push({ kind: rec.kind, pre: meta.pre, post: meta.post, lib: rec.lib });
+        }
+        const emMeta = this.classMeta.get(RUNTIME_EMITTER_CLASS);
+        if (emMeta)
+            this.emitterInterval = { pre: emMeta.pre, post: emMeta.post };
+        for (const [name, rec] of RUNTIME_STREAM_CLASSES) {
+            const meta = this.classMeta.get(name);
+            if (!meta)
+                continue;
+            this.streamIntervals.push({
+                vt: `scr_${rec.lib.toLowerCase()}_vt`,
+                pre: meta.pre,
+                post: meta.post,
+                lib: rec.lib,
+            });
+        }
+        this.virtualBorrows = new VirtualBorrows(mod, this.classMeta, this.fnByName, this.callLifetimes.borrowed);
+        // After the vtable slots: borrowing slots exclude their implementations.
+        if (this.debug === null)
+            this.analyzeBorrowedReturns();
+        // Which classes drop their count word: a node of a graph the program
+        // proves acyclic, singly owned and unobserved (backend/tree-classes.ts,
+        // out/unique-ownership/DESIGN.md). The linear-use analysis agrees with
+        // the emitter's own ownership discipline, so it reads the facts above
+        // and nothing else. A debug build skips the borrowed-return analysis
+        // this needs; it keeps every class counted.
+        if (this.debug === null && mod.lib === undefined && mod.lifetimeRegions !== true) {
+            const plan = planTreeClasses(mod, {
+                borrowed: this.callLifetimes.borrowed,
+                borrowedReturns: this.borrowedReturns,
+                traced: { shapes: this.tracedShapes, unions: this.tracedUnions },
+                immutable: this.immutableFields,
+                published: this.publishedTypes,
+            });
+            for (const name of plan.classes)
+                this.classMeta.get(name).tree = true;
+            this.treeMoves = plan.classes.size > 0 ? new Set(plan.moves) : null;
+        }
         // Group arenas: off with lifetime regions, which own their classes'
         // allocation, and in libraries, whose exports any host code calls.
+        // Planned after the tree classes, which keep the general allocator:
+        // their teardown is a plain free, and an arena block's disposal runs
+        // the counted path.
         if (arenasRequested() && mod.lifetimeRegions !== true && mod.lib === undefined) {
             this.arenas = planArenas(mod, {
                 shape: (id) => {
@@ -1924,6 +2052,7 @@ export class LlEmitter {
                     const meta = this.classMeta.get(def.name);
                     return (meta !== undefined &&
                         !meta.compact &&
+                        !meta.tree &&
                         !meta.threadSlot &&
                         // An Array subclass's instance is an array (the runtime's header).
                         def.arrayElem === undefined &&
@@ -1933,6 +2062,7 @@ export class LlEmitter {
                 },
                 nullableArm: (unionId) => this.nullableUnions.single(unionId)?.arm ?? null,
                 traced: (t) => traceAdapter(this.shapeHost, t) !== null,
+                tree: (def) => this.classMeta.get(def.name)?.tree === true,
             });
             if (this.arenas !== null) {
                 this.shapeHost.arenaShapes = this.arenas.shapes;
@@ -1948,30 +2078,6 @@ export class LlEmitter {
         if (arenaShapes !== undefined && viewTargets !== null)
             for (const id of arenaShapes)
                 viewTargets.delete(id);
-        for (const [name, rec] of RUNTIME_ERROR_CLASSES) {
-            const meta = this.classMeta.get(name);
-            if (!meta)
-                break; // hand-written IR without the builtin defs: no stamps
-            this.errorIntervals.push({ kind: rec.kind, pre: meta.pre, post: meta.post, lib: rec.lib });
-        }
-        const emMeta = this.classMeta.get(RUNTIME_EMITTER_CLASS);
-        if (emMeta)
-            this.emitterInterval = { pre: emMeta.pre, post: emMeta.post };
-        for (const [name, rec] of RUNTIME_STREAM_CLASSES) {
-            const meta = this.classMeta.get(name);
-            if (!meta)
-                continue;
-            this.streamIntervals.push({
-                vt: `scr_${rec.lib.toLowerCase()}_vt`,
-                pre: meta.pre,
-                post: meta.post,
-                lib: rec.lib,
-            });
-        }
-        this.virtualBorrows = new VirtualBorrows(mod, this.classMeta, this.fnByName, this.callLifetimes.borrowed);
-        // After the vtable slots: borrowing slots exclude their implementations.
-        if (this.debug === null)
-            this.analyzeBorrowedReturns();
         this.int32SlotsValue ??= this.joinInt32Slots();
     }
     /** Computes the int32 slot analysis, or starts it on a forked process.
@@ -2056,7 +2162,7 @@ export class LlEmitter {
     emitParts() {
         const parts = emitParts(this);
         const bridged = this.unwindAbi.size > 0 ? bridgePlainUnwindCalls(parts) : parts;
-        const out = this.cpuDispatch ? cloneForCpuDispatch(bridged) : bridged;
+        const out = this.cpuCopies === null ? bridged : cloneForCpuDispatch(bridged, this.cpuCopies);
         return this.heapCensus === null ? out : [...out, this.heapCensus.definitions().join("\n")];
     }
     /** The entry point and JavaScript name of each named function the
@@ -2065,10 +2171,18 @@ export class LlEmitter {
      * displayName, else its sourceName. Function boxes without a static name
      * look the closure's entry up in this table. */
     closureNameEntries;
+    closureNameByEntry;
+    /** The declared functions `closureNames` lists by their wrapper. A scan
+     * sees closures in statements the emitter never reaches (a statement
+     * after a runtimeFence: the fence always jumps), so some of these names
+     * never enter `fnValues`; emitFnValueDefs defines their wrapper anyway,
+     * because the table's entry has to resolve. */
+    closureWrapperNames = new Set();
     closureNames() {
         if (this.closureNameEntries !== undefined)
             return this.closureNameEntries;
         const entries = new Map();
+        this.closureNameByEntry = entries;
         const scan = this.nodeIndex.scan(CLOSURE_KINDS);
         for (const fn of this.mod.functions) {
             eachNodeOfKinds(fn, scan, (node) => {
@@ -2079,7 +2193,9 @@ export class LlEmitter {
                     (target?.sourceName !== "<anonymous>" ? target?.sourceName : undefined);
                 if (target === undefined || name === undefined || name === "")
                     return true;
-                const entry = target.captures === undefined ? mangleWrapper(node.fnName) : this.callTarget(node.fnName);
+                const entry = this.closureEntry(node.fnName, target);
+                if (target.captures === undefined)
+                    this.closureWrapperNames.add(node.fnName);
                 if (!entries.has(entry))
                     entries.set(entry, name);
                 return true;
@@ -2087,6 +2203,21 @@ export class LlEmitter {
         }
         return (this.closureNameEntries = [...entries].map(([entry, name]) => ({ entry, name })));
     }
+    /** The entry point of a closure of `fnName` (closureNames). */
+    closureEntry(fnName, target) {
+        return target.captures === undefined ? mangleWrapper(fnName) : this.callTarget(fnName);
+    }
+    /** The name the closure-name table gives a closure made of `fnName`
+     * (null when it has none), which lets a box of a closure made at the site
+     * skip the table lookup; undefined for a function the module does not
+     * define. */
+    closureNameOf(fnName) {
+        const target = this.fnByName.get(fnName);
+        if (target === undefined)
+            return undefined;
+        this.closureNames();
+        return this.closureNameByEntry.get(this.closureEntry(fnName, target)) ?? null;
+    }
     /** The dispose-observer gates the emitted frees and record writers test
      * (alloc.ts): defined after every helper is emitted, because dynCheck
      * builders, JSON schemas and weak collection constructors are requested
@@ -2095,7 +2226,10 @@ export class LlEmitter {
         const weak = [...this.decls].some((d) => d.includes("@scr_weak_map_new(") || d.includes("@scr_weak_set_new("));
         return [
             `${WEAK_KEYS_GATE} = internal constant i1 ${weak}`,
-            `${RECORD_SOURCES_GATE} = internal constant i1 ${this.dyn.keepsRecordSources}`,
+            `${RECORD_SOURCES_GATE} = internal constant i1 ${this.dyn.keepsRecordSources || this.hasRecordLinks()}`,
+            ...(this.hasRecordLinks()
+                ? [`${RECORD_KEPT_GATE} = internal constant i1 ${this.dyn.keepsRecordSources}`]
+                : []),
             ``,
         ];
     }
@@ -2131,10 +2265,15 @@ export class LlEmitter {
     }
     /** Env-signature wrappers + interned immortal closures for declared
      * functions used as values (the runtime ABI’s sc_w_/sc_fc_ pair): every
-     * mention of `f` yields the same pointer, so `f === f` holds. */
+     * mention of `f` yields the same pointer, so `f === f` holds. The
+     * closure-name table's wrapper entries are included even when their
+     * closure was never emitted (see closureWrapperNames). */
     emitFnValueDefs() {
         const out = [];
-        for (const name of this.fnValues) {
+        const names = new Set(this.fnValues);
+        for (const name of this.closureWrapperNames)
+            names.add(name);
+        for (const name of names) {
             const fn = this.fnByName.get(name);
             const params = fn.params.map((p, i) => `${this.llType(p.type)} %a${i}`);
             const args = fn.params.map((p, i) => `${this.llType(p.type)} %a${i}`).join(", ");
@@ -3010,11 +3149,27 @@ export class LlEmitter {
     toFrame(v) {
         this.disownTemp(v);
     }
+    /** Whether a value of `type` is an instance of a tree class, whose retain
+     * is a no-op and whose release destroys the subtree: it has exactly one
+     * owner, so it may only be moved. */
+    isTreeValue(type) {
+        if (this.treeMoves === null)
+            return false;
+        const nullable = this.shapeHost.nullableUnions.of(type);
+        const arm = nullable === null ? type : nullable.repr === "single" ? nullable.arm : null;
+        return (arm !== null && arm.kind === "object" && this.classMeta.get(arm.className)?.tree === true);
+    }
     /** The retained (+1) read of a refcounted value — type-directed through
      * the `_v` table (immortals skip, exactly the C retain calls). */
     retainCall(name, type) {
         if (this.isImmortal(name))
             return name;
+        // A copy of a tree value would be a second owner, and the two would
+        // destroy the same nodes. Every accepted read of one is a move
+        // (takeLastUseMove), so a retain means the plan and the emitter
+        // disagree: fail here rather than corrupt the heap.
+        if (this.isTreeValue(type))
+            throw new InternalCompilerError(`llvm emitter bug: tree value ${name} is copied instead of moved`);
         const t = this.B.tmp();
         this.B.line(`${t} = call ptr ${retainSym(this.shapeHost, type)}(ptr ${name})`);
         return t;
@@ -4070,6 +4225,29 @@ export class LlEmitter {
             single.arm.kind === "object" &&
             isCompact(single.arm.className));
     }
+    /** Whether values of `t` are NULL or a refcounted object that lies in the
+     * allocator's window below 32 GiB, so that a compact class field of type
+     * `t` can store it as a 32-bit reference: an array, map or set, or an
+     * instance of a class that is not compact and that the program allocates
+     * (not the runtime's Error hierarchy, whose instances the runtime
+     * allocates), or one of these or `undefined`/`null` (NULL). Strings keep
+     * 8-byte pointers: literals lie in the executable's image. */
+    windowRefType(t, isCompact) {
+        const target = (u) => {
+            if (u.kind === "array" || u.kind === "map" || u.kind === "set")
+                return true;
+            if (u.kind !== "object" || isCompact(u.className))
+                return false;
+            const meta = this.classMeta.get(u.className);
+            return meta !== undefined && meta.root.def.runtime !== true;
+        };
+        if (target(t))
+            return true;
+        if (t.kind !== "union")
+            return false;
+        const single = this.nullableUnions.single(t.unionId);
+        return single !== null && single.nullTag < 0 && target(single.arm);
+    }
     /** Whether arrays of `elem` hold 32-bit references (SCR_ELEM_CREF). */
     compactArrayElem(elem) {
         return this.compactRegion && this.compactRefType(elem);
@@ -4240,6 +4418,155 @@ export class LlEmitter {
         const type = shape.fields[idx].type;
         return { ptr: p, type, inline: this.inlineUnions.record(type) };
     }
+    /** Whether a value of `shapeId` may lack field `field`: a PARTIAL record
+     * view (record-views.ts) whose viewed record does not declare it. A field
+     * with no value representation (a unit type) keeps its slot lookup. */
+    partialFieldMissing(shapeId, field) {
+        if (this.shapeHost.recordViews?.partialMissing(shapeId, field) !== true)
+            return false;
+        const type = this.recordShape(shapeId).fields.find((f) => f.name === field)?.type;
+        return type !== undefined && !isUnitType(type);
+    }
+    /** The viewed record's slot for `field` of a partial view, or NULL when
+     * that record does not declare the field. The caller has established that
+     * `obj` is a view. */
+    partialViewSlot(objName, shapeId, field) {
+        const position = this.recordShape(shapeId).fields.findIndex((f) => f.name === field);
+        this.declare(`declare ptr @scr_record_view_slot(ptr, ${this.sizeType})`);
+        const slot = this.B.tmp();
+        this.B.line(`${slot} = call ptr @scr_record_view_slot(ptr ${objName}, ${this.sizeType} ${position})`);
+        return slot;
+    }
+    /** The boxed property a partial view keeps for a field its viewed record
+     * does not declare (NULL until something writes it). */
+    partialViewExtra(objName, field) {
+        this.declare(`declare ptr @scr_record_view_extra(ptr, ptr, ${this.sizeType})`);
+        const extra = this.B.tmp();
+        this.B.line(`${extra} = call ptr @scr_record_view_extra(ptr ${objName}, ptr ${this.cstr(field)}, ${this.sizeType} ${Buffer.byteLength(field, "utf8")})`);
+        return extra;
+    }
+    /** Reads field `field` of `obj` (shape `shapeId`) where a PARTIAL view may
+     * lack it. A view's present field reads through the viewed record's slot;
+     * a field that record does not declare reads the property a write left in
+     * the view's extra store, converted back to the field type; a field
+     * nothing wrote stops the program (the frontend's checked read throws its
+     * TypeError first). The answer is owned, like a checked conversion's. */
+    readPartialField(objName, shapeId, field, type) {
+        const B = this.B;
+        const idx = this.recordShape(shapeId).fields.findIndex((f) => f.name === field);
+        const inline = this.inlineUnions.record(type);
+        const isView = B.tmp();
+        const view = B.newLabel("pf.view");
+        const notView = B.newLabel("pf.slot");
+        const slots = B.newLabel("pf.slots");
+        const extra = B.newLabel("pf.extra");
+        const answer = B.newLabel("pf.answer");
+        for (const line of recordViewTestLines(this.sizeType, objName, isView))
+            B.line(line.trimStart());
+        B.condBr(isView, view, notView);
+        // Not a view: the field's own slot.
+        B.startBlock(notView);
+        const own = B.tmp();
+        B.line(`${own} = getelementptr inbounds %${mangleRecordStruct(shapeId)}, ptr ${objName}, i64 0, i32 ${idx + this.nullableUnions.fieldBase(shapeId)}`);
+        const ownFrom = B.currentLabel();
+        B.br(slots);
+        B.startBlock(view);
+        const slot = this.partialViewSlot(objName, shapeId, field);
+        const present = B.tmp();
+        B.line(`${present} = icmp ne ptr ${slot}, null`);
+        const slotFrom = B.currentLabel();
+        B.condBr(present, slots, extra);
+        B.startBlock(slots);
+        const addr = B.tmp();
+        B.line(`${addr} = phi ptr [ ${own}, %${ownFrom} ], [ ${slot}, %${slotFrom} ]`);
+        // An inline union field answers a private stack box, as a plain read does.
+        const loaded = inline
+            ? this.inlineFieldUnion(addr, type)
+            : this.loadRecordField(addr, type, false);
+        const hit = isRefCounted(type) ? this.retainFrame(loaded, type) : loaded;
+        const hitFrom = B.currentLabel();
+        B.br(answer);
+        B.startBlock(extra);
+        const stored = this.partialViewExtra(objName, field);
+        const absent = B.tmp();
+        B.line(`${absent} = icmp eq ptr ${stored}, null`);
+        const trap = B.newLabel("pf.absent");
+        const convert = B.newLabel("pf.convert");
+        B.condBr(absent, trap, convert);
+        B.startBlock(trap);
+        absentTrapLines(B, (text) => this.cstr(text), (decl) => this.declare(decl));
+        B.startBlock(convert);
+        const path = B.slot();
+        B.entryAllocas.push(`${path} = alloca %ScrDynPath`);
+        const parentPtr = B.tmp();
+        const keyPtr = B.tmp();
+        const indexPtr = B.tmp();
+        B.line(`${parentPtr} = getelementptr inbounds %ScrDynPath, ptr ${path}, i64 0, i32 0`);
+        B.line(`store ptr null, ptr ${parentPtr}`);
+        B.line(`${keyPtr} = getelementptr inbounds %ScrDynPath, ptr ${path}, i64 0, i32 1`);
+        B.line(`store ptr ${this.cstr(field)}, ptr ${keyPtr}`);
+        B.line(`${indexPtr} = getelementptr inbounds %ScrDynPath, ptr ${path}, i64 0, i32 2`);
+        B.line(`store ${this.sizeType} 0, ptr ${indexPtr}`);
+        const helper = this.dyn.dynCheckHelper(type);
+        const ty = this.llType(type);
+        const checked = B.tmp();
+        B.line(`${checked} = call ${ty === "i1" ? "zeroext i1" : ty} @${helper}(ptr ${stored}, ptr ${path})`);
+        const convertFrom = B.currentLabel();
+        B.br(answer);
+        B.startBlock(answer);
+        const value = B.tmp();
+        B.line(`${value} = phi ${ty} [ ${hit}, %${hitFrom} ], [ ${checked}, %${convertFrom} ]`);
+        return { name: value, type };
+    }
+    /** Stores `value` into field `field` of `obj` (shape `shapeId`) where a
+     * PARTIAL view may lack it, calling `storeAt` with the address to write.
+     * A field the viewed record does not declare is kept as a boxed property
+     * in the view's extra store, where reflection and a later read see it;
+     * `released` gives up a caller reference the frame does not own. */
+    storePartialField(objName, shapeId, field, type, value, storeAt, released) {
+        const B = this.B;
+        const idx = this.recordShape(shapeId).fields.findIndex((f) => f.name === field);
+        const isView = B.tmp();
+        const notView = B.newLabel("ps.slot");
+        const view = B.newLabel("ps.view");
+        const present = B.newLabel("ps.present");
+        const store = B.newLabel("ps.store");
+        const extra = B.newLabel("ps.extra");
+        const done = B.newLabel("ps.done");
+        for (const line of recordViewTestLines(this.sizeType, objName, isView))
+            B.line(line.trimStart());
+        B.condBr(isView, view, notView);
+        B.startBlock(notView);
+        const own = B.tmp();
+        B.line(`${own} = getelementptr inbounds %${mangleRecordStruct(shapeId)}, ptr ${objName}, i64 0, i32 ${idx + this.nullableUnions.fieldBase(shapeId)}`);
+        const ownFrom = B.currentLabel();
+        B.br(store);
+        B.startBlock(view);
+        const slot = this.partialViewSlot(objName, shapeId, field);
+        const hasSlot = B.tmp();
+        B.line(`${hasSlot} = icmp ne ptr ${slot}, null`);
+        B.condBr(hasSlot, present, extra);
+        B.startBlock(present);
+        const presentFrom = B.currentLabel();
+        B.br(store);
+        // One store site whichever slot answers: the value's frame ownership
+        // ends in one place, whether the write runs on this program's path or
+        // on the other branch of the test.
+        B.startBlock(store);
+        const addr = B.tmp();
+        B.line(`${addr} = phi ptr [ ${own}, %${ownFrom} ], [ ${slot}, %${presentFrom} ]`);
+        storeAt(addr);
+        B.br(done);
+        B.startBlock(extra);
+        const boxed = B.tmp();
+        const box = this.dyn.toDynHelper(type);
+        B.line(`${boxed} = call ptr @${box}(${this.llType(type)} ${value.name})`);
+        this.declare(`declare void @scr_record_view_extra_set(ptr, ptr, ${this.sizeType}, ptr)`);
+        B.line(`call void @scr_record_view_extra_set(ptr ${objName}, ptr ${this.cstr(field)}, ${this.sizeType} ${Buffer.byteLength(field, "utf8")}, ptr ${boxed})`);
+        released?.();
+        B.br(done);
+        B.startBlock(done);
+    }
     /** The overflow map's slot pointer on an index-signature shape. */
     recordOvfPtr(objName, shapeId) {
         const shape = this.recordShape(shapeId);
@@ -5041,7 +5368,7 @@ export class LlEmitter {
     /** An emitter for a range of this module's functions: the same facts,
      * empty module-level tables, and a journal of what the range adds. */
     chunkEmitter() {
-        const chunk = new LlEmitter(this.mod, { ...this.targetOptions, functionChunks: 1 }, new EmitJournal());
+        const chunk = new LlEmitter(this.mod, { ...this.targetOptions, functionChunks: 1 }, new EmitJournal(), null, this.nodeIndex);
         chunk.debug?.record();
         return chunk;
     }
@@ -5217,7 +5544,8 @@ export class LlEmitter {
             const exception = B.tmp();
             B.line(`${exception} = landingpad { ptr, i32 } cleanup`);
             for (const index of borrowed)
-                this.releaseFrame(`%p${index}`, fn.params[index].type);
+                if (!this.isTreeValue(fn.params[index].type))
+                    this.releaseFrame(`%p${index}`, fn.params[index].type);
             this.declare(UNWIND_RESUME_DECLARATION);
             B.resumeUnwind(exception);
             B.startBlock(ok);
@@ -5244,8 +5572,10 @@ export class LlEmitter {
             result = B.tmp();
             B.line(`${result} = load ptr, ptr ${slot}`);
         }
+        // A tree value is passed by reference to its owner and never counted,
+        // so the wrapper has nothing to drop for it.
         for (const index of borrowed)
-            if (!kept.has(index))
+            if (!kept.has(index) && !this.isTreeValue(fn.params[index].type))
                 this.releaseFrame(`%p${index}`, fn.params[index].type);
         B.terminate(ret === "void" ? "ret void" : `ret ${ret} ${result}`);
         const symbol = kept.size > 0 ? `${mangleBorrowedFunction(fn.name)}.virtual` : mangleFunction(fn.name);
@@ -5486,6 +5816,17 @@ export class LlEmitter {
     /** Emits the move of a noted last read: the slot is cleared, so scope
      * exits release nothing and the read's owned temp carries the reference. */
     takeLastUseMove(e, slot, type) {
+        if (this.isTreeValue(e.type)) {
+            // A tree value has one owner and no count: every read of it that the
+            // plan accepted IS its transfer (backend/tree-classes.ts records the
+            // expression), so the read takes the reference exactly as a last-use
+            // move does. A read the plan did not record would copy the node,
+            // which retainCall refuses.
+            if (this.treeMoves?.delete(e) !== true)
+                return false;
+            this.B.line(`store ptr null, ptr ${slot}`);
+            return true;
+        }
         if (this.lastUseMoves.get(e) !== slot || !typeEquals(type, e.type))
             return false;
         this.lastUseMoves.delete(e);
@@ -6771,6 +7112,11 @@ export class LlEmitter {
     /** Group arenas (arenas.ts): the plan, the list slot of each root and
      * call region, and which locals' scopes drop which roots' arenas. */
     arenas = null;
+    /** The varRef reads the tree-class plan proved move a node out of its
+     * local (backend/tree-classes.ts). Each one emits its own last-use move:
+     * the source slot is nulled and the value taken without a retain, since
+     * a tree instance has no count to raise. */
+    treeMoves = null;
     arenaSlots = new Map();
     /** The frames emitStmtBody opens for whole statements (arenas only). */
     statementFrames = new Set();
@@ -6919,6 +7265,29 @@ export class LlEmitter {
         this.journal?.site(name, "jsIcSite");
         return name;
     }
+    /** A fresh guard-group record (js-groups.ts). */
+    jsGroup() {
+        const name = `@sc_js_group_${this.jsGroupCount++}`;
+        this.journal?.site(name, "jsGroup");
+        return name;
+    }
+    /** The constant key array `keys` (string literal symbols) that a group's
+     * probe reads, shared by every group with the same keys. */
+    jsGroupKeys(keys) {
+        const text = keys.join("\u0000");
+        let name = this.jsGroupKeysByText.get(text);
+        if (name !== undefined)
+            return name;
+        name = `@sc_gkeys_${this.jsGroupKeysCount++}`;
+        this.jsGroupKeysByText.set(text, name);
+        this.jsGroupKeysByName.set(name, keys);
+        this.journal?.site(name, "jsGroupKeys", [keys]);
+        return name;
+    }
+    /** The key array of each of this module's guard groups, by name. */
+    get jsGroupKeysTable() {
+        return this.jsGroupKeysByName;
+    }
     /** A fresh read-site cache for one constant-key dyn read. */
     dynReadIcSite() {
         const name = `@sc_dyn_read_ic_${this.dynReadIcSites++}`;
@@ -7144,8 +7513,8 @@ export class LlEmitter {
     emitRecordKeyGet(e) {
         return emitRecordKeyGet(this, e);
     }
-    keyedRecordReadInto(slot, join, objName, keyName, shapeId, resultType, overflowOnly, loc, missNaN = false) {
-        return keyedRecordReadInto(this, slot, join, objName, keyName, shapeId, resultType, overflowOnly, loc, missNaN);
+    keyedRecordReadInto(slot, join, objName, keyName, shapeId, resultType, overflowOnly, loc, missNaN = false, missInto = null, read = null) {
+        return keyedRecordReadInto(this, slot, join, objName, keyName, shapeId, resultType, overflowOnly, loc, missNaN, missInto, read);
     }
     dynPromiseAdapter(inner) {
         return dynPromiseAdapter(this, inner);
@@ -7262,6 +7631,8 @@ function addNumberedSymbol(into, key, entry, prefix, names) {
         names.set(entry.sym, own.sym);
 }
 registerReplay("jsIcSite", (emitter) => emitter.jsIcSite());
+registerReplay("jsGroup", (emitter) => emitter.jsGroup());
+registerReplay("jsGroupKeys", (emitter, args) => emitter.jsGroupKeys(args[0]));
 registerReplay("dynReadIcSite", (emitter) => emitter.dynReadIcSite());
 registerReplay("speculativeLoopSite", (emitter) => emitter.speculativeLoopSite());
 for (const op of [