@scriptc/compiler 0.3.2 → 0.3.4

package/dist/backend/llvm/dyn.d.ts

@@ -1,6 +1,11 @@
-import type { IrType } from "../../ir/ir.js";
+import type { IrRecordShape, IrType } from "../../ir/ir.js";
 import type { WalkerHost } from "./walkers.js";
 import type { LlStreamTypedRefAdapter } from "./expr-context.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 declare function recordDynKeepsIdentity(shape: IrRecordShape): boolean;
 export declare const DYN_KIND: {
     readonly NULL: 0;
     readonly BOOL: 1;
@@ -55,9 +60,38 @@ export declare class LlDyn {
     private dynToStrFn;
     private caughtToDynFn;
     private readonly helperMemo;
+    private readonly recursiveShapes;
+    private readonly holdsRecursiveShapes;
     /** Emitted function definitions, in interning order. */
     readonly defs: string[];
     constructor(host: DynHost);
+    /** The types a dyn matcher or builder for `t` checks structurally: record
+     * fields and index values, array elements and union arms. */
+    private structuralChildren;
+    /** 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. */
+    private isRecursiveShape;
+    /** 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. */
+    private holdsRecursiveShape;
+    /** `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. */
+    private emitVisitWrapper;
+    /** 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. */
+    private viewFn;
+    /** In a recursive shape's builder body: record `value`, just allocated
+     * for %d, before its members are built. */
+    private recordBuilt;
     /** Branch to a variant only after its literal discriminator and complete
      * structure match. Use the same path for predicates and builders. */
     private unionArmMatch;
@@ -106,6 +140,11 @@ export declare class LlDyn {
     private presenceOf;
     /** Ordinary property lookup, including inherited data and accessors (+1). */
     private objReadLit;
+    /** 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. */
+    private memberRead;
     /** Appends a borrowed string, preserving its full byte length. */
     private putScrStr;
     /** Fixed text and JSON tokens hold no lone surrogate, so they append
@@ -117,6 +156,10 @@ export declare class LlDyn {
     /** Emit the standard in-helper pending check: on a pending exception
      * run `cleanup` and return `dummy`. */
     private pendingBail;
+    /** A capsule boxed from this class by this program carries the class's
+     * key constant itself: return its instance (+1) without comparing names
+     * or calling the capsule's retain adapter. Other values continue. */
+    private exactClassCapsule;
     /** Native subclass capsules also satisfy a checked base-class slot.
      * Class layouts share their base prefix, so unboxing retains the same
      * pointer and virtual dispatch still uses the object's original vtable. */

package/dist/backend/llvm/dyn.js

@@ -1,15 +1,26 @@
 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";
-import { DYN_HANDLE_KINDS, isDynTypedRefType, isRefCounted, typeKey } from "../../ir/ir.js";
+import { DYN_HANDLE_KINDS, isDirentShape, isDynTypedRefType, isRefCounted, typeKey, } from "../../ir/ir.js";
 import { dynDesc, streamTypedRefEligible } from "../../ir/analysis.js";
 import { mangleRecordNew, mangleRecordStruct } from "../mangle.js";
 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";
+/** 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 = {
@@ -22,6 +33,7 @@ const DYN_HANDLE_TAG_NUM = {
     httpClientReq: 6,
     child: 16,
     fileHandle: 17,
+    dir: 44,
 };
 export const DYN_KIND = {
     NULL: 0,
@@ -54,11 +66,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) {
@@ -313,12 +431,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)`);
@@ -371,6 +500,35 @@ export class LlDyn {
         B.terminate(`ret ${dummy}`);
         B.startBlock(lk);
     }
+    /** A capsule boxed from this class by this program carries the class's
+     * key constant itself: return its instance (+1) without comparing names
+     * or calling the capsule's retain adapter. Other values continue. */
+    exactClassCapsule(B, t) {
+        const key = typeKey(t);
+        const present = B.tmp();
+        const inspect = B.newLabel("dc.exact.inspect");
+        const capsule = B.newLabel("dc.exact.capsule");
+        const hit = B.newLabel("dc.exact.hit");
+        const miss = B.newLabel("dc.exact.miss");
+        B.line(`${present} = icmp ne ptr %d, null`);
+        B.condBr(present, inspect, miss);
+        B.startBlock(inspect);
+        const typed = B.tmp();
+        B.line(`${typed} = icmp eq i32 ${this.kindOf(B, "%d")}, ${DYN_KIND.TYPED_REF}`);
+        B.condBr(typed, capsule, miss);
+        B.startBlock(capsule);
+        const keySlot = B.tmp(), keyPtr = B.tmp(), same = B.tmp();
+        B.line(`${keySlot} = getelementptr inbounds i8, ptr %d, i64 ${this.abiOffset(40, 28)} ; ->v.typed_ref.type_key`);
+        B.line(`${keyPtr} = load ptr, ptr ${keySlot}`);
+        B.line(`${same} = icmp eq ptr ${keyPtr}, ${this.host.cstr(key)}`);
+        B.condBr(same, hit, miss);
+        B.startBlock(hit);
+        const object = this.payloadOf(B, "%d", "ptr");
+        const retained = B.tmp();
+        B.line(`${retained} = call ptr ${vAdapters(this.host, t).retain}(ptr ${object})`);
+        B.terminate(`ret ptr ${retained}`);
+        B.startBlock(miss);
+    }
     /* ── dynMatchHelper (walkers.ts, ported) ──────────────────────── */
     /** Native subclass capsules also satisfy a checked base-class slot.
      * Class layouts share their base prefix, so unboxing retains the same
@@ -404,6 +562,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);
@@ -415,7 +575,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();
@@ -430,7 +590,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}`);
@@ -609,13 +769,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);
                 }
@@ -733,7 +892,9 @@ 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 ───────────────────────────────── */
@@ -863,6 +1024,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";
@@ -890,6 +1053,8 @@ export class LlDyn {
                 B.terminate(`ret ptr ${error}`);
                 B.startBlock(next);
             }
+            if (isDynTypedRefType(t))
+                this.exactClassCapsule(B, t);
             const matched = this.typedRefMatches(B, t);
             const lRef = B.newLabel("dc.tr");
             const lNext = B.newLabel("dc.nt");
@@ -912,7 +1077,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)`);
@@ -928,6 +1093,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");
@@ -938,7 +1110,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();
@@ -976,7 +1148,7 @@ export class LlDyn {
                         ? [
                             ...shape.fields.map((field, index) => ({
                                 index: index + 1,
-                                type: llFieldType(field.type),
+                                type: llFieldType(field.type, host.inlineUnions.record(field.type)),
                                 name: field.name,
                             })),
                             ...(shape.indexValue
@@ -1015,6 +1187,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);
@@ -1246,19 +1424,30 @@ export class LlDyn {
                     B.line(`${ip} = getelementptr inbounds %ScrDynPath, ptr ${pathSlot}, i64 0, i32 2`);
                     B.line(`store ${host.sizeType} 0, ptr ${ip}`);
                 };
+                // An inline union field copies the checked box's bits; the caller
+                // releases the box afterwards.
                 const storeInto = (fieldName, ft, value) => {
                     const idx = fieldIndex.get(fieldName);
                     const p = B.tmp();
                     B.line(`${p} = getelementptr inbounds %${struct}, ptr %r0, i64 0, i32 ${idx} ; .${llvmCommentText(fieldName)}`);
-                    if (llFieldType(ft) === "i8") {
+                    const fieldTy = llFieldType(ft, host.inlineUnions.record(ft));
+                    if (fieldTy === INLINE_UNION_FIELD) {
+                        const { tag, bits } = unionBoxBits(B, value, host.unionNoneRef());
+                        storeInlineUnion(B, p, tag, bits);
+                    }
+                    else if (fieldTy === "i8") {
                         const z = B.tmp();
                         B.line(`${z} = zext i1 ${value} to i8`);
                         B.line(`store i8 ${z}, ptr ${p}`);
                     }
                     else {
-                        B.line(`store ${llFieldType(ft)} ${value}, ptr ${p}`);
+                        B.line(`store ${fieldTy} ${value}, ptr ${p}`);
                     }
                 };
+                const releaseInline = (ft, value) => {
+                    if (host.inlineUnions.record(ft))
+                        B.line(`call void ${releaseSym(host, ft)}(ptr ${value})`);
+                };
                 // Tuple targets: a JSON ARRAY of exactly the arity.
                 if (shape.tuple) {
                     const byIndex = [...shape.fields].sort((a, b) => Number(a.name) - Number(b.name));
@@ -1275,6 +1464,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}`);
@@ -1282,6 +1473,7 @@ export class LlDyn {
                         const v = B.tmp();
                         B.line(`${v} = call ${this.valTy(f.type)} @${this.dynCheckHelper(f.type, preserveRefs)}(ptr ${e}, ptr ${pathSlot})`);
                         storeInto(f.name, f.type, v);
+                        releaseInline(f.type, v);
                         this.pendingBail(B, "dct", releaseR, "ptr null");
                     });
                     B.terminate(`ret ptr %r0`);
