@scriptc/compiler 0.4.1 → 0.4.3

package/dist/backend/llvm/expr-stream-bridges.js

@@ -2,14 +2,17 @@ import { typedRefConstructor } from "./shapes.js";
 /* Focused LLVM expression emission extracted from emitter.ts. */
 import { InternalCompilerError } from "../../errors.js";
 import { streamTypedRefEligible, undefinedArmTag } from "../../ir/analysis.js";
-import { CLASS_ATTRIBUTES, DYN_CLASS_PROPERTIES, RUNTIME_STREAM_CLASSES, SYMBOL_T, classDynViewSupported, classFieldAttributesName, isClassOwnEnumerableFieldName, isDirentShape, isDynTypedRefType, isRefCounted, shapeHasAccessorSlots, typeKey, } from "../../ir/ir.js";
+import { CLASS_ATTRIBUTES, DYN_CLASS_PROPERTIES, RUNTIME_STREAM_CLASSES, SYMBOL_T, classDynViewSupported, classFieldAttributesName, isClassOwnEnumerableFieldName, isDirentShape, KEY_ORDER_FIELD, shapeKeyOrders, isDynTypedRefType, textCodecRecordClass, isRefCounted, shapeHasAccessorSlots, typeKey, } from "../../ir/ir.js";
 import { mangleFunction, mangleGlobal, mangleRecordStruct } from "../mangle.js";
 import { BlockBuilder } from "./blocks.js";
-import { classFieldIndex, classPreLines, classStructSym } from "./classes.js";
+import { classFieldIndex, classPreLines, classStructSym, compactRefLoadLines, compactRefStoreLines, } from "./classes.js";
 import { SCR_ARR_FIELD, llvmCommentText } from "./common.js";
 import { FN_ATTRS, elemAccess, llFieldType, loadStructField, releaseSym, traceArg, vAdapters, } from "./shapes.js";
 import { emitUnionPeek, emitUnionTag } from "./union-repr.js";
 import { inlineUnionCopyLines } from "./inline-unions.js";
+import { recordMayKeepSource } from "./record-sources.js";
+import { emitPerKeyOrder } from "./key-orders.js";
+import { registerReplay } from "./emit-journal.js";
 /** An owned (+1) union value for a nullable-pointer class field slot `p`
  * (the unit arm's immortal instance, or a fresh box around a retained
  * instance). The bridge releases it after boxing. */
