@scriptc/compiler 0.4.2 → 0.4.4

package/dist/backend/llvm/dyn.js

@@ -1,10 +1,11 @@
+import { emitPerKeyOrder } from "./key-orders.js";
 import { typedRefConstructor } from "./shapes.js";
 import { bindLiveArrayOps } from "./expr-stream-bridges.js";
-import { BYTES_ELEM_NUM, SCR_ARR_FIELD, f64Lit, sizeToDouble } from "./common.js";
+import { BYTES_ELEM_NUM, SCR_ARR_FIELD, SCR_ARR_STATES, f64Lit, sizeToDouble } from "./common.js";
 import { emitUnionPeek, emitUnionTag } from "./union-repr.js";
 import { INLINE_UNION_FIELD, loadInlineUnion, stackUnionBox, storeInlineUnion, unionBoxBits, } from "./inline-unions.js";
 import { InternalCompilerError } from "../../errors.js";
-import { accessorSlotProp, DYN_HANDLE_KINDS, isDirentShape, isDynTypedRefType, isRefCounted, isUnitType, typeKey, } from "../../ir/ir.js";
+import { accessorSlotProp, DYN_HANDLE_KINDS, isDirentShape, KEY_ORDER_FIELD, shapeKeyOrders, isDynTypedRefType, isRefCounted, isUnitType, recordTextCodecClass, textCodecRecordClass, typeKey, } from "../../ir/ir.js";
 import { dynDesc, streamTypedRefEligible } from "../../ir/analysis.js";
 import { mangleRecordNew, mangleRecordStruct } from "../mangle.js";
 import { BlockBuilder } from "./blocks.js";
@@ -39,6 +40,15 @@ export const DYN_HANDLE_TAG_NUM = {
     cryptoHash: 52,
     cryptoHmac: 53,
 };
+/** The handle tags of TextEncoder and TextDecoder records boxed as dyn
+ * (scr_dyn.h; scr_text_codec_dyn.c boxes and unboxes them). */
+export const TEXT_CODEC_TAG_NUM = {
+    TextDecoder: 76,
+    TextEncoder: 77,
+};
+/** The decoder record fields scr_text_decoder_to_dyn reads, in its
+ * parameter order. */
+const TEXT_DECODER_FIELDS = ["%TextDecoder", "%fatal", "%ignoreBOM", "%state"];
 /** Handle kinds whose runtime unit boxes them through its own function,
  * which installs the tag's ops on first use (scr_crypto.h). Programs that
  * never box one of these values do not link its dynamic members. */