@@ -1317,24 +1509,29 @@ 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", releaseR, "ptr null");
+                    this.pendingBail(B, "dcr", () => {
+                        releaseInline(f.type, value);
+                        releaseR();
+                    }, "ptr null");
                     if (f.type.kind === "union") {
                         const stored = this.presenceOf(B, "%d", f.name, f.type, value);
                         if (stored !== value)
                             storeInto(f.name, f.type, stored);
                     }
+                    releaseInline(f.type, value);
                 }
                 // Index-signature shapes CAPTURE undeclared keys into the
                 // overflow map.
@@ -1409,6 +1606,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`);
@@ -1427,7 +1626,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);
@@ -1514,7 +1713,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)`);
@@ -1533,7 +1732,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}`);
@@ -1548,7 +1747,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();
@@ -1691,7 +1890,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) ─────────────────────────── */
@@ -1809,6 +2010,10 @@ export class LlDyn {
                 const keyLit = host.cstr(typeKey(t));
                 const r = B.tmp();
                 B.line(`${r} = call ptr ${typedRefConstructor(host, t)}(ptr %v, ptr ${rc.retain}, ptr ${rc.release}, ptr ${keyLit}, ${host.sizeType} ${Buffer.byteLength(typeKey(t), "utf8")}, ptr @${adapter.snapshot}, ptr ${adapter.commit})`);
+                // The same live view as a direct box: class members for `in` and
+                // the class name for inspection.
+                for (const line of bindLiveArrayOps(host, adapter, r))
+                    B.line(line);
                 B.terminate(`ret ptr ${r}`);
                 break;
             }
@@ -1846,9 +2051,14 @@ export class LlDyn {
                 const loadFieldOf = (fname, ft) => {
                     const p = B.tmp();
                     B.line(`${p} = getelementptr inbounds %${struct}, ptr %v, i64 0, i32 ${fieldIndex.get(fname)} ; .${llvmCommentText(fname)}`);
+                    // An inline union field lends a private stack box (ABSENT kept).
+                    if (host.inlineUnions.record(ft)) {
+                        const { tag, bits } = loadInlineUnion(B, p);
+                        return stackUnionBox(B, host.sizeType, tag, bits);
+                    }
                     const raw = B.tmp();
-                    B.line(`${raw} = load ${llFieldType(ft)}, ptr ${p}`);
-                    if (llFieldType(ft) !== "i8")
+                    B.line(`${raw} = load ${llFieldType(ft, false)}, ptr ${p}`);
+                    if (llFieldType(ft, false) !== "i8")
                         return raw;
                     const b = B.tmp();
                     B.line(`${b} = trunc i8 ${raw} to i1`);
@@ -1885,8 +2095,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`,
@@ -1921,6 +2130,12 @@ export class LlDyn {
                         B.startBlock(lSkip);
                     }
                 }
