@scriptc/compiler 0.3.3 → 0.3.5

package/dist/backend/llvm/dyn.js

@@ -1,6 +1,6 @@
 import { typedRefConstructor } from "./shapes.js";
 import { bindLiveArrayOps } from "./expr-stream-bridges.js";
-import { BYTES_ELEM_NUM, SCR_ARR_FIELD, f64Lit } from "./common.js";
+import { BYTES_ELEM_NUM, SCR_ARR_FIELD, 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";
@@ -11,6 +11,17 @@ import { BlockBuilder } from "./blocks.js";
 import { llvmCommentText } from "./common.js";
 import { arrNewCall, elemAccess, llFieldType, releaseSym, traceAdapter, traceArg, vAdapters, } from "./shapes.js";
 import { LlvmUnsupportedError } from "./unsupported.js";
+import { recordMayKeepSource, recordSourceFieldOrder } from "./record-sources.js";
+/** Whether to-dyn of a record shape keeps the record itself: an empty shape
+ * and an event-listener record (a `handleEvent` function field) box their
+ * identity. Every other shape, tuples included, copies its fields into a
+ * fresh checked-dynamic value. */
+export function recordDynKeepsIdentity(shape) {
+    if (shape.tuple)
+        return false;
+    return ((shape.fields.length === 0 && !shape.indexValue) ||
+        shape.fields.some((f) => f.name === "handleEvent" && f.type.kind === "func"));
+}
 /** ScrDynKind values (scr_runtime.h). */
 /** ScrDynHandleTag numeric values (scr_runtime.h's enum order). */
 const DYN_HANDLE_TAG_NUM = {
@@ -56,11 +67,117 @@ export class LlDyn {
     dynToStrFn = null;
     caughtToDynFn = null;
     helperMemo = new Map();
+    recursiveShapes = new Map();
+    holdsRecursiveShapes = new Map();
     /** Emitted function definitions, in interning order. */
     defs = [];
     constructor(host) {
         this.host = host;
     }
+    /** The types a dyn matcher or builder for `t` checks structurally: record
+     * fields and index values, array elements and union arms. */
+    structuralChildren(t) {
+        switch (t.kind) {
+            case "record": {
+                const shape = this.host.recordsById.get(t.shapeId);
+                if (!shape)
+                    return [];
+                const fields = shape.fields.map((f) => f.type);
+                return shape.indexValue ? [...fields, shape.indexValue] : fields;
+            }
+            case "array":
+                return [t.elem];
+            case "union":
+                return this.host.unionsById.get(t.unionId)?.arms ?? [];
+            default:
+                return [];
+        }
+    }
+    /** A record or array type that reaches itself through its fields,
+     * elements or union arms. Only these can describe a cyclic dyn value, so
+     * only their matchers and builders track visited values. */
+    isRecursiveShape(t) {
+        if (t.kind !== "record" && t.kind !== "array")
+            return false;
+        const key = typeKey(t);
+        const known = this.recursiveShapes.get(key);
+        if (known !== undefined)
+            return known;
+        const seen = new Set();
+        const pending = [...this.structuralChildren(t)];
+        let recursive = false;
+        while (pending.length > 0 && !recursive) {
+            const next = pending.pop();
+            const nextKey = typeKey(next);
+            if (nextKey === key)
+                recursive = true;
+            else if (!seen.has(nextKey)) {
+                seen.add(nextKey);
+                pending.push(...this.structuralChildren(next));
+            }
+        }
+        this.recursiveShapes.set(key, recursive);
+        return recursive;
+    }
+    /** A type with a recursive shape among the types it reaches. Its matcher
+     * and builder keep one visit session open for all of its members, so a
+     * dyn value reached through two of them converts once. */
+    holdsRecursiveShape(t) {
+        const key = typeKey(t);
+        const known = this.holdsRecursiveShapes.get(key);
+        if (known !== undefined)
+            return known;
+        const seen = new Set([key]);
+        const pending = [...this.structuralChildren(t)];
+        let holds = false;
+        while (pending.length > 0 && !holds) {
+            const next = pending.pop();
+            const nextKey = typeKey(next);
+            if (seen.has(nextKey))
+                continue;
+            seen.add(nextKey);
+            if (this.isRecursiveShape(next))
+                holds = true;
+            else
+                pending.push(...this.structuralChildren(next));
+        }
+        this.holdsRecursiveShapes.set(key, holds);
+        return holds;
+    }
+    /** `name` around the structural body `${name}_body`, inside one visit
+     * session of the runtime. A recursive shape's matcher ("match") answers
+     * true for a (value, matcher) pair it is already checking further up the
+     * stack. A recursive shape's builder ("build") answers the value it
+     * already built for the same dyn value in the session, so cycles and
+     * shared values keep their identity. Matchers ("visit") and builders
+     * ("memo") of types holding recursive shapes only keep the session open
+     * across their members. */
+    emitVisitWrapper(name, t, mode) {
+        const host = this.host;
+        const what = mode === "match" || mode === "build" ? "visits tracked" : "one visit session";
+        if (mode === "match" || mode === "visit") {
+            host.declare(`declare zeroext i1 @scr_dyn_match_visit(ptr, ptr, ptr)`);
+            this.defs.push(`define internal zeroext i1 @${name}(ptr %d) ${FN_ATTRS} { ; matches ${llvmCommentText(typeKey(t))}, ${what}`, `entry:`, `  %ok = call zeroext i1 @scr_dyn_match_visit(ptr %d, ptr ${mode === "match" ? `@${name}` : "null"}, ptr @${name}_body)`, `  ret i1 %ok`, `}`, ``);
+            return;
+        }
+        const retain = mode === "build" ? vAdapters(host, t).retain : "null";
+        host.declare(`declare ptr @scr_dyn_build_visit(ptr, ptr, ptr, ptr, ptr)`);
+        this.defs.push(`define internal ptr @${name}(ptr %d, ptr %path) ${FN_ATTRS} { ; check ${llvmCommentText(typeKey(t))}, ${what}`, `entry:`, `  %r = call ptr @scr_dyn_build_visit(ptr %d, ptr %path, ptr ${mode === "build" ? `@${name}` : "null"}, ptr @${name}_body, ptr ${retain})`, `  ret ptr %r`, `}`, ``);
+    }
+    /** The runtime call that gives a matcher or builder body a capsule's
+     * dyn view: inside a visit session (`wrapped`), a capsule keeps the view
+     * it was first given, so an outer visit can keep reading it. */
+    viewFn(wrapped) {
+        const fn = wrapped ? "scr_dyn_visit_view" : "scr_dyn_typed_ref_materialize";
+        this.host.declare(`declare ptr @${fn}(ptr)`);
+        return fn;
+    }
+    /** In a recursive shape's builder body: record `value`, just allocated
+     * for %d, before its members are built. */
+    recordBuilt(B, name, value) {
+        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})`);
+    }
     /** 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) {
@@ -315,12 +432,23 @@ export class LlDyn {
         return out;
     }
     /** Ordinary property lookup, including inherited data and accessors (+1). */
-    objReadLit(B, d, key) {
-        this.host.declare(`declare ptr @scr_dyn_obj_read(ptr, ptr, ${this.S})`);
+    objReadLit(B, d, key, held = false) {
+        const read = held ? "scr_dyn_obj_read_held" : "scr_dyn_obj_read";
+        this.host.declare(`declare ptr @${read}(ptr, ptr, ${this.S})`);
         const value = B.tmp();
-        B.line(`${value} = call ptr @scr_dyn_obj_read(ptr ${d}, ptr ${this.host.cstr(key)}, ${this.S} ${Buffer.byteLength(key, "utf8")})`);
+        B.line(`${value} = call ptr @${read}(ptr ${d}, ptr ${this.host.cstr(key)}, ${this.S} ${Buffer.byteLength(key, "utf8")})`);
         return value;
     }
+    /** A member read for a matcher or builder of `t`: values that can reach a
+     * recursive shape go through the runtime's held read, so its visit
+     * tracking does not count the read's reference. Returns the value and
+     * the matching release. */
+    memberRead(B, key, t) {
+        const held = this.isRecursiveShape(t) || this.holdsRecursiveShape(t);
+        const release = held ? "scr_dyn_release_held" : "scr_dyn_release";
+        this.host.declare(`declare void @${release}(ptr)`);
+        return { value: this.objReadLit(B, "%d", key, held), release };
+    }
     /** Appends a borrowed string, preserving its full byte length. */
     putScrStr(B, buf, s) {
         this.host.declare(`declare void @scr_jb_put_str(ptr, ptr)`);
@@ -435,6 +563,8 @@ export class LlDyn {
             return existing;
         const name = `sc_dm_${this.dynMatchers.size}`;
         this.dynMatchers.set(matcherKey, name);
+        const recursive = this.isRecursiveShape(t);
+        const wrapped = recursive || this.holdsRecursiveShape(t);
         const B = new BlockBuilder();
         if (isRefCounted(t) && t.kind !== "dyn") {
             const matched = this.typedRefMatches(B, t);
@@ -446,7 +576,7 @@ export class LlDyn {
             B.startBlock(lNext);
         }
         if (t.kind !== "dyn") {
-            this.host.declare(`declare ptr @scr_dyn_typed_ref_materialize(ptr)`);
+            const view = this.viewFn(wrapped);
             this.host.declare(`declare void @scr_dyn_release_v(ptr)`);
             const kind = this.kindOf(B, "%d");
             const capsule = B.tmp();
@@ -461,7 +591,7 @@ export class LlDyn {
             else {
                 const materialized = B.tmp();
                 const matched = B.tmp();
-                B.line(`${materialized} = call ptr @scr_dyn_typed_ref_materialize(ptr %d)`);
+                B.line(`${materialized} = call ptr @${view}(ptr %d)`);
                 B.line(`${matched} = call zeroext i1 @${name}(ptr ${materialized})`);
                 B.line(`call void @scr_dyn_release_v(ptr ${materialized})`);
                 B.terminate(`ret i1 ${matched}`);
@@ -640,13 +770,12 @@ export class LlDyn {
                 for (const f of shape.fields) {
                     if (f.type.kind === "dyn")
                         continue;
-                    const m = this.objReadLit(B, "%d", f.name);
+                    const { value: m, release } = this.memberRead(B, f.name, f.type);
                     const lNext = B.newLabel("dm.n");
-                    this.host.declare(`declare void @scr_dyn_release(ptr)`);
-                    this.pendingBail(B, "dm.read", () => B.line(`call void @scr_dyn_release(ptr ${m})`), "i1 false");
+                    this.pendingBail(B, "dm.read", () => B.line(`call void @${release}(ptr ${m})`), "i1 false");
                     const ok = B.tmp();
                     B.line(`${ok} = call zeroext i1 @${this.dynMatchHelper(f.type, preserveRefs)}(ptr ${m})`);
-                    B.line(`call void @scr_dyn_release(ptr ${m})`);
+                    B.line(`call void @${release}(ptr ${m})`);
                     B.condBr(ok, lNext, fail);
                     B.startBlock(lNext);
                 }
@@ -764,12 +893,15 @@ export class LlDyn {
                 break;
             }
         }
-        this.defs.push(`define internal zeroext i1 @${name}(ptr %d) ${FN_ATTRS} { ; matches ${key}`, B.render(), `}`, ``);
+        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");
         return name;
     }
     /* ── schema-directed JSON.parse ───────────────────────────────── */
     jsonSchemas = new Map();
     jsonParsers = new Map();
+    recordNameTables = new Map();
     /** Targets the one-pass parser (scr_json_parse_schema) can build
      * directly: number, boolean and string leaves inside arrays and plain
      * records (no tuple, index signature, internal '%' slot or `__proto__`
@@ -834,10 +966,8 @@ export class LlDyn {
                     throw new InternalCompilerError(`llvm emitter bug: JSON schema of unknown shape ${t.shapeId}`);
                 const struct = mangleRecordStruct(t.shapeId);
                 const index = new Map(shape.fields.map((f, i) => [f.name, i + 1]));
-                const order = [...(shape.declaredOrder ?? []).filter((n) => index.has(n))];
-                for (const f of shape.fields)
-                    if (!order.includes(f.name))
-                        order.push(f.name);
+                // The runtime names kept-source keys by this index (record-sources.ts).
+                const order = recordSourceFieldOrder(shape);
                 const fieldTy = `{ ptr, ${S}, ${S}, ptr }`;
                 const entries = order.map((fieldName) => {
                     const field = shape.fields[index.get(fieldName) - 1];
@@ -856,6 +986,24 @@ export class LlDyn {
         this.defs.push(`@${name} = internal constant { ${S}, ${S}, ptr, ptr, ptr, ptr, ptr } { ${body} }`, ``);
         return name;
     }
+    /** 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
+     * '%'-fields follow, so they never count as undeclared source keys. */
+    recordNameTable(shapeId, shape) {
+        const existing = this.recordNameTables.get(shapeId);
+        if (existing)
+            return existing;
+        const host = this.host;
+        const S = host.sizeType;
+        const base = `sc_rnames_${this.recordNameTables.size}`;
+        const table = { names: `@${base}`, lens: `@${base}_lens` };
+        this.recordNameTables.set(shapeId, table);
+        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(", ")}]`, ``);
+        return table;
+    }
     /** `sc_jp_<n>(ptr text) -> T` for `JSON.parse(text) as T`, or null when T
      * is not a schema target. Tries the one-pass schema parser; when it
      * declines (any input the checked route might reject or read
@@ -894,6 +1042,8 @@ export class LlDyn {
             return existing;
         const name = `sc_dc_${this.dynBuilders.size}`;
         this.dynBuilders.set(builderKey, name);
+        const recursive = this.isRecursiveShape(t);
+        const memo = !recursive && this.holdsRecursiveShape(t) && this.valTy(t) === "ptr";
         const host = this.host;
         const retTy = this.valTy(t);
         const dummy = retTy === "double" ? `double ${f64Lit(0)}` : retTy === "i1" ? "i1 false" : "ptr null";
@@ -945,7 +1095,7 @@ export class LlDyn {
                 B.startBlock(plain);
             }
             else if (t.kind !== "union") {
-                host.declare(`declare ptr @scr_dyn_typed_ref_materialize(ptr)`);
+                const view = this.viewFn(recursive || memo);
                 host.declare(`declare ptr @scr_dyn_typed_ref_cached_cast(ptr, ptr, ${host.sizeType})`);
                 host.declare(`declare void @scr_dyn_typed_ref_cache_cast(ptr, ptr, ${host.sizeType}, ptr, ptr, ptr, i1)`);
                 host.declare(`declare void @scr_dyn_release_v(ptr)`);
@@ -961,6 +1111,13 @@ export class LlDyn {
                 B.line(`${cached} = call ptr @scr_dyn_typed_ref_cached_cast(ptr %d, ptr ${host.cstr(key)}, ${host.sizeType} ${Buffer.byteLength(key, "utf8")})`);
                 const hasCached = B.tmp();
                 B.line(`${hasCached} = icmp ne ptr ${cached}, null`);
+                if (recursive) {
+                    // A cached record keeps its identity: the refresh below rewrites
+                    // it in place. Later visits of this capsule in the session answer
+                    // it, instead of refreshing it while this visit rebuilds it.
+                    host.declare(`declare void @scr_dyn_build_note(ptr, ptr, ptr)`);
+                    B.line(`call void @scr_dyn_build_note(ptr %d, ptr @${name}, ptr ${cached})`);
+                }
                 if (t.kind !== "record" && t.kind !== "array") {
                     const lCached = B.newLabel("dc.tr.hit");
                     const lMaterialize = B.newLabel("dc.tr.mat");
@@ -971,7 +1128,7 @@ export class LlDyn {
                 }
                 const materialized = B.tmp();
                 const checked = B.tmp();
-                B.line(`${materialized} = call ptr @scr_dyn_typed_ref_materialize(ptr %d)`);
+                B.line(`${materialized} = call ptr @${view}(ptr %d)`);
                 B.line(`${checked} = call ${retTy} @${name}(ptr ${materialized}, ptr %path)`);
                 B.line(`call void @scr_dyn_release_v(ptr ${materialized})`);
                 const ok = B.tmp();
@@ -1048,6 +1205,12 @@ export class LlDyn {
                         host.declare("declare void @scr_arr_swap_indexed_ext(ptr, ptr)");
                         B.line(`call void @scr_arr_swap_indexed_ext(ptr ${cached}, ptr ${checked})`);
                     }
+                    if (recursive) {
+                        // The memo recorded the record built for the view: later visits
+                        // in the session answer the cached record that now holds it.
+                        host.declare(`declare void @scr_dyn_build_rekey(ptr, ptr, ptr)`);
+                        B.line(`call void @scr_dyn_build_rekey(ptr ${materialized}, ptr @${name}, ptr ${cached})`);
+                    }
                     B.line(`call void ${releaseSym(host, t)}(ptr ${checked})`);
                     B.terminate(`ret ptr ${cached}`);
                     B.startBlock(lCache);
@@ -1319,6 +1482,8 @@ export class LlDyn {
                     B.terminate(`ret ptr null`);
                     B.startBlock(lGo);
                     B.line(`%r0 = call ptr @${mangleRecordNew(t.shapeId)}()`);
+                    if (recursive)
+                        this.recordBuilt(B, name, "%r0");
                     const items = this.itemsOf(B, "%d");
                     byIndex.forEach((f, i) => {
                         setPath(null, `${i}`);
@@ -1362,17 +1527,18 @@ export class LlDyn {
                     B.startBlock(lCopy);
                 }
                 B.line(`%r0 = call ptr @${mangleRecordNew(t.shapeId)}()`);
+                if (recursive)
+                    this.recordBuilt(B, name, "%r0");
                 for (const f of shape.fields) {
-                    const m = this.objReadLit(B, "%d", f.name);
-                    host.declare(`declare void @scr_dyn_release(ptr)`);
+                    const { value: m, release } = this.memberRead(B, f.name, f.type);
                     this.pendingBail(B, "dcr.read", () => {
-                        B.line(`call void @scr_dyn_release(ptr ${m})`);
+                        B.line(`call void @${release}(ptr ${m})`);
                         releaseR();
                     }, "ptr null");
                     setPath(f.name, "0");
                     const value = B.tmp();
                     B.line(`${value} = call ${this.valTy(f.type)} @${this.dynCheckHelper(f.type, preserveRefs)}(ptr ${m}, ptr ${pathSlot})`);
-                    B.line(`call void @scr_dyn_release(ptr ${m})`);
+                    B.line(`call void @${release}(ptr ${m})`);
                     storeInto(f.name, f.type, value);
                     this.pendingBail(B, "dcr", () => {
                         releaseInline(f.type, value);
@@ -1385,6 +1551,14 @@ export class LlDyn {
                     }
                     releaseInline(f.type, value);
                 }
+                // A closed layout cannot store undeclared keys: a source object
+                // that has them stays beside the record so its reflective
+                // surfaces still observe them (scr_record_source_note).
+                if (recordMayKeepSource(shape)) {
+                    const names = this.recordNameTable(t.shapeId, shape);
+                    host.declare(`declare void @scr_record_source_note(ptr, ptr, ptr, ptr, ${host.sizeType})`);
+                    B.line(`call void @scr_record_source_note(ptr %r0, ptr %d, ptr ${names.names}, ptr ${names.lens}, ${host.sizeType} ${shape.fields.length})`);
+                }
                 // Index-signature shapes CAPTURE undeclared keys into the
                 // overflow map.
                 if (shape.indexValue) {
@@ -1458,6 +1632,8 @@ export class LlDyn {
                 const n = this.lenOf(B, "%d");
                 const a = B.tmp();
                 B.line(`${a} = ${arrNewCall(host, elem, n)}`);
+                if (recursive)
+                    this.recordBuilt(B, name, a);
                 const items = this.itemsOf(B, "%d");
                 const pathSlot = "%dcp";
                 B.entryAllocas.push(`${pathSlot} = alloca %ScrDynPath`);
@@ -1476,7 +1652,7 @@ export class LlDyn {
                     host.declare(`declare void @scr_arr_set_len(ptr, double)`);
                     const index = B.tmp();
                     const length = B.tmp();
-                    B.line(`${index} = sitofp ${this.S} ${i} to double`);
+                    B.line(`${index} = ${sizeToDouble(this.S)} ${this.S} ${i} to double`);
                     B.line(`${length} = fadd double ${index}, 1.0`);
                     B.line(`call void @scr_arr_set_len(ptr ${a}, double ${length})`);
                     B.br(doneLabel);
@@ -1563,7 +1739,7 @@ export class LlDyn {
                 // retry the union against the ordinary copy-based structural
                 // snapshot (the compiler's width-coercion stance, rather than a
                 // live narrowed alias).
-                host.declare(`declare ptr @scr_dyn_typed_ref_materialize(ptr)`);
+                const view = this.viewFn(recursive || memo);
                 host.declare(`declare ptr @scr_dyn_typed_ref_cached_cast(ptr, ptr, ${host.sizeType})`);
                 host.declare(`declare void @scr_dyn_typed_ref_cache_cast(ptr, ptr, ${host.sizeType}, ptr, ptr, ptr, i1)`);
                 host.declare(`declare void @scr_dyn_release_v(ptr)`);
@@ -1582,7 +1758,7 @@ export class LlDyn {
                     // pending exception rather than a NULL result.
                     const materialized = B.tmp();
                     const checked = B.tmp();
-                    B.line(`${materialized} = call ptr @scr_dyn_typed_ref_materialize(ptr %d)`);
+                    B.line(`${materialized} = call ptr @${view}(ptr %d)`);
                     B.line(`${checked} = call ptr @${name}(ptr ${materialized}, ptr %path)`);
                     B.line(`call void @scr_dyn_release_v(ptr ${materialized})`);
                     B.terminate(`ret ptr ${checked}`);
@@ -1597,7 +1773,7 @@ export class LlDyn {
                 B.line(`${hasCached} = icmp ne ptr ${cached}, null`);
                 const materialized = B.tmp();
                 const checked = B.tmp();
-                B.line(`${materialized} = call ptr @scr_dyn_typed_ref_materialize(ptr %d)`);
+                B.line(`${materialized} = call ptr @${view}(ptr %d)`);
                 B.line(`${checked} = call ptr @${name}(ptr ${materialized}, ptr %path)`);
                 B.line(`call void @scr_dyn_release_v(ptr ${materialized})`);
                 const ok = B.tmp();
@@ -1740,7 +1916,9 @@ export class LlDyn {
                 throw new LlvmUnsupportedError(`type:${t.kind}`);
             }
         }
-        this.defs.push(`define internal ${retTy === "i1" ? "zeroext i1" : retTy} @${name}(ptr %d, ptr %path) ${FN_ATTRS} { ; check ${key}`, B.render(), `}`, ``);
+        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");
         return name;
     }
     /* ── toDynHelper (walkers.ts, ported) ─────────────────────────── */
