@scriptc/compiler 0.4.1 → 0.4.3

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. */
@@ -54,6 +64,14 @@ const DYN_HANDLE_BOX_FN = {
 const DYN_HANDLE_UNBOX_FN = {
     dgramSocket: "scr_dgram_from_dyn",
 };
+/** ScrMessageKind (scr_message.h): the node kinds message readers test. */
+const MESSAGE_KIND = {
+    UNDEFINED: 0,
+    NULL: 1,
+    BOOL: 2,
+    NUMBER: 3,
+    STRING: 4,
+};
 export const DYN_KIND = {
     NULL: 0,
     BOOL: 1,
@@ -92,6 +110,8 @@ export class LlDyn {
     dynFuncThunks = new Map();
     dynFuncBoxes = new Map();
     dynFuncAdapters = new Map();
+    messageListeners = new Map();
+    messageReaders = new Map();
     promiseDynAdapters = new Map();
     mapDynOps = new Map();
     dynToStrFn = null;
@@ -104,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) {
@@ -208,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) {
@@ -261,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) => {
@@ -301,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 ─────────────────────────────────────────────── */
@@ -641,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();
@@ -846,9 +955,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");
@@ -976,6 +1086,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 ───────────────────────────────── */
@@ -1012,9 +1123,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":
@@ -1063,6 +1175,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":
@@ -1087,7 +1200,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 }`;
@@ -1120,6 +1235,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):
@@ -1190,9 +1306,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
@@ -1213,12 +1331,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) ──────────────────────── */
@@ -1233,6 +1353,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;
@@ -1247,6 +1368,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") {
@@ -1406,6 +1539,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)");
@@ -1736,7 +1889,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})`);
@@ -1904,9 +2061,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);
@@ -1948,7 +2106,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`);
@@ -2147,8 +2305,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.
@@ -2160,6 +2374,7 @@ 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;
@@ -2309,6 +2524,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]));
@@ -2391,58 +2611,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)) {
@@ -2714,6 +2944,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 —
@@ -2730,6 +2961,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)`);
@@ -2801,16 +3033,19 @@ 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) ────────────────── */
     /** Node's String() over a dyn value — sc_ds (+1 result) over the
-     * recursive sc_ds_buf walker. Borrowed operand; never throws. */
+     * recursive sc_ds_buf walker. Borrowed operand; an exception that an
+     * object's toString or valueOf throws stays pending. */
     dynToStrHelper() {
         if (this.dynToStrFn)
             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)`);
@@ -2909,9 +3144,9 @@ export class LlDyn {
             B.startBlock(labels.get(DYN_KIND.ARR));
             {
                 // Array.prototype.toString: join(",") — null/undefined ELEMENTS
-                // print empty (unlike top level), nested arrays flatten.
+                // print empty (unlike top level), nested arrays flatten. The length
+                // is read once, as join reads it.
                 const n = this.lenOf(B, "%d");
-                const items = this.itemsOf(B, "%d");
                 this.i64Loop(B, "ds.ar", n, (i, brNext) => {
                     const nz = B.tmp();
                     B.line(`${nz} = icmp ugt ${this.S} ${i}, 0`);
@@ -2922,7 +3157,22 @@ export class LlDyn {
                     B.line(`call void @scr_jb_putc(ptr %b, i8 44)`);
                     B.br(lel);
                     B.startBlock(lel);
-                    const e = this.itemAt(B, items, i);
+                    // Each index reads the element as join does (scr_dyn_arr_at, +1):
+                    // from the current storage, undefined past the current length,
+                    // and through the prototype for a hole. An element's toString
+                    // can append to, shrink or reallocate the array; a getter that
+                    // throws answers NULL with the exception pending.
+                    host.declare(`declare ptr @scr_dyn_arr_at(ptr, double)`);
+                    host.declare(`declare void @scr_dyn_release_v(ptr)`);
+                    const index = B.tmp();
+                    B.line(`${index} = uitofp ${this.S} ${i} to double`);
+                    const e = B.tmp();
+                    B.line(`${e} = call ptr @scr_dyn_arr_at(ptr %d, double ${index})`);
+                    const missing = B.tmp();
+                    B.line(`${missing} = icmp eq ptr ${e}, null`);
+                    const lGot = B.newLabel("ds.gt");
+                    B.condBr(missing, done, lGot);
+                    B.startBlock(lGot);
                     const ek = this.kindOf(B, e);
                     const isU = B.tmp();
                     const isN = B.tmp();
@@ -2930,20 +3180,31 @@ export class LlDyn {
                     B.line(`${isU} = icmp eq i32 ${ek}, ${DYN_KIND.UNDEF}`);
                     B.line(`${isN} = icmp eq i32 ${ek}, ${DYN_KIND.NULL}`);
                     B.line(`${unit} = or i1 ${isU}, ${isN}`);
-                    const lSkip = B.newLabel("ds.sk");
                     const lRec = B.newLabel("ds.rc");
+                    const lSkip = B.newLabel("ds.sk");
                     B.condBr(unit, lSkip, lRec);
                     B.startBlock(lSkip);
+                    B.line(`call void @scr_dyn_release_v(ptr ${e})`);
                     brNext();
                     B.startBlock(lRec);
                     B.line(`call void @sc_ds_buf(ptr %b, ptr ${e})`);
+                    B.line(`call void @scr_dyn_release_v(ptr ${e})`);
+                    // The first exception an element's conversion throws ends the
+                    // conversion; later elements are not read.
+                    const thrown = B.tmp();
+                    for (const line of host.pendingTestLines(thrown))
+                        B.line(line.trimStart());
+                    const lMore = B.newLabel("ds.mo");
+                    B.condBr(thrown, done, lMore);
+                    B.startBlock(lMore);
                 });
                 B.br(done);
             }
             B.startBlock(labels.get(DYN_KIND.OBJ));
             {
                 // The checked-dynamic tree's error encoding renders Error.prototype.toString;
-                // plain objects are "[object Object]".
+                // other objects convert with ToPrimitive's string hint: a toString or
+                // valueOf of their own or of their prototypes, else "[object Object]".
                 const marker = this.objGetLit(B, "%d", "%error");
                 const isErr = B.tmp();
                 B.line(`${isErr} = icmp ne ptr ${marker}, null`);
@@ -2951,8 +3212,21 @@ export class LlDyn {
                 const lPlain = B.newLabel("ds.pl");
                 B.condBr(isErr, lErr, lPlain);
                 B.startBlock(lPlain);
-                this.puts(B, "%b", "[object Object]");
-                B.br(done);
+                {
+                    // Null leaves the exception the conversion threw pending.
+                    host.declare(`declare ptr @scr_dyn_string_coerce_js(ptr)`);
+                    host.declare(`declare void @scr_str_release(ptr)`);
+                    const text = B.tmp();
+                    B.line(`${text} = call ptr @scr_dyn_string_coerce_js(ptr %d)`);
+                    const converted = B.tmp();
+                    B.line(`${converted} = icmp ne ptr ${text}, null`);
+                    const lPut = B.newLabel("ds.pp");
+                    B.condBr(converted, lPut, done);
+                    B.startBlock(lPut);
+                    this.putScrStr(B, "%b", text);
+                    B.line(`call void @scr_str_release(ptr ${text})`);
+                    B.br(done);
+                }
                 B.startBlock(lErr);
                 // Error.prototype.toString, reading name and message through the
                 // prototype. Null leaves the exception its conversion threw pending.
@@ -3062,6 +3336,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) ─────────────────────────── */
@@ -3072,6 +3347,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();
@@ -3170,6 +3446,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) ──────────────────────── */
@@ -3182,6 +3459,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)`);
@@ -3214,6 +3492,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() {
@@ -3223,6 +3502,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");
@@ -3601,6 +3881,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) ─────────────────── */
@@ -3611,6 +3892,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)`);
@@ -3660,6 +3942,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) ──────────── */
@@ -3670,6 +3953,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)`);
@@ -3864,12 +4148,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);
@@ -3893,6 +4203,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 = [];
@@ -3991,6 +4302,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);
             }
         });