+                // 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)) {
+                    host.declare(`declare void @scr_dyn_dirent_finish(ptr)`);
+                    B.line(`call void @scr_dyn_dirent_finish(ptr ${d})`);
+                }
                 if (shape.indexValue) {
                     const iv = shape.indexValue;
                     host.declare(`declare ptr @scr_map_keys_js_order(ptr)`);
@@ -2309,10 +2524,10 @@ export class LlDyn {
             B.br(done);
             B.startBlock(labels.get(DYN_KIND.TYPED_REF));
             {
-                host.declare(`declare ptr @scr_dyn_typed_ref_materialize(ptr)`);
+                host.declare(`declare ptr @scr_dyn_typed_ref_string_view(ptr)`);
                 host.declare(`declare void @scr_dyn_release_v(ptr)`);
                 const materialized = B.tmp();
-                B.line(`${materialized} = call ptr @scr_dyn_typed_ref_materialize(ptr %d)`);
+                B.line(`${materialized} = call ptr @scr_dyn_typed_ref_string_view(ptr %d)`);
                 B.line(`call void @sc_ds_buf(ptr %b, ptr ${materialized})`);
                 B.line(`call void @scr_dyn_release_v(ptr ${materialized})`);
                 B.br(done);
@@ -3039,7 +3254,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);
@@ -3078,7 +3293,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");
@@ -3331,7 +3546,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}`);