@@ -114,6 +124,54 @@ export class LlDyn {
     constructor(host) {
         this.host = host;
     }
+    /** Journal replay (emit-journal.ts): builds or finds the helper a chunk
+     * emitter recorded, and answers its name. */
+    replayHelper(op, args) {
+        switch (op) {
+            case "dyn.collectionDynOps":
+                return this.collectionDynOps(args[0]);
+            case "dyn.dynMatchHelper":
+                return this.dynMatchHelper(args[0], args[1]);
+            case "dyn.jsonSchema":
+                return this.jsonSchema(args[0]);
+            case "dyn.recordNameTable": {
+                const shapeId = args[0];
+                return this.recordNameTable(shapeId, this.host.recordsById.get(shapeId)).names;
+            }
+            case "dyn.jsonParseHelper":
+                return this.jsonParseHelper(args[0]);
+            case "dyn.dynCheckHelper":
+                return this.dynCheckHelper(args[0], args[1]);
+            case "dyn.toDynHelper":
+                return this.toDynHelper(args[0]);
+            case "dyn.promiseDynAdapterHelper":
+                return this.promiseDynAdapterHelper(args[0]);
+            case "dyn.dynFuncThunkHelper":
+                return this.dynFuncThunkHelper(args[0]);
+            case "dyn.dynFuncBoxHelper":
+                return this.dynFuncBoxHelper(args[0]);
+            case "dyn.dynFuncAdapterHelper":
+                return this.dynFuncAdapterHelper(args[0]);
+            case "dyn.dynToStrHelper":
+                return this.dynToStrHelper();
+            case "dyn.dynIterNHelper":
+                return this.dynIterNHelper();
+            case "dyn.dynDestrCheckHelper":
+                return this.dynDestrCheckHelper();
+            case "dyn.dynKeyGetHelper":
+                return this.dynKeyGetHelper();
+            case "dyn.dynComputedKeyGetHelper":
+                return this.dynComputedKeyGetHelper();
+            case "dyn.caughtToDynHelper":
+                return this.caughtToDynHelper();
+            case "dyn.messageListenerHelper":
+                return this.messageListenerHelper(args[0]) ?? "";
+            case "dyn.messageReaderHelper":
+                return this.messageReaderHelper(args[0]);
+            default:
+                throw new InternalCompilerError(`llvm emitter bug: no dyn helper replay ${op}`);
+        }
+    }
     /** The types a dyn matcher or builder for `t` checks structurally: record
      * fields and index values, array elements and union arms. */
     structuralChildren(t) {
@@ -218,6 +276,34 @@ export class LlDyn {
         this.host.declare(`declare void @scr_dyn_build_add(ptr, ptr, ptr)`);
         B.line(`call void @scr_dyn_build_add(ptr %d, ptr @${name}, ptr ${value})`);
     }
+    /** The order a dyn value tries a union's arms in: the canonical order,
+     * except that among the record arms, those with more required fields go
+     * first, then those with more fields. Records are width-tolerant, so an
+     * arm with fewer fields (`{}`, or one whose fields are all optional,
+     * matches every object) would otherwise take an object that a wider arm
+     * also matches and drop the fields only the wider arm has. */
+    unionArmOrder(def) {
+        const width = (i) => {
+            const arm = def.arms[i];
+            if (arm.kind !== "record")
+                return null;
+            const shape = this.host.recordsById.get(arm.shapeId);
+            if (!shape || shape.tuple)
+                return null;
+            const required = shape.fields.filter((field) => field.type.kind !== "union" ||
+                !this.host.unionsById.get(field.type.unionId)?.arms.some((x) => x.kind === "undefinedT")).length;
+            return [required, shape.fields.length];
+        };
+        const order = def.arms.map((_, i) => i);
+        const records = order.filter((i) => width(i) !== null);
+        const widest = [...records].sort((x, y) => {
+            const [rx, fx] = width(x);
+            const [ry, fy] = width(y);
+            return ry - rx || fy - fx || x - y;
+        });
+        records.forEach((slot, k) => (order[slot] = widest[k]));
+        return order;
+    }
     /** Branch to a variant only after its literal discriminator and complete
      * structure match. Use the same path for predicates and builders. */
     unionArmMatch(B, def, tag, yes, no, preserveRefs = false) {
@@ -258,7 +344,7 @@ export class LlDyn {
     }
     /** The value LLVM type of a dynCheck result / toDyn operand for `t`. */
     valTy(t) {
-        return t.kind === "f64" || t.kind === "date" || t.kind === "procStream"
+        return t.kind === "f64" || t.kind === "procStream"
             ? "double"
             : t.kind === "bool"
                 ? "i1"
@@ -271,6 +357,7 @@ export class LlDyn {
             return prior;
         const name = `sc_map_dyn_${this.mapDynOps.size}`;
         this.mapDynOps.set(key, name);
+        this.host.journalAllocated?.(name, "dyn.collectionDynOps", [t]);
         const keyType = t.kind === "map" ? t.key : t.elem;
         const valueType = t.kind === "map" ? t.value : { kind: "f64" };
         const emitSlot = (type, role) => {
@@ -311,6 +398,7 @@ export class LlDyn {
         emitSlot(keyType, "key");
         emitSlot(valueType, "value");
         this.defs.push(`@${name} = internal constant { ptr, ptr, ptr, ptr, ptr, ptr } { ptr ${this.host.cstr(key)}, ptr @${name}_key_box, ptr @${name}_key_unbox, ptr @${this.dynMatchHelper(keyType)}, ptr @${name}_value_box, ptr @${name}_value_unbox }`, "");
+        this.host.journalBuilt?.();
         return name;
     }
     /* ── dyn node plumbing ─────────────────────────────────────────────── */
@@ -651,6 +739,17 @@ export class LlDyn {
             return existing;
         const name = `sc_dm_${this.dynMatchers.size}`;
         this.dynMatchers.set(matcherKey, name);
+        this.host.journalAllocated?.(name, "dyn.dynMatchHelper", [t, preserveRefs]);
+        const codec = textCodecRecordClass(t, (id) => this.host.recordsById.get(id));
+        if (codec !== null) {
+            // A codec matches only its own handle box.
+            const B = new BlockBuilder();
+            const matched = this.handleTagMatches(B, TEXT_CODEC_TAG_NUM[codec]);
+            B.terminate(`ret i1 ${matched}`);
+            this.defs.push(`define internal zeroext i1 @${name}(ptr %d) ${FN_ATTRS} { ; matches ${key}`, B.render(), `}`, ``);
+            this.host.journalBuilt?.();
+            return name;
+        }
         const recursive = this.isRecursiveShape(t);
         const wrapped = recursive || this.holdsRecursiveShape(t);
         const B = new BlockBuilder();
@@ -675,7 +774,10 @@ export class LlDyn {
             const lPlain = B.newLabel("dm.tr.plain");
             B.condBr(capsule, lCapsule, lPlain);
             B.startBlock(lCapsule);
-            if (preserveRefs) {
+            // A class target matches only capsules of that class (tested above):
+            // a materialized view is a plain object, which never carries a class
+            // brand, so materializing one cannot change the answer.
+            if (preserveRefs || (t.kind === "object" && t.className !== "%Error")) {
                 B.terminate(`ret i1 false`);
             }
             else {
@@ -856,9 +958,10 @@ export class LlDyn {
                 }
                 B.condBr(readable, l0, fail);
                 B.startBlock(l0);
-                // dyn ('unknown') fields match ANY value, present or missing.
+                // dyn ('unknown') fields match ANY value, present or missing. The
+                // order index is no key.
                 for (const f of shape.fields) {
-                    if (f.type.kind === "dyn")
+                    if (f.type.kind === "dyn" || f.name === KEY_ORDER_FIELD)
                         continue;
                     const { value: m, release } = this.memberRead(B, f.name, f.type);
                     const lNext = B.newLabel("dm.n");
@@ -986,6 +1089,7 @@ export class LlDyn {
         this.defs.push(`define internal zeroext i1 @${wrapped ? `${name}_body` : name}(ptr %d) ${FN_ATTRS} { ; matches ${key}`, B.render(), `}`, ``);
         if (wrapped)
             this.emitVisitWrapper(name, t, recursive ? "match" : "visit");
+        this.host.journalBuilt?.();
         return name;
     }
     /* ── schema-directed JSON.parse ───────────────────────────────── */
@@ -1022,9 +1126,10 @@ export class LlDyn {
                 if (shape.fields.length > 64 || (shape.fields.length === 0 && !index))
                     return false;
                 visiting.add(t.shapeId);
-                return (shape.fields.every((f) => !f.name.startsWith("%") &&
-                    f.name !== "__proto__" &&
-                    this.jsonSchemaSupported(f.type, visiting, true)) &&
+                return (shape.fields.every((f) => f.name === KEY_ORDER_FIELD ||
+                    (!f.name.startsWith("%") &&
+                        f.name !== "__proto__" &&
+                        this.jsonSchemaSupported(f.type, visiting, true))) &&
                     (!index || this.jsonSchemaSupported(index, visiting)));
             }
             case "union":
@@ -1073,6 +1178,7 @@ export class LlDyn {
         const S = host.sizeType;
         const name = `sc_jsch_${this.jsonSchemas.size}`;
         this.jsonSchemas.set(key, name);
+        this.host.journalAllocated?.(name, "dyn.jsonSchema", [t]);
         let body;
         switch (t.kind) {
             case "f64":
@@ -1097,7 +1203,9 @@ export class LlDyn {
                 const base = host.nullableUnions.fieldBase(t.shapeId);
                 const index = new Map(shape.fields.map((f, i) => [f.name, i + base]));
                 // The runtime names kept-source keys by this index (record-sources.ts).
-                const order = recordSourceFieldOrder(shape);
+                // The order index is no key: parsed values keep the table's order
+                // and their source's own order.
+                const order = recordSourceFieldOrder(shape).filter((name) => name !== KEY_ORDER_FIELD);
                 if (recordMayKeepSource(shape))
                     this.keepsRecordSources = true;
                 const fieldTy = `{ ptr, ${S}, ${S}, ptr }`;
@@ -1130,6 +1238,7 @@ export class LlDyn {
                 throw new InternalCompilerError(`llvm emitter bug: JSON schema of ${t.kind}`);
         }
         this.defs.push(`@${name} = internal constant { ${S}, ${S}, ptr, ptr, ptr, ptr, ptr, ptr, ${S} } { ${body} }`, ``);
+        this.host.journalBuilt?.();
         return name;
     }
     /** The ScrJsonUnion descriptor of a union member (scr_json.h layout):
@@ -1187,6 +1296,16 @@ export class LlDyn {
         this.defs.push(`@${descriptor} = internal constant { ${S}, [7 x ${S}], [7 x ptr], ptr, ptr, ptr } { ${S} ${repr}, [7 x ${S}] [${tags.map((tag) => `${S} ${tag}`).join(", ")}], [7 x ptr] [${arms.join(", ")}], ptr ${nullValue}, ptr ${absentValue}, ptr ${box} }`, ``);
         return descriptor;
     }
+    /** `record.sourceSpread(built, value)`: the built record keeps value's
+     * kept-source order over its own declared names. */
+    emitRecordSourceSpread(B, built, value, shapeId) {
+        const host = this.host;
+        const shape = host.recordsById.get(shapeId);
+        this.keepsRecordSources = true;
+        const names = this.recordNameTable(shapeId, shape);
+        host.declare(`declare void @scr_record_source_spread(ptr, ptr, ptr, ptr, ${host.sizeType})`);
+        B.line(`call void @scr_record_source_spread(ptr ${built}, ptr ${value}, ptr ${names.names}, ptr ${names.lens}, ${host.sizeType} ${shape.fields.length})`);
+    }
     /** The declared-name tables scr_record_source_note scans: parallel
      * constant arrays of field-name bytes and byte lengths in declaration
      * order (the order the record serializes), interned per shape. Internal
@@ -1200,9 +1319,11 @@ export class LlDyn {
         const base = `sc_rnames_${this.recordNameTables.size}`;
         const table = { names: `@${base}`, lens: `@${base}_lens` };
         this.recordNameTables.set(shapeId, table);
+        this.host.journalAllocated?.(base, "dyn.recordNameTable", [shapeId]);
         const n = shape.fields.length;
         const names = recordSourceFieldOrder(shape);
         this.defs.push(`@${base} = internal constant [${n} x ptr] [${names.map((name) => `ptr ${host.cstr(name)}`).join(", ")}]`, `@${base}_lens = internal constant [${n} x ${S}] [${names.map((name) => `${S} ${Buffer.byteLength(name, "utf8")}`).join(", ")}]`, ``);
+        this.host.journalBuilt?.();
         return table;
     }
     /** `sc_jp_<n>(ptr text) -> T` for `JSON.parse(text) as T`, or null when T
@@ -1223,12 +1344,14 @@ export class LlDyn {
         const host = this.host;
         const name = `sc_jp_${this.jsonParsers.size}`;
         this.jsonParsers.set(key, name);
+        this.host.journalAllocated?.(name, "dyn.jsonParseHelper", [t]);
         const schema = this.jsonSchema(t);
         const check = this.dynCheckHelper(t);
         host.declare(`declare ptr @scr_json_parse_schema(ptr, ptr)`);
         host.declare(`declare ptr @scr_json_parse(ptr)`);
         host.declare(`declare void @scr_dyn_release(ptr)`);
         this.defs.push(`define internal ptr @${name}(ptr %text) ${FN_ATTRS} { ; JSON.parse as ${llvmCommentText(key)}`, `entry:`, `  %fast = call ptr @scr_json_parse_schema(ptr %text, ptr @${schema})`, `  %hit = icmp ne ptr %fast, null`, `  br i1 %hit, label %done, label %slow`, `done:`, `  ret ptr %fast`, `slow:`, `  %d = call ptr @scr_json_parse(ptr %text)`, `  %bad = icmp eq ptr %d, null`, `  br i1 %bad, label %fail, label %check`, `fail:`, `  ret ptr null`, `check:`, `  %v = call ptr @${check}(ptr %d, ptr null)`, `  call void @scr_dyn_release(ptr %d)`, `  ret ptr %v`, `}`, ``);
+        this.host.journalBuilt?.();
         return name;
     }
     /* ── dynCheckHelper (walkers.ts, ported) ──────────────────────── */
@@ -1243,6 +1366,7 @@ export class LlDyn {
             return existing;
         const name = `sc_dc_${this.dynBuilders.size}`;
         this.dynBuilders.set(builderKey, name);
+        this.host.journalAllocated?.(name, "dyn.dynCheckHelper", [t, preserveRefs]);
         const recursive = this.isRecursiveShape(t);
         const memo = !recursive && this.holdsRecursiveShape(t) && this.valTy(t) === "ptr";
         const host = this.host;
@@ -1257,6 +1381,18 @@ export class LlDyn {
             B.line(`${checked} = call ptr @scr_dyn_class_check(ptr %d, ptr ${host.cstr(key)}, ptr %path)`);
             B.terminate(`ret ptr ${checked}`);
             this.defs.push(`define internal ptr @${name}(ptr %d, ptr %path) ${FN_ATTRS} {`, B.render(), `}`, ``);
+            this.host.journalBuilt?.();
+            return name;
+        }
+        const codec = textCodecRecordClass(t, (id) => host.recordsById.get(id));
+        if (codec !== null) {
+            // The record the codec's handle box holds (+1), or the path TypeError.
+            host.declare(`declare ptr @scr_text_codec_from_dyn(ptr, i1 zeroext, ptr, ptr)`);
+            const checked = B.tmp();
+            B.line(`${checked} = call ptr @scr_text_codec_from_dyn(ptr %d, i1 ${codec === "TextDecoder"}, ptr %path, ptr ${want})`);
+            B.terminate(`ret ptr ${checked}`);
+            this.defs.push(`define internal ptr @${name}(ptr %d, ptr %path) ${FN_ATTRS} {`, B.render(), `}`, ``);
+            this.host.journalBuilt?.();
             return name;
         }
         if (isRefCounted(t) && t.kind !== "dyn") {
@@ -1416,6 +1552,26 @@ export class LlDyn {
                         B.line(`store ${member.type} ${oldValue}, ptr ${checkedPtr}`);
                     });
                     if (t.kind !== "record") {
+                        // Whether the dense slots carry states (SCR_ARR_STATES in
+                        // `spare`) moves with them; the rest of `spare` stays.
+                        const cachedSpare = B.tmp(), checkedSpare = B.tmp();
+                        const sparePtr = (array) => {
+                            const ptr = B.tmp();
+                            B.line(`${ptr} = getelementptr inbounds %ScrArr, ptr ${array}, i64 0, i32 ${SCR_ARR_FIELD.spare}`);
+                            return ptr;
+                        };
+                        const cachedSparePtr = sparePtr(cached), checkedSparePtr = sparePtr(checked);
+                        B.line(`${cachedSpare} = load i16, ptr ${cachedSparePtr}`);
+                        B.line(`${checkedSpare} = load i16, ptr ${checkedSparePtr}`);
+                        const exchange = (own, other, ptr) => {
+                            const kept = B.tmp(), moved = B.tmp(), next = B.tmp();
+                            B.line(`${kept} = and i16 ${own}, ${~SCR_ARR_STATES}`);
+                            B.line(`${moved} = and i16 ${other}, ${SCR_ARR_STATES}`);
+                            B.line(`${next} = or i16 ${kept}, ${moved}`);
+                            B.line(`store i16 ${next}, ptr ${ptr}`);
+                        };
+                        exchange(cachedSpare, checkedSpare, cachedSparePtr);
+                        exchange(checkedSpare, cachedSpare, checkedSparePtr);
                         // Sparse slots and numeric properties live out of line; each
                         // array keeps its own match metadata.
                         host.declare("declare void @scr_arr_swap_indexed_ext(ptr, ptr)");
@@ -1461,10 +1617,10 @@ export class LlDyn {
         };
         switch (t.kind) {
             case "date": {
-                host.declare(`declare double @scr_dyn_native_date_value(ptr)`);
+                host.declare(`declare ptr @scr_dyn_native_date_check(ptr, ptr)`);
                 const r = B.tmp();
-                B.line(`${r} = call double @scr_dyn_native_date_value(ptr %d)`);
-                B.terminate(`ret double ${r}`);
+                B.line(`${r} = call ptr @scr_dyn_native_date_check(ptr %d, ptr %path)`);
+                B.terminate(`ret ptr ${r}`);
                 break;
             }
             case "url":
@@ -1746,7 +1902,11 @@ export class LlDyn {
                 B.line(`%r0 = call ptr @${mangleRecordNew(t.shapeId)}()`);
                 if (recursive)
                     this.recordBuilt(B, name, "%r0");
+                // The order index stays 0: the source's own order is kept below
+                // when it differs from the table.
                 for (const f of shape.fields) {
+                    if (f.name === KEY_ORDER_FIELD)
+                        continue;
                     const { value: m, release } = this.memberRead(B, f.name, f.type);
                     this.pendingBail(B, "dcr.read", () => {
                         B.line(`call void @${release}(ptr ${m})`);
@@ -1914,9 +2074,10 @@ export class LlDyn {
                 const def = host.unionsById.get(t.unionId);
                 if (!def)
                     throw new InternalCompilerError(`llvm emitter bug: dynCheck of unknown union ${t.unionId}`);
-                // Arms in CANONICAL order, first FULL match wins. The matched
-                // arm's builder can no longer fail.
-                def.arms.forEach((arm, i) => {
+                // Arms in unionArmOrder, first FULL match wins. The matched arm's
+                // builder can no longer fail.
+                for (const i of this.unionArmOrder(def)) {
+                    const arm = def.arms[i];
                     const lHit = B.newLabel("dcu.h");
                     const lNext = B.newLabel("dcu.n");
                     this.unionArmMatch(B, def, i, lHit, lNext, preserveRefs);
@@ -1958,7 +2119,7 @@ export class LlDyn {
                         B.terminate(`ret ptr ${u}`);
                     }
                     B.startBlock(lNext);
-                });
+                }
                 if (preserveRefs) {
                     B.line(`call void @scr_dyn_check_fail(ptr %path, ptr ${host.cstr("reference with its original layout")}, ptr %d)`);
                     B.terminate(`ret ptr null`);
@@ -2157,8 +2318,64 @@ export class LlDyn {
         this.defs.push(`define internal ${retTy === "i1" ? "zeroext i1" : retTy} @${recursive || memo ? `${name}_body` : name}(ptr %d, ptr %path) ${FN_ATTRS} { ; check ${key}`, B.render(), `}`, ``);
         if (recursive || memo)
             this.emitVisitWrapper(name, t, recursive ? "build" : "memo");
+        this.host.journalBuilt?.();
         return name;
     }
+    /** `i1`: %d is a handle box with tag `tag`. */
+    handleTagMatches(B, tag) {
+        const kd = this.kindOf(B, "%d");
+        const isHandle = B.tmp();
+        B.line(`${isHandle} = icmp eq i32 ${kd}, ${DYN_KIND.HANDLE}`);
+        const lHandle = B.newLabel("dm.handle");
+        const lDone = B.newLabel("dm.handle.done");
+        const entry = B.currentLabel();
+        B.condBr(isHandle, lHandle, lDone);
+        B.startBlock(lHandle);
+        const tagPtr = B.tmp();
+        const loaded = B.tmp();
+        B.line(`${tagPtr} = getelementptr inbounds i8, ptr %d, i64 ${this.abiOffset(24, 20)} ; ->v.handle.tag`);
+        B.line(`${loaded} = load i32, ptr ${tagPtr}`);
+        const same = B.tmp();
+        B.line(`${same} = icmp eq i32 ${loaded}, ${tag}`);
+        B.br(lDone);
+        B.startBlock(lDone);
+        const matched = B.tmp();
+        B.line(`${matched} = phi i1 [ false, %${entry} ], [ ${same}, %${lHandle} ]`);
+        return matched;
+    }
+    /** A TextEncoder or TextDecoder record boxes as its handle (+1), which
+     * holds the record by reference. A decoder passes the byte offsets of the
+     * fields its boxed decode reads. */
+    textCodecToDyn(B, t, shape, codec) {
+        const host = this.host;
+        const rc = vAdapters(host, t);
+        const r = B.tmp();
+        if (codec === "TextEncoder") {
+            host.declare(`declare ptr @scr_text_encoder_to_dyn(ptr, ptr, ptr)`);
+            B.line(`${r} = call ptr @scr_text_encoder_to_dyn(ptr %v, ptr ${rc.retain}, ptr ${rc.release})`);
+        }
+        else {
+            const struct = mangleRecordStruct(t.shapeId);
+            const base = host.nullableUnions.fieldBase(t.shapeId);
+            const start = B.tmp();
+            B.line(`${start} = ptrtoint ptr %v to ${this.S}`);
+            const offsets = TEXT_DECODER_FIELDS.map((field) => {
+                const index = shape.fields.findIndex((f) => f.name === field);
+                if (index < 0)
+                    throw new InternalCompilerError(`llvm emitter bug: TextDecoder record lacks ${field}`);
+                const p = B.tmp();
+                const at = B.tmp();
+                const offset = B.tmp();
+                B.line(`${p} = getelementptr inbounds %${struct}, ptr %v, i64 0, i32 ${index + base} ; .${llvmCommentText(field)}`);
+                B.line(`${at} = ptrtoint ptr ${p} to ${this.S}`);
+                B.line(`${offset} = sub ${this.S} ${at}, ${start}`);
+                return `${this.S} ${offset}`;
+            });
+            host.declare(`declare ptr @scr_text_decoder_to_dyn(ptr, ptr, ptr, ${this.S}, ${this.S}, ${this.S}, ${this.S})`);
+            B.line(`${r} = call ptr @scr_text_decoder_to_dyn(ptr %v, ptr ${rc.retain}, ptr ${rc.release}, ${offsets.join(", ")})`);
+        }
+        B.terminate(`ret ptr ${r}`);
+    }
     /* ── toDynHelper (walkers.ts, ported) ─────────────────────────── */
     /** `sc_td_<n>(<T> v) -> ptr` — build a fresh dyn value from a
      * static one (+1), DEEP-COPYING composites. Borrows the operand.
@@ -2170,16 +2387,16 @@ export class LlDyn {
             return existing;
         const name = `sc_td_${this.toDynFns.size}`;
         this.toDynFns.set(key, name);
+        this.host.journalAllocated?.(name, "dyn.toDynHelper", [t]);
         const host = this.host;
         const B = new BlockBuilder();
         let sourceAccessor = null;
         switch (t.kind) {
             case "date": {
-                // A Date handle holding the same time value; native Dates are
-                // immutable values, and so is the handle.
-                host.declare(`declare ptr @scr_dyn_native_date_from_ms(double)`);
+                // A Date handle holding the same Date object.
+                host.declare(`declare ptr @scr_dyn_native_date(ptr)`);
                 const r = B.tmp();
-                B.line(`${r} = call ptr @scr_dyn_native_date_from_ms(double %v)`);
+                B.line(`${r} = call ptr @scr_dyn_native_date(ptr %v)`);
                 B.terminate(`ret ptr ${r}`);
                 break;
             }
@@ -2319,6 +2536,11 @@ export class LlDyn {
                 const shape = host.recordsById.get(t.shapeId);
                 if (!shape)
                     throw new InternalCompilerError(`llvm emitter bug: to-dyn of unknown shape ${t.shapeId}`);
+                const codec = recordTextCodecClass(shape);
+                if (codec !== null) {
+                    this.textCodecToDyn(B, t, shape, codec);
+                    break;
+                }
                 const struct = mangleRecordStruct(t.shapeId);
                 const base = host.nullableUnions.fieldBase(t.shapeId);
                 const fieldIndex = new Map(shape.fields.map((f, i) => [f.name, i + base]));
@@ -2401,58 +2623,68 @@ export class LlDyn {
                     host.declare(`declare ptr @scr_dyn_new_obj()`);
                     B.line(`${d} = call ptr @scr_dyn_new_obj()`);
                 }
-                // Keys insert in DECLARED order (JS insertion order); internal
-                // '%'-fields follow so a record→dyn→record round trip keeps them.
+                // Keys insert in DECLARED order (JS insertion order), or in the
+                // value's own order for a shape with orderVariants; internal
+                // '%'-fields follow so a record→dyn→record round trip keeps them
+                // (all but the order index, which is no key).
                 const byName = new Map(shape.fields.map((f) => [f.name, f]));
                 // An accessor property is one key whose getter and setter are the
                 // slot closures (see accessorSlotProp), in accessorOrder's place.
-                const order = shape.accessorOrder ?? shape.declaredOrder ?? shape.fields.map((f) => f.name);
-                const inOrder = new Set(order);
-                const accessors = new Set(shape.accessorOrder === undefined
-                    ? []
-                    : shape.fields.flatMap((f) => {
-                        const slot = accessorSlotProp(f.name);
-                        return slot === null ? [] : [slot.prop];
-                    }));
-                const dynFields = [
-                    ...order.flatMap((n) => {
-                        if (accessors.has(n))
-                            return [{ accessor: n }];
-                        const f = byName.get(n);
-                        return f === undefined ? [] : [f];
-                    }),
-                    ...shape.fields.filter((f) => !inOrder.has(f.name) && !(accessors.size > 0 && accessorSlotProp(f.name) !== null)),
-                ];
-                for (const entry of dynFields) {
-                    if ("accessor" in entry) {
-                        host.declare(`declare void @scr_dyn_obj_set_accessor(ptr, ptr, ${host.sizeType}, ptr, ptr)`);
-                        const boxed = (kind) => {
-                            const slot = byName.get(`%${kind}:${entry.accessor}`);
-                            if (slot === undefined)
-                                return "null";
-                            const fv = loadFieldOf(slot.name, slot.type);
-                            const conv = B.tmp();
-                            B.line(`${conv} = call ptr @${this.toDynHelper(slot.type)}(${this.valTy(slot.type)} ${fv})`);
-                            return conv;
-                        };
-                        const getter = boxed("get");
-                        const setter = boxed("set");
-                        B.line(`call void @scr_dyn_obj_set_accessor(ptr ${d}, ptr ${host.cstr(entry.accessor)}, ${host.sizeType} ${Buffer.byteLength(entry.accessor, "utf8")}, ptr ${getter}, ptr ${setter}) ; ${llvmCommentText(entry.accessor)}`);
-                        continue;
-                    }
-                    const f = entry;
-                    const klen = Buffer.byteLength(f.name, "utf8");
-                    const fv = loadFieldOf(f.name, f.type);
-                    // An ABSENT optional field contributes no key.
-                    const lSkip = f.type.kind === "union" ? this.skipIfAbsent(B, fv, f.type) : null;
-                    const conv = B.tmp();
-                    B.line(`${conv} = call ptr @${this.toDynHelper(f.type)}(${this.valTy(f.type)} ${fv})`);
-                    B.line(`call void @scr_dyn_obj_set(ptr ${d}, ptr ${host.cstr(f.name)}, ${host.sizeType} ${klen}, ptr ${conv}) ; ${llvmCommentText(f.name)}`);
-                    if (lSkip !== null) {
-                        B.br(lSkip);
-                        B.startBlock(lSkip);
+                const orders = shape.accessorOrder !== undefined ? [shape.accessorOrder] : shapeKeyOrders(shape);
+                const perOrder = (order) => {
+                    const inOrder = new Set(order);
+                    const accessors = new Set(shape.accessorOrder === undefined
+                        ? []
+                        : shape.fields.flatMap((f) => {
+                            const slot = accessorSlotProp(f.name);
+                            return slot === null ? [] : [slot.prop];
+                        }));
+                    const dynFields = [
+                        ...order.flatMap((n) => {
+                            if (accessors.has(n))
+                                return [{ accessor: n }];
+                            const f = byName.get(n);
+                            return f === undefined ? [] : [f];
+                        }),
+                        ...shape.fields.filter((f) => !inOrder.has(f.name) &&
+                            f.name !== KEY_ORDER_FIELD &&
+                            !(accessors.size > 0 && accessorSlotProp(f.name) !== null)),
+                    ];
+                    for (const entry of dynFields) {
+                        if ("accessor" in entry) {
+                            host.declare(`declare void @scr_dyn_obj_set_accessor(ptr, ptr, ${host.sizeType}, ptr, ptr)`);
+                            const boxed = (kind) => {
+                                const slot = byName.get(`%${kind}:${entry.accessor}`);
+                                if (slot === undefined)
+                                    return "null";
+                                const fv = loadFieldOf(slot.name, slot.type);
+                                const conv = B.tmp();
+                                B.line(`${conv} = call ptr @${this.toDynHelper(slot.type)}(${this.valTy(slot.type)} ${fv})`);
+                                return conv;
+                            };
+                            const getter = boxed("get");
+                            const setter = boxed("set");
+                            B.line(`call void @scr_dyn_obj_set_accessor(ptr ${d}, ptr ${host.cstr(entry.accessor)}, ${host.sizeType} ${Buffer.byteLength(entry.accessor, "utf8")}, ptr ${getter}, ptr ${setter}) ; ${llvmCommentText(entry.accessor)}`);
+                            continue;
+                        }
+                        const f = entry;
+                        const klen = Buffer.byteLength(f.name, "utf8");
+                        const fv = loadFieldOf(f.name, f.type);
+                        // An ABSENT optional field contributes no key.
+                        const lSkip = f.type.kind === "union" ? this.skipIfAbsent(B, fv, f.type) : null;
+                        const conv = B.tmp();
+                        B.line(`${conv} = call ptr @${this.toDynHelper(f.type)}(${this.valTy(f.type)} ${fv})`);
+                        B.line(`call void @scr_dyn_obj_set(ptr ${d}, ptr ${host.cstr(f.name)}, ${host.sizeType} ${klen}, ptr ${conv}) ; ${llvmCommentText(f.name)}`);
+                        if (lSkip !== null) {
+                            B.br(lSkip);
+                            B.startBlock(lSkip);
+                        }
                     }
-                }
+                };
+                if (orders.length === 1)
+                    perOrder(orders[0]);
+                else
+                    emitPerKeyOrder(B, shape, base, "%v", perOrder);
                 // A Dirent row takes Node's Dirent prototype (the type probes) and
                 // its Symbol(type) key; %dtype stays readable but non-enumerable.
                 if (isDirentShape(shape)) {
@@ -2724,6 +2956,7 @@ export class LlDyn {
         if (sourceAccessor) {
             this.defs.push(`define internal ptr @${sourceAccessor.name}(ptr %v, i1 %materialize) ${FN_ATTRS} { ; record source ${key}`, `entry:`, `  br i1 %materialize, label %snapshot, label %release`, `snapshot:`, `  %d = call ptr @${name}(ptr %v)`, `  ret ptr %d`, `release:`, `  call void ${sourceAccessor.release}(ptr %v)`, `  ret ptr null`, `}`, ``);
         }
+        this.host.journalBuilt?.();
         return name;
     }
     /** The checked-dynamic tree-promise settle adapter for one fulfillment payload type —
@@ -2740,6 +2973,7 @@ export class LlDyn {
             return existing;
         const name = `sc_pda_${this.promiseDynAdapters.size}`;
         this.promiseDynAdapters.set(key, name);
+        this.host.journalAllocated?.(name, "dyn.promiseDynAdapterHelper", [inner]);
         const host = this.host;
         const B = new BlockBuilder();
         host.declare(`declare void @scr_promise_fulfill_ref(ptr, ptr, ptr, ptr, ptr)`);
@@ -2811,6 +3045,7 @@ export class LlDyn {
         }
         B.terminate(`ret void`);
         this.defs.push(`define internal void @${name}(ptr %dst, ptr %src) ${FN_ATTRS} { ; dyn-box settle adapter for promise<${key}>`, B.render(), `}`, ``);
+        this.host.journalBuilt?.();
         return name;
     }
     /* ── the dyn ToString pair (dynToStrHelper, ported) ────────────────── */
@@ -2822,6 +3057,7 @@ export class LlDyn {
             return this.dynToStrFn;
         const name = "sc_ds";
         this.dynToStrFn = name;
+        this.host.journalAllocated?.(name, "dyn.dynToStrHelper", []);
         const host = this.host;
         host.declare(`declare void @scr_jb_init(ptr)`);
         host.declare(`declare ptr @scr_jb_finish(ptr)`);
@@ -3112,6 +3348,7 @@ export class LlDyn {
             B.terminate(`ret ptr ${out}`);
             this.defs.push(`define internal ptr @${name}(ptr %d) ${FN_ATTRS} { ; String(unknown) -> owned (+1)`, B.render(), `}`, ``);
         }
+        this.host.journalBuilt?.();
         return name;
     }
     /* ── caughtToDyn (walkers.ts, ported) ─────────────────────────── */
@@ -3122,6 +3359,7 @@ export class LlDyn {
             return this.caughtToDynFn;
         const name = "sc_cd";
         this.caughtToDynFn = name;
+        this.host.journalAllocated?.(name, "dyn.caughtToDynHelper", []);
         const host = this.host;
         const B = new BlockBuilder();
         const kp = B.tmp();
@@ -3220,6 +3458,7 @@ export class LlDyn {
             B.terminate(`ret ptr ${e}`);
         }
         this.defs.push(`define internal ptr @${name}(ptr %c) ${FN_ATTRS} { ; caught -> unknown (+1, fresh tree)`, B.render(), `}`, ``);
+        this.host.journalBuilt?.();
         return name;
     }
     /* ── the keyed read (dynKeyGetHelper, ported) ──────────────────────── */
@@ -3232,6 +3471,7 @@ export class LlDyn {
         this.helperMemo.set(name, name);
         const B = new BlockBuilder();
         const host = this.host;
+        this.host.journalAllocated?.(name, "dyn.dynComputedKeyGetHelper", []);
         const stringHelper = this.dynKeyGetHelper();
         host.declare(`declare ptr @scr_dyn_property_key_value(ptr)`);
         host.declare(`declare ptr @scr_dyn_symbol_key_get(ptr, ptr, i1 zeroext)`);
@@ -3264,6 +3504,7 @@ export class LlDyn {
         B.line(`call void @scr_dyn_release(ptr ${key})`);
         B.terminate(`ret ptr ${value}`);
         this.defs.push(`define internal ptr @${name}(ptr %d, ptr %key, i1 zeroext %opt) ${FN_ATTRS} {`, B.render(), "}", "");
+        this.host.journalBuilt?.();
         return name;
     }
     dynKeyGetHelper() {
@@ -3273,6 +3514,7 @@ export class LlDyn {
             return existing;
         const name = "sc_dyn_key_get";
         this.dynBuilders.set(memoKey, name);
+        this.host.journalAllocated?.(name, "dyn.dynKeyGetHelper", []);
         const host = this.host;
         const B = new BlockBuilder();
         const kd = this.kindOf(B, "%d");
@@ -3651,6 +3893,7 @@ export class LlDyn {
         }
         retainUndef();
         this.defs.push(`define internal ptr @${name}(ptr %d, ptr %k, i1 zeroext %opt) ${FN_ATTRS} { ; d[k] on dyn`, B.render(), `}`, ``);
+        this.host.journalBuilt?.();
         return name;
     }
     /* ── destructuring RequireObjectCoercible (ported) ─────────────────── */
@@ -3661,6 +3904,7 @@ export class LlDyn {
             return existing;
         const name = "sc_dyn_destr_check";
         this.dynBuilders.set(memoKey, name);
+        this.host.journalAllocated?.(name, "dyn.dynDestrCheckHelper", []);
         const host = this.host;
         host.declare(`declare void @scr_jb_init(ptr)`);
         host.declare(`declare ptr @scr_jb_finish(ptr)`);
@@ -3710,6 +3954,7 @@ export class LlDyn {
         B.line(`call void @scr_throw_error(i32 1, ptr ${msg}) ; SCR_ERR_TYPE`);
         B.terminate(`ret void`);
         this.defs.push(`define internal void @${name}(ptr %d, ptr %spell, ptr %firstProp) ${FN_ATTRS} { ; destructuring RequireObjectCoercible`, B.render(), `}`, ``);
+        this.host.journalBuilt?.();
         return name;
     }
     /* ── GetIterator + first-N steps (dynIterNHelper, ported) ──────────── */
@@ -3720,6 +3965,7 @@ export class LlDyn {
             return existing;
         const name = "sc_dyn_iter_n";
         this.dynBuilders.set(memoKey, name);
+        this.host.journalAllocated?.(name, "dyn.dynIterNHelper", []);
         const host = this.host;
         host.declare(`declare ptr @scr_dyn_new_arr()`);
         host.declare(`declare void @scr_dyn_arr_push(ptr, ptr)`);
@@ -3914,12 +4160,38 @@ export class LlDyn {
         });
         B.terminate(`ret ptr ${out}`);
         this.defs.push(`define internal ptr @${name}(ptr %d, ${host.sizeType} %n, ptr %spelling) ${FN_ATTRS} { ; destructuring GetIterator + N steps`, B.render(), `}`, ``);
+        this.host.journalBuilt?.();
         return name;
     }
     /* ── the checked-dynamic function boundary (ported) ────────────────── */
     /** The dyn argument spelling of one static value: dyn passes through
      * (+1), funcs box anonymously, everything else rides toDyn. `expr` is
      * BORROWED in every arm. Emits into the given builder. */
+    /** A live capsule of a record or array value (+1; the value is
+     * borrowed), as `dynFrom` with `liveRef` builds it; null for other
+     * types. Closures boxed in a declaration-typed boundary program return
+     * their records and arrays this way. */
+    liveToDyn(B, t, expr) {
+        const host = this.host;
+        if (t.kind === "union") {
+            const arms = host.unionsById.get(t.unionId)?.arms ?? [];
+            if (!arms.some((arm) => arm.kind === "record" || arm.kind === "array"))
+                return null;
+            const boxed = B.tmp();
+            B.line(`${boxed} = call ptr @${host.liveDynUnionRefAdapter(t)}(ptr ${expr})`);
+            return boxed;
+        }
+        if ((t.kind !== "record" && t.kind !== "array") || !streamTypedRefEligible(t))
+            return null;
+        const key = typeKey(t);
+        const adapter = host.liveDynRefAdapter(t);
+        const rc = vAdapters(host, t);
+        const boxed = B.tmp();
+        B.line(`${boxed} = call ptr ${typedRefConstructor(host, t)}(ptr ${expr}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${host.cstr(key)}, ${host.sizeType} ${Buffer.byteLength(key, "utf8")}, ptr @${adapter.snapshot}, ptr ${adapter.commit})`);
+        for (const line of bindLiveArrayOps(host, adapter, boxed))
+            B.line(line);
+        return boxed;
+    }
     toDynExpr(B, t, expr) {
         if (t.kind === "dyn")
             return this.retainDyn(B, expr);
@@ -3943,6 +4215,7 @@ export class LlDyn {
             return existing;
         const name = `sc_dfk_${this.dynFuncThunks.size}`;
         this.dynFuncThunks.set(key, name);
+        this.host.journalAllocated?.(name, "dyn.dynFuncThunkHelper", [t]);
         const host = this.host;
         const B = new BlockBuilder();
         const argNames = [];
@@ -4041,6 +4314,22 @@ export class LlDyn {
                             B.line(`call void ${releaseSym(host, q)}(ptr ${argNames[j]})`);
                     });
                 }, "ptr null");
+                // Declaration-typed boundary programs: an argument package code
+                // passes keeps its identity (scr_dyn_decl_adopt).
+                const capsule = this.host.declBoundary?.() === true ? this.liveToDyn(B, p, a) : null;
+                if (capsule !== null) {
+                    host.declare(`declare void @scr_dyn_decl_adopt(ptr, ptr)`);
+                    host.declare(`declare void @scr_dyn_release(ptr)`);
+                    B.line(`call void @scr_dyn_decl_adopt(ptr ${ad}, ptr ${capsule})`);
+                    B.line(`call void @scr_dyn_release(ptr ${capsule})`);
+                    this.pendingBail(B, "dfk.adopt", () => {
+                        t.params.slice(0, i + 1).forEach((q, j) => {
+                            const name = j === i ? a : argNames[j];
+                            if (isRefCounted(q))
+                                B.line(`call void ${releaseSym(host, q)}(ptr ${name})`);
+                        });
+                    }, "ptr null");
+                }
                 argNames.push(a);
             }
         });
@@ -4075,12 +4364,15 @@ export class LlDyn {
             const r = B.tmp();
             B.line(`${r} = call ${retTy} ${fn}(${callArgs})`);
             this.pendingBail(B, "dfkr", () => { }, "ptr null");
-            const out = this.toDynExpr(B, t.ret, r);
+            const out = this.host.declBoundary?.() === true
+                ? (this.liveToDyn(B, t.ret, r) ?? this.toDynExpr(B, t.ret, r))
+                : this.toDynExpr(B, t.ret, r);
             if (isRefCounted(t.ret))
                 B.line(`call void ${releaseSym(host, t.ret)}(ptr ${r})`);
             B.terminate(`ret ptr ${out}`);
         }
         this.defs.push(`define internal ptr @${name}(ptr %c, ptr %args, ${host.sizeType} %argc) ${FN_ATTRS} { ; dyn call thunk for ${key}`, B.render(), `}`, ``);
+        this.host.journalBuilt?.();
         return name;
     }
     /** The box builder dynFrom emits for one closure signature. */
@@ -4091,12 +4383,14 @@ export class LlDyn {
             return existing;
         const name = `sc_dfb_${this.dynFuncBoxes.size}`;
         this.dynFuncBoxes.set(key, name);
+        this.host.journalAllocated?.(name, "dyn.dynFuncBoxHelper", [t]);
         const host = this.host;
         const thunk = this.dynFuncThunkHelper(t);
         host.declare(`declare ptr @scr_closure_retain_v(ptr)`);
         host.declare(`declare ptr @scr_dyn_new_func(ptr, ptr, i32, ptr, ptr)`);
         const sigLit = host.cstr(key);
         this.defs.push(`define internal ptr @${name}(ptr %v, ptr %fname) ${FN_ATTRS} { ; box ${key} into dyn`, `entry:`, `  %c = call ptr @scr_closure_retain_v(ptr %v)`, `  %r = call ptr @scr_dyn_new_func(ptr %c, ptr @${thunk}, i32 ${t.params.length - (t.restAbi === "typed" ? 1 : 0)}, ptr ${sigLit}, ptr %fname)`, `  ret ptr %r`, `}`, ``);
+        this.host.journalBuilt?.();
         return name;
     }
     /** `sc_dml_<n>(ptr c, ptr message) -> i1`, the typed message entry of a
@@ -4118,11 +4412,15 @@ export class LlDyn {
             (t.ret.kind === "void" || t.ret.kind === "f64" || t.ret.kind === "bool") &&
             this.messageReadable(param, new Set());
         if (!supported) {
+            // A signature without an entry still takes a number.
             this.messageListeners.set(key, null);
+            this.host.journalAllocated?.("", "dyn.messageListenerHelper", [t]);
+            this.host.journalBuilt?.();
             return null;
         }
         const name = `sc_dml_${this.messageListeners.size}`;
         this.messageListeners.set(key, name);
+        this.host.journalAllocated?.(name, "dyn.messageListenerHelper", [t]);
         const B = new BlockBuilder();
         B.entryAllocas.push(`%fail = alloca i1`);
         B.line(`store i1 false, ptr %fail`);
@@ -4149,6 +4447,7 @@ export class LlDyn {
             B.line(`${B.tmp()} = call ${this.valTy(t.ret)} ${fn}(${args})`);
         B.terminate(`ret i1 true`);
         this.defs.push(`define internal zeroext i1 @${name}(ptr %c, ptr %m) ${FN_ATTRS} { ; message entry for ${llvmCommentText(key)}`, B.render(), `}`, ``);
+        this.host.journalBuilt?.();
         return name;
     }
     /** Whether a message reader can build T: numbers, booleans and strings;
@@ -4212,6 +4511,7 @@ export class LlDyn {
             return existing;
         const name = `sc_dmr_${this.messageReaders.size}`;
         this.messageReaders.set(key, name);
+        this.host.journalAllocated?.(name, "dyn.messageReaderHelper", [t]);
         const host = this.host;
         const S = host.sizeType;
         if (t.kind !== "record")
@@ -4370,6 +4670,7 @@ export class LlDyn {
         B.line(`store i1 true, ptr %fail`);
         B.terminate(`ret ${retTy} ${dummy}`);
         this.defs.push(`define internal ${retTy === "i1" ? "zeroext i1" : retTy} @${name}(ptr %m, ${S} %n, ptr %fail) ${FN_ATTRS} { ; message reader for ${llvmCommentText(key)}`, B.render(), `}`, ``);
+        this.host.journalBuilt?.();
         return name;
     }
     /** The adapter closure body for one TARGET signature: caps[0] is an
@@ -4381,6 +4682,7 @@ export class LlDyn {
             return existing;
         const name = `sc_dfa_${this.dynFuncAdapters.size}`;
         this.dynFuncAdapters.set(key, name);
+        this.host.journalAllocated?.(name, "dyn.dynFuncAdapterHelper", [t]);
         const host = this.host;
         const B = new BlockBuilder();
         host.declare(`declare ptr @scr_box_get_ref(ptr)`);
@@ -4475,6 +4777,7 @@ export class LlDyn {
             ...(checkedRest ? ["ptr %rest"] : []),
         ].join(", ");
         this.defs.push(`define internal ${retTy === "i1" ? "zeroext i1" : retTy} @${name}(${params}) ${FN_ATTRS} { ; dyn fn adapter to ${key}`, B.render(), `}`, ``);
+        this.host.journalBuilt?.();
         return name;
     }
 }