@@ -4025,12 +4352,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. */
@@ -4041,12 +4371,294 @@ 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
+     * closure registered as a 'message' listener (ScrDynMessageListener):
+     * builds the closure's parameter from the message's nodes and calls the
+     * closure. It answers false, without calling it, when the message does
+     * not have the parameter's exact layout, and the listener then runs
+     * through its thunk on the decoded message, as before. Null when the
+     * signature's parameter has no message reader (messageReadable). */
+    messageListenerHelper(t) {
+        const key = typeKey(t);
+        const existing = this.messageListeners.get(key);
+        if (existing !== undefined)
+            return existing;
+        const param = t.params[0];
+        const supported = t.params.length === 1 &&
+            t.rest !== true &&
+            param !== undefined &&
+            (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`);
+        const value = B.tmp();
+        B.line(`${value} = call ${this.valTy(param)} @${this.messageReaderHelper(param)}(ptr %m, ${this.host.sizeType} 0, ptr %fail)`);
+        const failed = B.tmp();
+        B.line(`${failed} = load i1, ptr %fail`);
+        const lMiss = B.newLabel("dml.miss");
+        const lCall = B.newLabel("dml.call");
+        B.condBr(failed, lMiss, lCall);
+        B.startBlock(lMiss);
+        B.terminate(`ret i1 false`);
+        B.startBlock(lCall);
+        // The closure consumes its parameter; a pending exception stays for
+        // the emitter, as after the thunk.
+        const fnp = B.tmp();
+        const fn = B.tmp();
+        B.line(`${fnp} = getelementptr inbounds %ScrClosure, ptr %c, i64 0, i32 1`);
+        B.line(`${fn} = load ptr, ptr ${fnp}`);
+        const args = `ptr %c, ${this.valTy(param)} ${value}`;
+        if (t.ret.kind === "void")
+            B.line(`call void ${fn}(${args})`);
+        else
+            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;
+     * records of them with only declared fields, none of union type; and
+     * boxed unions of those arms and null or undefined without a literal
+     * discriminator, with at most one number, boolean and string arm. */
+    messageReadable(t, seen) {
+        switch (t.kind) {
+            case "f64":
+            case "bool":
+            case "string":
+                return true;
+            case "record": {
+                const shape = this.host.recordsById.get(t.shapeId);
+                if (!shape || shape.tuple || shape.indexValue || shape.fields.length === 0)
+                    return false;
+                if (seen.has(t.shapeId) || this.isRecursiveShape(t))
+                    return false;
+                seen.add(t.shapeId);
+                const readable = shape.fields.every((f) => !f.name.startsWith("%") &&
+                    f.type.kind !== "union" &&
+                    llFieldType(f.type, this.host.inlineUnions.record(f.type)) !== INLINE_UNION_FIELD &&
+                    this.messageReadable(f.type, seen));
+                seen.delete(t.shapeId);
+                return readable;
+            }
+            case "union": {
+                const def = this.host.unionsById.get(t.unionId);
+                // A discriminated union's checked conversion also tests the arm's
+                // literal discriminator, which the readers do not.
+                if (!def || def.discriminant || this.host.nullableUnions.has(t.unionId))
+                    return false;
+                const scalars = new Set();
+                for (const arm of def.arms) {
+                    if (arm.kind === "nullT" || arm.kind === "undefinedT")
+                        continue;
+                    if (arm.kind === "f64" || arm.kind === "bool" || arm.kind === "string") {
+                        if (scalars.has(arm.kind))
+                            return false;
+                        scalars.add(arm.kind);
+                        continue;
+                    }
+                    if (arm.kind !== "record" || !this.messageReadable(arm, seen))
+                        return false;
+                }
+                return true;
+            }
+            default:
+                return false;
+        }
+    }
+    /** `sc_dmr_<n>(ptr message, size node, ptr fail) -> T`: T (+1) built
+     * from a message node, for a type messageReadable accepts. Sets *fail
+     * and returns a dummy when the node does not have T's layout: the arm
+     * the checked conversion would choose, a record's declared keys in
+     * declaration order and no others. */
+    messageReaderHelper(t) {
+        const key = typeKey(t);
+        const existing = this.messageReaders.get(key);
+        if (existing)
+            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")
+            host.declare(`declare i32 @scr_message_kind(ptr, ${S})`);
+        const retTy = this.valTy(t);
+        const dummy = retTy === "double" ? f64Lit(0) : retTy === "i1" ? "false" : "null";
+        const B = new BlockBuilder();
+        const lFail = B.newLabel("dmr.fail");
+        // scr_message_fields tests a record's kind itself.
+        const kind = B.tmp();
+        if (t.kind !== "record")
+            B.line(`${kind} = call i32 @scr_message_kind(ptr %m, ${S} %n)`);
+        const requireKind = (want) => {
+            const ok = B.tmp();
+            B.line(`${ok} = icmp eq i32 ${kind}, ${want}`);
+            const lOk = B.newLabel("dmr.kind");
+            B.condBr(ok, lOk, lFail);
+            B.startBlock(lOk);
+        };
+        switch (t.kind) {
+            case "f64":
+            case "bool": {
+                host.declare(`declare double @scr_message_number(ptr, ${S})`);
+                requireKind(t.kind === "f64" ? MESSAGE_KIND.NUMBER : MESSAGE_KIND.BOOL);
+                const n = B.tmp();
+                B.line(`${n} = call double @scr_message_number(ptr %m, ${S} %n)`);
+                if (t.kind === "f64")
+                    B.terminate(`ret double ${n}`);
+                else {
+                    const b = B.tmp();
+                    B.line(`${b} = fcmp une double ${n}, ${f64Lit(0)}`);
+                    B.terminate(`ret i1 ${b}`);
+                }
+                break;
+            }
+            case "string": {
+                host.declare(`declare ptr @scr_message_string(ptr, ${S})`);
+                requireKind(MESSAGE_KIND.STRING);
+                const str = B.tmp();
+                B.line(`${str} = call ptr @scr_message_string(ptr %m, ${S} %n)`);
+                B.terminate(`ret ptr ${str}`);
+                break;
+            }
+            case "record": {
+                const shape = host.recordsById.get(t.shapeId);
+                const order = recordSourceFieldOrder(shape);
+                const fields = new Map(shape.fields.map((f, i) => [f.name, { field: f, index: i }]));
+                const base = host.nullableUnions.fieldBase(t.shapeId);
+                const struct = mangleRecordStruct(t.shapeId);
+                const names = this.recordNameTable(t.shapeId, shape);
+                host.declare(`declare zeroext i1 @scr_message_fields(ptr, ${S}, ptr, ptr, ${S}, ptr)`);
+                B.entryAllocas.push(`%kids = alloca [${order.length} x ${S}]`);
+                const matched = B.tmp();
+                B.line(`${matched} = call zeroext i1 @scr_message_fields(ptr %m, ${S} %n, ptr ${names.names}, ptr ${names.lens}, ${S} ${order.length}, ptr %kids)`);
+                const lBuild = B.newLabel("dmr.build");
+                B.condBr(matched, lBuild, lFail);
+                B.startBlock(lBuild);
+                B.line(`%r0 = call ptr @${mangleRecordNew(t.shapeId)}()`);
+                order.forEach((fieldName, i) => {
+                    const { field, index } = fields.get(fieldName);
+                    const kidp = B.tmp();
+                    const kid = B.tmp();
+                    B.line(`${kidp} = getelementptr inbounds [${order.length} x ${S}], ptr %kids, i64 0, i64 ${i}`);
+                    B.line(`${kid} = load ${S}, ptr ${kidp}`);
+                    const v = B.tmp();
+                    B.line(`${v} = call ${this.valTy(field.type)} @${this.messageReaderHelper(field.type)}(ptr %m, ${S} ${kid}, ptr %fail)`);
+                    const failed = B.tmp();
+                    B.line(`${failed} = load i1, ptr %fail`);
+                    const lDrop = B.newLabel("dmr.drop");
+                    const lStore = B.newLabel("dmr.store");
+                    B.condBr(failed, lDrop, lStore);
+                    B.startBlock(lDrop);
+                    B.line(`call void ${releaseSym(host, t)}(ptr %r0)`);
+                    B.terminate(`ret ptr null`);
+                    B.startBlock(lStore);
+                    const p = B.tmp();
+                    B.line(`${p} = getelementptr inbounds %${struct}, ptr %r0, i64 0, i32 ${index + base} ; .${llvmCommentText(fieldName)}`);
+                    const fieldTy = llFieldType(field.type, host.inlineUnions.record(field.type));
+                    if (fieldTy === "i8") {
+                        const z = B.tmp();
+                        B.line(`${z} = zext i1 ${v} to i8`);
+                        B.line(`store i8 ${z}, ptr ${p}`);
+                    }
+                    else {
+                        B.line(`store ${fieldTy} ${v}, ptr ${p}`);
+                    }
+                });
+                B.terminate(`ret ptr %r0`);
+                break;
+            }
+            case "union": {
+                const def = host.unionsById.get(t.unionId);
+                def.arms.forEach((arm, i) => {
+                    const lNext = B.newLabel("dmr.next");
+                    if (arm.kind === "nullT" || arm.kind === "undefinedT") {
+                        const hit = B.tmp();
+                        B.line(`${hit} = icmp eq i32 ${kind}, ${arm.kind === "nullT" ? MESSAGE_KIND.NULL : MESSAGE_KIND.UNDEFINED}`);
+                        const lHit = B.newLabel("dmr.unit");
+                        B.condBr(hit, lHit, lNext);
+                        B.startBlock(lHit);
+                        B.terminate(`ret ptr ${host.unitInstanceRef(t.unionId, i)}`);
+                        B.startBlock(lNext);
+                        return;
+                    }
+                    if (arm.kind !== "record") {
+                        const want = arm.kind === "f64"
+                            ? MESSAGE_KIND.NUMBER
+                            : arm.kind === "bool"
+                                ? MESSAGE_KIND.BOOL
+                                : MESSAGE_KIND.STRING;
+                        const hit = B.tmp();
+                        B.line(`${hit} = icmp eq i32 ${kind}, ${want}`);
+                        const lHit = B.newLabel("dmr.arm");
+                        B.condBr(hit, lHit, lNext);
+                        B.startBlock(lHit);
+                    }
+                    // A record arm that does not match leaves *fail clear for the
+                    // next arm, like the checked conversion's next-arm match.
+                    const v = B.tmp();
+                    B.line(`${v} = call ${this.valTy(arm)} @${this.messageReaderHelper(arm)}(ptr %m, ${S} %n, ptr %fail)`);
+                    if (arm.kind === "record") {
+                        const failed = B.tmp();
+                        B.line(`${failed} = load i1, ptr %fail`);
+                        const lHit = B.newLabel("dmr.arm");
+                        const lMiss = B.newLabel("dmr.miss");
+                        B.condBr(failed, lMiss, lHit);
+                        B.startBlock(lMiss);
+                        B.line(`store i1 false, ptr %fail`);
+                        B.br(lNext);
+                        B.startBlock(lHit);
+                    }
+                    const u = B.tmp();
+                    if (arm.kind === "f64") {
+                        host.declare(`declare ptr @scr_union_new_f64(i32, double)`);
+                        B.line(`${u} = call ptr @scr_union_new_f64(i32 ${i}, double ${v})`);
+                    }
+                    else if (arm.kind === "bool") {
+                        host.declare(`declare ptr @scr_union_new_bool(i32, i1 zeroext)`);
+                        B.line(`${u} = call ptr @scr_union_new_bool(i32 ${i}, i1 ${v})`);
+                    }
+                    else {
+                        const rc = vAdapters(host, arm);
+                        host.declare(`declare ptr @scr_union_new_ref(i32, ptr, ptr, ptr, ptr)`);
+                        B.line(`${u} = call ptr @scr_union_new_ref(i32 ${i}, ptr ${v}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${traceArg(host, arm)})`);
+                    }
+                    B.terminate(`ret ptr ${u}`);
+                    B.startBlock(lNext);
+                });
+                B.br(lFail);
+                break;
+            }
+            default:
+                throw new InternalCompilerError(`llvm emitter bug: message reader of ${key}`);
+        }
+        B.startBlock(lFail);
+        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
@@ -4058,6 +4670,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)`);
@@ -4152,6 +4765,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;
     }
 }