@@ -40,6 +43,7 @@ export function dynPromiseAdapter(host, inner) {
         return existing;
     const sym = `sc_dpa_${host.dynPromiseAdapters.size}`;
     host.dynPromiseAdapters.set(key, sym);
+    host.journal?.allocated(sym, "dynPromiseAdapter", [inner]);
     host.declare(`declare ptr @scr_promise_payload_ref(ptr)`);
     host.declare(`declare void @scr_dyn_release_v(ptr)`);
     host.declare(`declare void @scr_promise_reject_pending(ptr)`);
@@ -84,6 +88,7 @@ export function dynPromiseAdapter(host, inner) {
     }
     B.terminate(`ret void`);
     host.resolveThunkDefs.push(`define internal void @${sym}(ptr %dst, ptr %src) ${FN_ATTRS} { ; checked-dynamic promise exit ${key}`, B.render(), `}`, ``);
+    host.journal?.built();
     return sym;
 }
 export function streamTypedRefCommitAdapter(host, t, snapshot) {
@@ -104,6 +109,7 @@ export function streamTypedRefCommitAdapter(host, t, snapshot) {
         const check = host.dyn.dynCheckHelper(t);
         host.declare(`declare void @scr_arr_release(ptr)`);
         host.declare(`declare void @scr_arr_outline(ptr)`);
+        host.declare(`declare void @scr_arr_adopt_view_properties(ptr, ptr, ptr)`);
         const lines = [
             `define internal void @${commit}(ptr %target, ptr %d) ${FN_ATTRS} { ; commit live stream element ${typeKey(t)}`,
             `entry:`,
@@ -111,6 +117,8 @@ export function streamTypedRefCommitAdapter(host, t, snapshot) {
             `  %missing = icmp eq ptr %next, null`,
             `  br i1 %missing, label %done, label %swap`,
             `swap:`,
+            // Properties move with the storage (in its out-of-line part).
+            `  call void @scr_arr_adopt_view_properties(ptr %next, ptr %d, ptr %target)`,
             // Inline slots live in each header's block; move them out first.
             `  call void @scr_arr_outline(ptr %target)`,
             `  call void @scr_arr_outline(ptr %next)`,
@@ -121,7 +129,10 @@ export function streamTypedRefCommitAdapter(host, t, snapshot) {
             { name: "cap", index: SCR_ARR_FIELD.cap, type: "i32" },
             { name: "data", index: SCR_ARR_FIELD.data, type: "ptr" },
             { name: "filled", index: SCR_ARR_FIELD.filled, type: "i32" },
-            { name: "ext", index: SCR_ARR_FIELD.ext, type: "ptr" },
+            // The out-of-line storage's pointer lives before the dense allocation
+            // and moves with data; its flag is in spare, whose element ops id the
+            // two arrays share.
+            { name: "spare", index: SCR_ARR_FIELD.spare, type: "i16" },
         ];
         for (const member of storageMembers) {
             lines.push(`  %target_${member.name}_ptr = getelementptr inbounds %ScrArr, ptr %target, i64 0, i32 ${member.index}`, `  %next_${member.name}_ptr = getelementptr inbounds %ScrArr, ptr %next, i64 0, i32 ${member.index}`, `  %target_${member.name} = load ${member.type}, ptr %target_${member.name}_ptr`, `  %next_${member.name} = load ${member.type}, ptr %next_${member.name}_ptr`, `  store ${member.type} %next_${member.name}, ptr %target_${member.name}_ptr`, `  store ${member.type} %target_${member.name}, ptr %next_${member.name}_ptr`);
@@ -164,7 +175,7 @@ export function streamTypedRefCommitAdapter(host, t, snapshot) {
             const pending = `f${index}_pending`;
             const store = `f${index}_store`;
             const after = `f${index}_after`;
-            const { index: fieldIndex } = classFieldIndex(meta, field.name);
+            const { index: fieldIndex, compressed } = classFieldIndex(meta, field.name, "compressed");
             const int32 = host.int32Slots.isField(t.className, field.name);
             const inline = host.inlineUnions.classField(t.className, field.name);
             const fieldTy = int32 ? "i32" : llFieldType(field.type, inline);
@@ -187,7 +198,12 @@ export function streamTypedRefCommitAdapter(host, t, snapshot) {
                 lines.push(`  %${raw} = call ptr @scr_dyn_obj_get(ptr %d, ptr ${host.cstr(field.name)}, ${host.sizeType} ${Buffer.byteLength(field.name, "utf8")})`);
             if (meta.def.tracksOwnFields && !symbolGlobal)
                 lines.push(`  %f${index}_present = icmp ne ptr %${raw}, null`, `  br i1 %f${index}_present, label %f${index}_read, label %${after}`, `f${index}_read:`);
-            lines.push(`  %${missing} = icmp eq ptr %${raw}, null`, `  %${undef} = call ptr @scr_dyn_undefined()`, `  %${input} = select i1 %${missing}, ptr %${undef}, ptr %${raw}`, `  %${next} = call ${field.type.kind === "bool" ? "zeroext " : ""}${checkTy} @${host.dyn.dynCheckHelper(field.type)}(ptr %${input}, ptr null)`, ...(symbolGlobal ? [`  call void @scr_dyn_release_v(ptr %${raw})`] : []), ...host.pendingTestLines(`%${pending}`), `  br i1 %${pending}, label %done, label %${store}`, `${store}:`, `  %f${index}_ptr = getelementptr inbounds %${classStructSym(t.className)}, ptr %target, i64 0, i32 ${fieldIndex}`, `  %f${index}_old = load ${fieldTy}, ptr %f${index}_ptr`);
+            lines.push(`  %${missing} = icmp eq ptr %${raw}, null`, `  %${undef} = call ptr @scr_dyn_undefined()`, `  %${input} = select i1 %${missing}, ptr %${undef}, ptr %${raw}`, `  %${next} = call ${field.type.kind === "bool" ? "zeroext " : ""}${checkTy} @${host.dyn.dynCheckHelper(field.type)}(ptr %${input}, ptr null)`, ...(symbolGlobal ? [`  call void @scr_dyn_release_v(ptr %${raw})`] : []), ...host.pendingTestLines(`%${pending}`), `  br i1 %${pending}, label %done, label %${store}`, `${store}:`, `  %f${index}_ptr = getelementptr inbounds %${classStructSym(t.className)}, ptr %target, i64 0, i32 ${fieldIndex}`, ...(compressed
+                ? [
+                    `  %f${index}_oldidx = load i32, ptr %f${index}_ptr`,
+                    ...compactRefLoadLines(`%f${index}_oldidx`, `%f${index}_old`, `%f${index}_od`),
+                ]
+                : [`  %f${index}_old = load ${fieldTy}, ptr %f${index}_ptr`]));
             if (int32) {
                 // int32-slots.ts keeps a field int32 only when no dynamic store in
                 // the program can name it, so the view still holds the exact int32
@@ -204,7 +220,12 @@ export function streamTypedRefCommitAdapter(host, t, snapshot) {
                 // instance pointer (NULL for the unit arm).
                 const rc = vAdapters(host.shapeHost, nullable.arm);
                 host.declare(`declare void @scr_union_release(ptr)`);
-                lines.push(`  %f${index}_tagp = getelementptr inbounds %ScrUnion, ptr %${next}, i64 0, i32 1`, `  %f${index}_tag = load i32, ptr %f${index}_tagp`, `  %f${index}_isref = icmp eq i32 %f${index}_tag, ${nullable.refTag}`, `  %f${index}_payp = getelementptr inbounds %ScrUnion, ptr %${next}, i64 0, i32 5`, `  %f${index}_pay = load ptr, ptr %f${index}_payp`, `  %f${index}_sel = select i1 %f${index}_isref, ptr %f${index}_pay, ptr null`, `  %f${index}_new = call ptr ${rc.retain}(ptr %f${index}_sel)`, `  store ptr %f${index}_new, ptr %f${index}_ptr`, `  call void @scr_union_release(ptr %${next})`, `  call void ${rc.release}(ptr %f${index}_old)`, `  br label %${after}`, `${after}:`);
+                lines.push(`  %f${index}_tagp = getelementptr inbounds %ScrUnion, ptr %${next}, i64 0, i32 1`, `  %f${index}_tag = load i32, ptr %f${index}_tagp`, `  %f${index}_isref = icmp eq i32 %f${index}_tag, ${nullable.refTag}`, `  %f${index}_payp = getelementptr inbounds %ScrUnion, ptr %${next}, i64 0, i32 5`, `  %f${index}_pay = load ptr, ptr %f${index}_payp`, `  %f${index}_sel = select i1 %f${index}_isref, ptr %f${index}_pay, ptr null`, `  %f${index}_new = call ptr ${rc.retain}(ptr %f${index}_sel)`, ...(compressed
+                    ? [
+                        ...compactRefStoreLines(`%f${index}_new`, `%f${index}_newidx`, `%f${index}_ne`),
+                        `  store i32 %f${index}_newidx, ptr %f${index}_ptr`,
+                    ]
+                    : [`  store ptr %f${index}_new, ptr %f${index}_ptr`]), `  call void @scr_union_release(ptr %${next})`, `  call void ${rc.release}(ptr %f${index}_old)`, `  br label %${after}`, `${after}:`);
                 continue;
             }
             if (inline) {
@@ -215,6 +236,9 @@ export function streamTypedRefCommitAdapter(host, t, snapshot) {
             if (field.type.kind === "bool") {
                 lines.push(`  %f${index}_stored = zext i1 %${next} to i8`, `  store i8 %f${index}_stored, ptr %f${index}_ptr`);
             }
+            else if (compressed) {
+                lines.push(...compactRefStoreLines(`%${next}`, `%f${index}_nextidx`, `%f${index}_nx`), `  store i32 %f${index}_nextidx, ptr %f${index}_ptr`);
+            }
             else {
                 lines.push(`  store ${fieldTy} %${next}, ptr %f${index}_ptr`);
             }
@@ -306,6 +330,12 @@ export function streamTypedRefCommitAdapter(host, t, snapshot) {
     members.forEach((member, index) => {
         lines.push(`  %tp${index} = getelementptr inbounds %${mangleRecordStruct(t.shapeId)}, ptr %target, i64 0, i32 ${member.index}`, `  %np${index} = getelementptr inbounds %${mangleRecordStruct(t.shapeId)}, ptr %next, i64 0, i32 ${member.index}`, `  %old${index} = load ${member.type}, ptr %tp${index} ; ${llvmCommentText(member.name)}`, `  %new${index} = load ${member.type}, ptr %np${index}`, `  store ${member.type} %new${index}, ptr %tp${index}`, `  store ${member.type} %old${index}, ptr %np${index}`);
     });
+    // The conversion kept the view's undeclared properties for %next. Shapes
+    // with accessor slots keep their accessors in the view instead.
+    if (recordMayKeepSource(shape) && !shapeHasAccessorSlots(shape)) {
+        host.declare(`declare void @scr_record_source_move(ptr, ptr)`);
+        lines.push(`  call void @scr_record_source_move(ptr %next, ptr %target)`);
+    }
     lines.push(`  call void ${releaseSym(host.shapeHost, t)}(ptr %next)`, `  br label %done`, `done:`, `  ret void`, `}`, ``);
     host.resolveThunkDefs.push(...lines);
     return `@${commit}`;
@@ -319,14 +349,20 @@ export function liveDynUnionRefAdapter(host, t) {
     if (!union) {
         throw new InternalCompilerError(`llvm emitter bug: live dyn ref of unknown union ${t.unionId}`);
     }
+    // Codec records box as their own handles, by reference, through toDynHelper.
+    const codecArm = (arm) => textCodecRecordClass(arm, (id) => host.recordsById.get(id)) !== null;
     const mutableArms = union.arms
         .map((arm, tag) => ({ arm, tag }))
-        .filter(({ arm }) => arm.kind !== "bytes" && (streamTypedRefEligible(arm) || isDynTypedRefType(arm)));
-    if (mutableArms.length === 0 && !union.arms.some((arm) => arm.kind === "bytes")) {
+        .filter(({ arm }) => arm.kind !== "bytes" &&
+        !codecArm(arm) &&
+        (streamTypedRefEligible(arm) || isDynTypedRefType(arm)));
+    if (mutableArms.length === 0 &&
+        !union.arms.some((arm) => arm.kind === "bytes" || codecArm(arm))) {
         throw new InternalCompilerError(`llvm emitter bug: live dyn ref of immutable union ${key}`);
     }
     const sym = `sc_ldu_${host.liveDynUnionRefAdapters.size}`;
     host.liveDynUnionRefAdapters.set(key, sym);
+    host.journal?.allocated(sym, "liveDynUnionRefAdapter", [t]);
     const adapters = new Map();
     for (const { arm, tag } of mutableArms) {
         adapters.set(tag, host.liveDynRefAdapter(arm));
@@ -403,6 +439,7 @@ export function liveDynUnionRefAdapter(host, t) {
     B.line(`call void @scr_trap(ptr ${host.cstr("scriptc: internal error: invalid union tag\n")})`);
     B.terminate(`unreachable`);
     host.resolveThunkDefs.push(`define internal ptr @${sym}(ptr %u) ${FN_ATTRS} { ; materialize live union value ${key}`, B.render(), `}`, ``);
+    host.journal?.built();
     return sym;
 }
 export function streamTypedRefBoxValue(host, B, t, value) {
@@ -415,7 +452,11 @@ export function streamTypedRefBoxValue(host, B, t, value) {
         B.line(`${boxed} = call ptr @${host.liveDynUnionRefAdapter(t)}(ptr ${value})`);
         return boxed;
     }
-    if (t.kind === "bytes" || (!streamTypedRefEligible(t) && !isDynTypedRefType(t))) {
+    // A codec record boxes as its own handle, by reference (toDynHelper), as
+    // it does outside a live view.
+    if (t.kind === "bytes" ||
+        textCodecRecordClass(t, (id) => host.recordsById.get(id)) !== null ||
+        (!streamTypedRefEligible(t) && !isDynTypedRefType(t))) {
         const valueTy = host.llType(t);
         B.line(`${boxed} = call ptr @${host.dyn.toDynHelper(t)}(${valueTy} ${value})`);
         return boxed;
@@ -438,12 +479,14 @@ export function streamTypedRefMaterializeAdapter(host, t) {
     const snapshot = `sc_ldr_${host.liveDynRefAdapters.size}_materialize`;
     const adapter = { snapshot, commit: "null" };
     host.liveDynRefAdapters.set(key, adapter);
+    host.journal?.allocated(snapshot.replace(/_materialize$/, ""), "streamTypedRefMaterializeAdapter", [t]);
     if (isDynTypedRefType(t)) {
         const fields = host.classMeta.get(t.className)?.def.fields;
         if (fields &&
             !classDynViewSupported(fields, (id) => host.recordsById.get(id), (id) => host.unionsById.get(id))) {
             host.declare(`declare ptr @scr_dyn_class_view_unavailable(ptr)`);
             adapter.snapshot = "scr_dyn_class_view_unavailable";
+            host.journal?.built();
             return adapter;
         }
     }
@@ -454,6 +497,8 @@ export function streamTypedRefMaterializeAdapter(host, t) {
     const opsMeta = isDynTypedRefType(t) ? host.classMeta.get(t.className) : undefined;
     if (opsMeta && liveClassOpsEligible(opsMeta))
         adapter.classOps = `@${snapshot}_cops`;
+    else if (opsMeta && liveBagClassOpsEligible(opsMeta))
+        adapter.bagClassOps = `@${snapshot}_bops`;
     adapter.commit = `@${snapshot}_commit`;
     adapter.commit = host.streamTypedRefCommitAdapter(t, snapshot);
     const B = new BlockBuilder();
@@ -464,6 +509,8 @@ export function streamTypedRefMaterializeAdapter(host, t) {
         }
         if (adapter.classOps !== undefined)
             liveClassOps(host, snapshot, meta);
+        if (adapter.bagClassOps !== undefined)
+            liveBagClassOps(host, snapshot, meta, t);
         if (meta.hierarchy && meta.children.length) {
             const pre = B.tmp();
             for (const line of classPreLines(meta, classStructSym(t.className), "%p", pre, host.sizeType))
@@ -528,8 +575,7 @@ export function streamTypedRefMaterializeAdapter(host, t) {
             B.line(`call void @scr_dyn_release_v(ptr ${prototype})`);
             B.line(`call void @scr_dyn_release_v(ptr ${attached})`);
         }
-        for (const field of meta.def.fields.filter((f) => isClassOwnEnumerableFieldName(f.name) &&
-            !(meta.root.def.name === "%Error" && (f.name === "message" || f.name === "name")))) {
+        for (const field of classViewFields(meta)) {
             const afterField = meta.def.tracksOwnFields ? B.newLabel("field.after") : null;
             if (afterField) {
                 host.declare(`declare ptr @scr_dyn_obj_get(ptr, ptr, ${host.sizeType})`);
@@ -539,28 +585,7 @@ export function streamTypedRefMaterializeAdapter(host, t) {
                 B.condBr(present, yes, afterField);
                 B.startBlock(yes);
             }
-            const { index } = classFieldIndex(meta, field.name);
-            const fieldPtr = B.tmp();
-            let fieldValue = B.tmp();
-            B.line(`${fieldPtr} = getelementptr inbounds %${classStructSym(t.className)}, ptr %p, i64 0, i32 ${index}`);
-            if (host.int32Slots.isField(t.className, field.name)) {
-                const raw = B.tmp();
-                B.line(`${raw} = load i32, ptr ${fieldPtr}`);
-                B.line(`${fieldValue} = sitofp i32 ${raw} to double`);
-            }
-            else if (host.inlineUnions.classField(t.className, field.name))
-                fieldValue = loadStructField(B, host.sizeType, fieldPtr, field.type, true);
-            else
-                B.line(`${fieldValue} = load ${llFieldType(field.type, false)}, ptr ${fieldPtr}`);
-            if (llFieldType(field.type, false) === "i8") {
-                const boolValue = B.tmp();
-                B.line(`${boolValue} = trunc i8 ${fieldValue} to i1`);
-                fieldValue = boolValue;
-            }
-            const nullable = host.nullableFields.get(t.className, field.name);
-            if (nullable)
-                fieldValue = nullableFieldUnion(host, B, fieldValue, nullable);
-            const boxed = host.streamTypedRefBoxValue(B, field.type, fieldValue);
+            const { boxed, nullable, fieldValue } = classFieldDynValue(host, B, meta, t, field);
             // Attributes copied from the bag do not stop the view taking the value.
             const setter = withAttributes ? "scr_dyn_obj_set_field" : "scr_dyn_obj_set";
             if (withAttributes)
@@ -708,42 +733,55 @@ export function streamTypedRefMaterializeAdapter(host, t) {
             const out = B.tmp();
             B.line(`${out} = call ptr @scr_dyn_new_obj()`);
             const byName = new Map(shape.fields.map((field) => [field.name, field]));
-            const order = shape.declaredOrder ?? shape.fields.map((field) => field.name);
-            const inOrder = new Set(order);
-            const fields = [
-                ...order.map((name) => byName.get(name)).filter((field) => field !== undefined),
-                ...shape.fields.filter((field) => !inOrder.has(field.name)),
-            ];
+            // A shape with orderVariants has one field list per key order; its
+            // order index is no key.
+            const orders = shapeKeyOrders(shape);
+            const fieldsOf = (order) => {
+                const inOrder = new Set(order);
+                return [
+                    ...order.map((name) => byName.get(name)).filter((field) => field !== undefined),
+                    ...shape.fields.filter((field) => !inOrder.has(field.name) && field.name !== KEY_ORDER_FIELD),
+                ];
+            };
             // Published before the field converters, like the array hooks below.
             // A Dirent row reads through its finished view (the prototype and
             // the non-enumerable %dtype).
             const dirent = isDirentShape(shape);
-            if (!dirent && liveRecordOpsEligible(fields)) {
-                adapter.recordOps = `@${snapshot}_rops`;
-                liveRecordOps(host, t, snapshot, fields);
-            }
-            for (const field of fields) {
-                const index = shape.fields.indexOf(field) + host.nullableUnions.fieldBase(t.shapeId);
-                const fieldPtr = B.tmp();
-                B.line(`${fieldPtr} = getelementptr inbounds %${mangleRecordStruct(t.shapeId)}, ptr %p, i64 0, i32 ${index}`);
-                const fieldValue = loadStructField(B, host.sizeType, fieldPtr, field.type, host.inlineUnions.record(field.type));
-                // An ABSENT optional field contributes no key.
-                const undefinedTag = undefinedArmTag(field.type, host.unionsById);
-                let skip = null;
-                if (undefinedTag >= 0 && field.type.kind === "union") {
-                    const absent = host.fieldAbsentTestIn(B, fieldValue, field.type.unionId);
-                    skip = B.newLabel("live.record.absent");
-                    const set = B.newLabel("live.record.set");
-                    B.condBr(absent, skip, set);
-                    B.startBlock(set);
+            if (!dirent && orders.every((order) => liveRecordOpsEligible(fieldsOf(order)))) {
+                if (orders.length === 1) {
+                    adapter.recordOps = `@${snapshot}_rops`;
+                    liveRecordOps(host, t, snapshot, fieldsOf(orders[0]));
                 }
-                const boxed = host.streamTypedRefBoxValue(B, field.type, fieldValue);
-                B.line(`call void @scr_dyn_obj_set(ptr ${out}, ptr ${host.cstr(field.name)}, ${host.sizeType} ${Buffer.byteLength(field.name, "utf8")}, ptr ${boxed})`);
-                if (skip !== null) {
-                    B.br(skip);
-                    B.startBlock(skip);
+                else {
+                    orders.forEach((order, i) => liveRecordOps(host, t, `${snapshot}_o${i}`, fieldsOf(order)));
+                    adapter.recordOps = `@${snapshot}_rops`;
+                    liveRecordOrderSelect(host, shape, snapshot);
                 }
             }
+            emitPerKeyOrder(B, shape, host.nullableUnions.fieldBase(t.shapeId), "%p", (order) => {
+                for (const field of fieldsOf(order)) {
+                    const index = shape.fields.indexOf(field) + host.nullableUnions.fieldBase(t.shapeId);
+                    const fieldPtr = B.tmp();
+                    B.line(`${fieldPtr} = getelementptr inbounds %${mangleRecordStruct(t.shapeId)}, ptr %p, i64 0, i32 ${index}`);
+                    const fieldValue = loadStructField(B, host.sizeType, fieldPtr, field.type, host.inlineUnions.record(field.type));
+                    // An ABSENT optional field contributes no key.
+                    const undefinedTag = undefinedArmTag(field.type, host.unionsById);
+                    let skip = null;
+                    if (undefinedTag >= 0 && field.type.kind === "union") {
+                        const absent = host.fieldAbsentTestIn(B, fieldValue, field.type.unionId);
+                        skip = B.newLabel("live.record.absent");
+                        const set = B.newLabel("live.record.set");
+                        B.condBr(absent, skip, set);
+                        B.startBlock(set);
+                    }
+                    const boxed = host.streamTypedRefBoxValue(B, field.type, fieldValue);
+                    B.line(`call void @scr_dyn_obj_set(ptr ${out}, ptr ${host.cstr(field.name)}, ${host.sizeType} ${Buffer.byteLength(field.name, "utf8")}, ptr ${boxed})`);
+                    if (skip !== null) {
+                        B.br(skip);
+                        B.startBlock(skip);
+                    }
+                }
+            });
             if (dirent) {
                 host.declare(`declare void @scr_dyn_dirent_finish(ptr)`);
                 B.line(`call void @scr_dyn_dirent_finish(ptr ${out})`);
@@ -824,6 +862,7 @@ export function streamTypedRefMaterializeAdapter(host, t) {
         B.terminate(`ret ptr ${out}`);
     }
     host.resolveThunkDefs.push(`define internal ptr @${snapshot}(ptr %p) ${FN_ATTRS} { ; materialize live stream value ${key}`, B.render(), `}`, ``);
+    host.journal?.built();
     return adapter;
 }
 /** Per-element hooks for a live array capsule (ScrDynTypedArrayOps). The
@@ -937,7 +976,23 @@ function liveRecordOps(host, t, snapshot, fields) {
     const literals = fields.map((field) => `ptr ${host.internLiteral(field.name)}`);
     host.resolveThunkDefs.push(`define internal zeroext i1 @${has}(ptr %p, ${host.sizeType} %i) ${FN_ATTRS} { ; live field presence of ${typeKey(t)}`, H.render(), `}`, ``, `define internal ptr @${get}(ptr %p, ${host.sizeType} %i) ${FN_ATTRS} { ; live field of ${typeKey(t)}`, G.render(), `}`, ``, `@${names} = internal constant [${fields.length} x ptr] [${literals.join(", ")}]`, 
     // Mutable: the runtime fills the trailing key-array slot on first use.
-    `@${ops} = internal global { ${host.sizeType}, ptr, ptr, ptr, i8, ptr } { ${host.sizeType} ${fields.length}, ptr @${names}, ptr @${has}, ptr @${get}, i8 ${optional.length === 0 ? 1 : 0}, ptr null }`, ``);
+    `@${ops} = internal global { ${host.sizeType}, ptr, ptr, ptr, i8, ptr, ptr } { ${host.sizeType} ${fields.length}, ptr @${names}, ptr @${has}, ptr @${get}, i8 ${optional.length === 0 ? 1 : 0}, ptr null, ptr null }`, ``);
+}
+/** `@<snapshot>_rops` for a shape with orderVariants: a record-ops table
+ * whose `select` hook answers the `_o<i>_rops` table (liveRecordOps) of the
+ * record's current key order, which a write of an optional key can change
+ * after the record is boxed. */
+function liveRecordOrderSelect(host, shape, snapshot) {
+    const B = new BlockBuilder();
+    const out = B.slot();
+    B.entryAllocas.push(`${out} = alloca ptr`);
+    emitPerKeyOrder(B, shape, host.nullableUnions.fieldBase(shape.id), "%p", (_, i) => {
+        B.line(`store ptr @${snapshot}_o${i}_rops, ptr ${out}`);
+    });
+    const ops = B.tmp();
+    B.line(`${ops} = load ptr, ptr ${out}`);
+    B.terminate(`ret ptr ${ops}`);
+    host.resolveThunkDefs.push(`define internal ptr @${snapshot}_select(ptr %p) ${FN_ATTRS} { ; live record ops by key order`, B.render(), `}`, ``, `@${snapshot}_rops = internal global { ${host.sizeType}, ptr, ptr, ptr, i8, ptr, ptr } { ${host.sizeType} 0, ptr null, ptr null, ptr null, i8 0, ptr null, ptr @${snapshot}_select }`, ``);
 }
 /** Compiled classes whose instance views have no prototype object. Runtime
  * classes and JavaScript classes with prototype data answer through their
@@ -990,12 +1045,112 @@ function liveClassOps(host, snapshot, meta) {
     const className = jsName === "" ? "null" : host.internLiteral(jsName);
     host.resolveThunkDefs.push(`@${names} = internal constant [${members.length} x ptr] [${literals.join(", ")}]`, `@${ops} = internal constant { ptr, ${host.sizeType}, ptr, ptr } { ptr ${exact}, ${host.sizeType} ${members.length}, ptr @${names}, ptr ${className} }`, ``);
 }
+/** The checked-dynamic value a class instance's view holds for `field`, read
+ * from its native slot of `%p`: `boxed` (+1), and the nullable union
+ * `fieldValue` the caller releases when `nullable` is set. */
+function classFieldDynValue(host, B, meta, t, field) {
+    const { index, compressed } = classFieldIndex(meta, field.name, "compressed");
+    const fieldPtr = B.tmp();
+    let fieldValue = B.tmp();
+    B.line(`${fieldPtr} = getelementptr inbounds %${classStructSym(t.className)}, ptr %p, i64 0, i32 ${index}`);
+    if (host.int32Slots.isField(t.className, field.name)) {
+        const raw = B.tmp();
+        B.line(`${raw} = load i32, ptr ${fieldPtr}`);
+        B.line(`${fieldValue} = sitofp i32 ${raw} to double`);
+    }
+    else if (host.inlineUnions.classField(t.className, field.name))
+        fieldValue = loadStructField(B, host.sizeType, fieldPtr, field.type, true);
+    else if (compressed) {
+        const idx = B.tmp();
+        B.line(`${idx} = load i32, ptr ${fieldPtr}`);
+        for (const line of compactRefLoadLines(idx, fieldValue, `${fieldValue}.r`))
+            B.line(line.trimStart());
+    }
+    else
+        B.line(`${fieldValue} = load ${llFieldType(field.type, false)}, ptr ${fieldPtr}`);
+    if (llFieldType(field.type, false) === "i8") {
+        const boolValue = B.tmp();
+        B.line(`${boolValue} = trunc i8 ${fieldValue} to i1`);
+        fieldValue = boolValue;
+    }
+    const nullable = host.nullableFields.get(t.className, field.name);
+    if (nullable)
+        fieldValue = nullableFieldUnion(host, B, fieldValue, nullable);
+    return { boxed: host.streamTypedRefBoxValue(B, field.type, fieldValue), nullable, fieldValue };
+}
+/** The fields an instance's view takes from their native slots, in order:
+ * its own enumerable fields, except an Error's message and name. */
+function classViewFields(meta) {
+    return meta.def.fields.filter((f) => isClassOwnEnumerableFieldName(f.name) &&
+        !(meta.root.def.name === "%Error" && (f.name === "message" || f.name === "name")));
+}
+/** Classes whose instance views the materializer builds from the property
+ * bag and the prototype data alone (see liveBagClassOps): JavaScript classes
+ * tracking their own fields, outside the Error and runtime families, with no
+ * subclass whose view another materializer builds. */
+function liveBagClassOpsEligible(meta) {
+    return (meta.def.tracksOwnFields === true &&
+        (meta.def.prototypeDataHelper !== undefined ||
+            meta.def.instancePrototypeHelper !== undefined) &&
+        !meta.def.runtime &&
+        !meta.root.def.runtime &&
+        meta.root.def.name !== "%Error" &&
+        !(meta.hierarchy && meta.children.length > 0) &&
+        meta.def.fields.some((field) => field.name === DYN_CLASS_PROPERTIES) &&
+        !meta.def.fields.some((field) => field.name === CLASS_ATTRIBUTES ||
+            meta.def.fields.some((f) => f.name === classFieldAttributesName(field.name))));
+}
+/** The hooks of a bag-tracked class instance capsule
+ * (ScrDynTypedBagClassOps). The materializer gives the instance's view
+ * exactly the bag's string-keyed properties, the values of the declared
+ * fields among them from their native slots, and the prototype these hooks
+ * return, so a method call resolves without building the view. */
+function liveBagClassOps(host, snapshot, meta, t) {
+    const struct = classStructSym(t.className);
+    const bag = new BlockBuilder();
+    const slot = bag.tmp(), value = bag.tmp();
+    bag.line(`${slot} = getelementptr inbounds %${struct}, ptr %p, i64 0, i32 ${classFieldIndex(meta, DYN_CLASS_PROPERTIES).index}`);
+    bag.line(`${value} = load ptr, ptr ${slot}`);
+    bag.terminate(`ret ptr ${value}`);
+    const proto = new BlockBuilder();
+    const prototype = proto.tmp();
+    if (meta.def.instancePrototypeHelper) {
+        const receiver = proto.tmp();
+        proto.line(`${receiver} = call ptr ${vAdapters(host.shapeHost, t).retain}(ptr %p)`);
+        proto.line(`${prototype} = call ptr @${mangleFunction(meta.def.instancePrototypeHelper)}(ptr ${receiver})`);
+    }
+    else
+        proto.line(`${prototype} = call ptr @${mangleFunction(meta.def.prototypeDataHelper)}()`);
+    proto.terminate(`ret ptr ${prototype}`);
+    // Field `%i` of the view's field list, as the materializer boxes it.
+    const fields = classViewFields(meta);
+    const get = new BlockBuilder();
+    const cases = fields.map((_, i) => get.newLabel(`field.${i}`));
+    const none = get.newLabel("field.none");
+    get.terminate(`switch ${host.sizeType} %i, label %${none} [ ${cases.map((label, i) => `${host.sizeType} ${i}, label %${label}`).join(" ")} ]`);
+    fields.forEach((field, i) => {
+        get.startBlock(cases[i]);
+        const { boxed, nullable, fieldValue } = classFieldDynValue(host, get, meta, t, field);
+        if (nullable) {
+            host.declare(`declare void @scr_union_release(ptr)`);
+            get.line(`call void @scr_union_release(ptr ${fieldValue})`);
+        }
+        get.terminate(`ret ptr ${boxed}`);
+    });
+    get.startBlock(none);
+    get.terminate(`ret ptr null`);
+    const names = fields.map((field) => `ptr ${host.internLiteral(field.name)}`);
+    host.resolveThunkDefs.push(`define internal ptr @${snapshot}_field(ptr %p, ${host.sizeType} %i) ${FN_ATTRS} { ; view field of ${meta.def.name}`, get.render(), `}`, ``, `@${snapshot}_fnames = internal constant [${names.length} x ptr] ${names.length ? `[${names.join(", ")}]` : "zeroinitializer"}`);
+    host.resolveThunkDefs.push(`define internal ptr @${snapshot}_bag(ptr %p) ${FN_ATTRS} { ; property bag of ${meta.def.name}`, bag.render(), `}`, ``, `define internal ptr @${snapshot}_proto(ptr %p) ${FN_ATTRS} { ; view prototype of ${meta.def.name}`, proto.render(), `}`, ``, `@${snapshot}_bops = internal constant { ptr, ptr, ${host.sizeType}, ptr, ptr } { ptr @${snapshot}_bag, ptr @${snapshot}_proto, ${host.sizeType} ${fields.length}, ptr @${snapshot}_fnames, ptr @${snapshot}_field }`, ``);
+}
 /** The live view a capsule of this adapter binds: the runtime bind call
  * and its ops constant, with the view code a deferred receiver recipe
- * records (1 array, 2 record, 3 class). */
+ * records (1 array, 2 record, 3 class, 4 bag-tracked class). */
 export function liveRefView(adapter) {
     if (adapter.classOps !== undefined)
         return { bind: "scr_dyn_typed_ref_bind_class", ops: adapter.classOps, code: 3 };
+    if (adapter.bagClassOps !== undefined)
+        return { bind: "scr_dyn_typed_ref_bind_bag_class", ops: adapter.bagClassOps, code: 4 };
     if (adapter.recordOps !== undefined)
         return { bind: "scr_dyn_typed_ref_bind_record", ops: adapter.recordOps, code: 2 };
     if (adapter.arrayOps !== undefined)
@@ -1018,6 +1173,7 @@ export function streamFromArrayAdapter(host, t) {
         return existing;
     const sym = `sc_sfa_${host.streamFromArrayAdapters.size}`;
     host.streamFromArrayAdapters.set(key, sym);
+    host.journal?.allocated(sym, "streamFromArrayAdapter", [t]);
     const B = new BlockBuilder();
     const unionDef = elem.kind === "union" ? host.unionsById.get(elem.unionId) : undefined;
     if (elem.kind === "union" && !unionDef) {
@@ -1112,6 +1268,11 @@ export function streamFromArrayAdapter(host, t) {
     }
     B.terminate(`ret ptr ${boxed}`);
     host.resolveThunkDefs.push(`define internal ptr @${sym}(ptr %a, double %i) ${FN_ATTRS} { ; ReadableStream.from array<${key}>`, B.render(), `}`, ``);
+    host.journal?.built();
     return sym;
 }
+registerReplay("dynPromiseAdapter", (host, args) => dynPromiseAdapter(host, args[0]));
+registerReplay("liveDynUnionRefAdapter", (host, args) => liveDynUnionRefAdapter(host, args[0]));
+registerReplay("streamTypedRefMaterializeAdapter", (host, args) => streamTypedRefMaterializeAdapter(host, args[0]).snapshot.replace(/_materialize$/, ""));
+registerReplay("streamFromArrayAdapter", (host, args) => streamFromArrayAdapter(host, args[0]));
 //# sourceMappingURL=expr-stream-bridges.js.map