@@ -1943,8 +2121,7 @@ export class LlDyn {
                     break;
                 }
                 const d = B.tmp();
-                const carriesListenerIdentity = shape.fields.some((f) => f.name === "handleEvent" && f.type.kind === "func");
-                if ((shape.fields.length === 0 && !shape.indexValue) || carriesListenerIdentity) {
+                if (recordDynKeepsIdentity(shape)) {
                     const rc = vAdapters(host, t);
                     sourceAccessor = {
                         name: `${name}_source_access`,
@@ -2052,9 +2229,17 @@ export class LlDyn {
                 }
                 if (cyclicRec)
                     B.line(`call void @scr_dyn_from_leave()`);
+                let snapshot = d;
+                if (!shape.indexValue && !recordDynKeepsIdentity(shape)) {
+                    // Undeclared properties the record kept from its checked source
+                    // rejoin the copy in their own-key positions.
+                    host.declare(`declare ptr @scr_record_source_apply(ptr, ptr)`);
+                    snapshot = B.tmp();
+                    B.line(`${snapshot} = call ptr @scr_record_source_apply(ptr ${d}, ptr %v)`);
+                }
                 host.declare(`declare ptr @scr_dyn_mark_snapshot(ptr)`);
-                B.line(`call ptr @scr_dyn_mark_snapshot(ptr ${d})`);
-                B.terminate(`ret ptr ${d}`);
+                B.line(`call ptr @scr_dyn_mark_snapshot(ptr ${snapshot})`);
+                B.terminate(`ret ptr ${snapshot}`);
                 break;
             }
             case "array": {
@@ -3103,7 +3288,7 @@ export class LlDyn {
                 const n = this.lenOf(B, "%d");
                 const nd = B.tmp();
                 const r = B.tmp();
-                B.line(`${nd} = sitofp ${host.sizeType} ${n} to double`);
+                B.line(`${nd} = ${sizeToDouble(host.sizeType)} ${host.sizeType} ${n} to double`);
                 B.line(`${r} = call ptr @scr_dyn_new_num(double ${nd})`);
                 B.terminate(`ret ptr ${r}`);
                 B.startBlock(lStr);
@@ -3142,7 +3327,7 @@ export class LlDyn {
                 const n2 = B.tmp();
                 B.line(`${n2} = call double @scr_str_utf16_len(ptr ${s})`);
                 const idxD = B.tmp();
-                B.line(`${idxD} = sitofp ${host.sizeType} ${idx} to double`);
+                B.line(`${idxD} = ${sizeToDouble(host.sizeType)} ${host.sizeType} ${idx} to double`);
                 const inR2 = B.tmp();
                 B.line(`${inR2} = fcmp olt double ${idxD}, ${n2}`);
                 const lHit2 = B.newLabel("kg.ash");
@@ -3395,7 +3580,7 @@ export class LlDyn {
                 const index = B.tmp();
                 const bd = B.tmp();
                 const r = B.tmp();
-                B.line(`${index} = sitofp ${host.sizeType} ${i} to double`);
+                B.line(`${index} = ${sizeToDouble(host.sizeType)} ${host.sizeType} ${i} to double`);
                 B.line(`${bd} = call double @scr_bytes_get(ptr ${bts}, double ${index})`);
                 B.line(`${r} = call ptr @scr_dyn_new_num(double ${bd})`);
                 B.line(`store ptr ${r}, ptr ${itemSlot}`);