@elaraai/east 1.0.76 → 1.0.78

package/dist/src/serialization/beast2/v4/type-table.js

@@ -3,15 +3,41 @@
  * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
  */
 /**
- * Beast2 v2 flat type table encoder and decoder.
+ * Beast2 flat type table — encoder and decoder.
  *
- * The type table is a flat array where each unique sub-type is defined once
- * and referenced by varint index. Tag bytes serve as direct array indices
- * into dispatch tables for zero-branch decoding.
+ * The type table is a flat array in which each distinct type is one entry,
+ * referenced by varint index; tag bytes double as indices into the decoder's
+ * dispatch table. The v4 container writes it as its first section and the v5
+ * container reuses it verbatim as the structural type section.
  *
- * See devdocs/BEAST2.md for the format specification.
+ * **The table is canonical** (#770): a pure function of the type, so the same
+ * type writes the same bytes in every runtime (east-c's `type_table.c` applies
+ * the same rules, and east-py encodes through it) and whether the type was
+ * built in code or read back off the wire. e3 content-addresses beast2 bytes,
+ * so anything less puts one value under several hashes. The rules, as
+ * {@link TypeTableBuilder} applies them:
+ *
+ * - Entries are committed in a post-order walk over the type in declaration
+ *   order: Struct fields as declared, Variant cases as sorted, Function inputs
+ *   then output, Dict key then value. A child therefore sits at a lower index
+ *   than its parent, which the decoders rely on.
+ * - A Recursive wrapper takes its index before its body is walked, so the
+ *   body's self-references name that index.
+ * - An entry whose bytes (tag + parameters) are already in the table is not
+ *   written again. Two occurrences of one type — inside or outside a
+ *   recursive wrapper's body, as an `EastType` or as an `EastTypeValue`, as
+ *   one object or as many — are one entry.
+ * - Two Recursive wrappers are one entry when {@link isTypeValueEqual} says
+ *   so. A wrapper's id is a runtime artefact (a type id in one process, a
+ *   table index off the wire) and is not written, so wrappers compare up to
+ *   their naming.
+ *
+ * Nothing here constructs an `EastType`. Type ids are serialized into IR, so
+ * an encode must not shift the ids of the types built after it.
+ *
+ * See v4/SPEC.md for the entry grammar and v5/SPEC.md for the type section.
  */
-import { toEastTypeValue } from "../../../type_of_type.js";
+import { toEastTypeValue, isTypeValueEqual } from "../../../type_of_type.js";
 import { getTypeId } from "../../../types.js";
 import { isVariant, variant } from "../../../containers/variant.js";
 import { BufferWriter, BufferReader } from "../../binary-utils.js";
@@ -45,313 +71,240 @@ const TAG_FOR_TYPE = {
     Function: TAG_FUNCTION, AsyncFunction: TAG_ASYNC_FUNCTION, Recursive: TAG_RECURSIVE,
 };
 /**
- * Builds a flat type table from types. Handles both EastType (which has
- * recursive wrappers with .node) and EastTypeValue (which has depth-based
- * Recursive(N) — no inner pointer, so cannot be recursive root).
+ * Builds the canonical flat type table of one or more types (see the module
+ * comment for the rules). Accepts `EastType` (converted with
+ * {@link toEastTypeValue}, which allocates no type) and `EastTypeValue`.
  *
  * Usage:
  *   const builder = new TypeTableBuilder();
  *   const rootIdx = builder.add(myType);           // EastType or EastTypeValue
- *   builder.addETV(someIRTypeAnnotation);           // EastTypeValue from IR
+ *   builder.add(someIRTypeAnnotation);              // a later type shares entries
  *   writeTypeTableSection(rootIdx, builder.entries, writer);
  */
 export class TypeTableBuilder {
     entries = [];
-    /** EastType pointer → table index */
-    etMap = new Map();
-    /** EastTypeValue object → table index (identity-based) */
-    etvMap = new Map();
-    /** type_id → table index (for cross-object lookup when identity fails) */
-    tidMap = new Map();
-    /** Recursive wrapper source ID (bigint) → table index */
-    recIdMap = new Map();
-    /** Get the type_id → index map (for IR type substitution). */
-    getIndexMap() {
-        return this.tidMap;
-    }
-    /** Create a shallow clone with the same entries and index maps. */
+    /** Entry bytes (tag + parameters) → index: the same bytes are the same wire node. */
+    byContent = new Map();
+    /** Type object (EastType or EastTypeValue) → index: a memo over the walk. */
+    byObject = new Map();
+    /** type_id → index, for the values `toEastTypeValue` stamps. */
+    byTid = new Map();
+    /** Recursive wrapper id → the wrapper's index, for every wrapper added. */
+    byWrapperId = new Map();
+    /** Committed wrappers, deduplicated structurally. */
+    wrappers = [];
+    /** Wrappers whose bodies are being walked, innermost last. */
+    open = [];
+    /** Create a copy with the same entries and lookups (the v4 encoder extends a
+     *  cached root closure per value). */
     clone() {
         const c = new TypeTableBuilder();
         for (const e of this.entries)
             c.entries.push(e);
-        for (const [k, v] of this.etMap)
-            c.etMap.set(k, v);
-        for (const [k, v] of this.etvMap)
-            c.etvMap.set(k, v);
-        for (const [k, v] of this.tidMap)
-            c.tidMap.set(k, v);
-        for (const [k, v] of this.recIdMap)
-            c.recIdMap.set(k, v);
+        for (const [k, v] of this.byContent)
+            c.byContent.set(k, v);
+        for (const [k, v] of this.byObject)
+            c.byObject.set(k, v);
+        for (const [k, v] of this.byTid)
+            c.byTid.set(k, v);
+        for (const [k, v] of this.byWrapperId)
+            c.byWrapperId.set(k, v);
+        for (const w of this.wrappers)
+            c.wrappers.push(w);
+        for (const w of this.open)
+            c.open.push(w);
         return c;
     }
-    /** Add a type. Accepts both EastType and EastTypeValue. */
+    /** Add a type and return its index; a type already in the table returns its
+     *  existing index and writes nothing. Accepts both EastType and EastTypeValue. */
     add(type) {
-        if (isVariant(type)) {
-            return this.visitETV(type);
-        }
-        return this.visitET(type);
+        const memo = this.byObject.get(type);
+        if (memo !== undefined)
+            return memo;
+        const etv = isVariant(type) ? type : toEastTypeValue(type);
+        const idx = this.visit(etv);
+        this.byObject.set(type, idx);
+        return idx;
     }
     /** Add an EastTypeValue (for IR type annotations). */
     addETV(etv) {
-        return this.visitETV(etv);
+        return this.add(etv);
     }
-    /** Look up an EastTypeValue's table index by identity, type_id, or recursive ref ID. */
+    /** Look up a type's index without adding it: by object, by type_id, or — for
+     *  a Recursive ref or wrapper — by the wrapper's id. */
     indexOf(etv) {
-        const idx = this.etvMap.get(etv);
-        if (idx !== undefined)
-            return idx;
+        const idx = this.lookup(etv);
+        if (idx === undefined)
+            throw new Error(`Type not in table: ${etv.type}`);
+        return idx;
+    }
+    /** Whether {@link indexOf} would find the type. `add` is idempotent, so a
+     *  miss here is never a reason not to add. */
+    has(etv) {
+        return this.lookup(etv) !== undefined;
+    }
+    lookup(etv) {
+        const memo = this.byObject.get(etv);
+        if (memo !== undefined)
+            return memo;
         const tid = getTypeId(etv);
         if (tid !== undefined) {
-            const tidIdx = this.tidMap.get(tid);
-            if (tidIdx !== undefined)
-                return tidIdx;
+            const known = this.byTid.get(tid);
+            if (known !== undefined)
+                return known;
         }
-        // Recursive ref: look up by the ref's bigint ID
-        if (etv.type === "Recursive" && etv.value?.type === "ref") {
-            const refId = etv.value.value;
-            const recIdx = this.recIdMap.get(refId);
-            if (recIdx !== undefined)
-                return recIdx;
+        if (etv.type === "Recursive") {
+            const id = recursiveId(etv.value);
+            return this.openWrapper(id) ?? this.byWrapperId.get(id);
         }
-        throw new Error(`Type not in table: ${etv.type}`);
+        return undefined;
     }
-    /** Check if an EastTypeValue is in the table (by identity, type_id, or recursive ref ID). */
-    has(etv) {
-        if (this.etvMap.has(etv))
-            return true;
+    // ── The walk ────────────────────────────────────────────────────────
+    visit(etv) {
+        const memo = this.byObject.get(etv);
+        if (memo !== undefined)
+            return memo;
         const tid = getTypeId(etv);
-        if (tid !== undefined && this.tidMap.has(tid))
-            return true;
-        // Recursive ref: check by bigint ID
-        if (etv.type === "Recursive" && etv.value?.type === "ref") {
-            return this.recIdMap.has(etv.value.value);
-        }
-        return false;
-    }
-    // ── EastType walker (handles Recursive wrappers) ────────────────────
-    visitET(type) {
-        const existing = this.etMap.get(type);
-        if (existing !== undefined)
-            return existing;
-        const t = type;
-        if (t.type === "Recursive") {
-            // Allocate index BEFORE recursing — self-references find this index
-            const idx = this.allocate();
-            this.etMap.set(type, idx);
-            // Register type_id so ETV path can find this entry via tidMap
-            const recTid = getTypeId(type);
-            if (recTid !== undefined) {
-                this.tidMap.set(recTid, idx);
-                this.recIdMap.set(BigInt(recTid), idx);
+        if (tid !== undefined) {
+            const known = this.byTid.get(tid);
+            if (known !== undefined) {
+                this.byObject.set(etv, known);
+                return known;
             }
-            const innerIdx = this.visitET(t.node);
-            this.entries[idx] = { tag: TAG_RECURSIVE, params: varint(innerIdx) };
-            return idx;
-        }
-        // Check EastTypeValue identity cache for dedup
-        const etv = toEastTypeValue(type);
-        const etvIdx = this.etvMap.get(etv);
-        if (etvIdx !== undefined) {
-            this.etMap.set(type, etvIdx);
-            return etvIdx;
-        }
-        // Primitives
-        if (t.type === "Never" || t.type === "Null" || t.type === "Boolean" ||
-            t.type === "Integer" || t.type === "Float" || t.type === "String" ||
-            t.type === "DateTime" || t.type === "Blob") {
-            return this.emitPrimitive(type, etv, t.type);
-        }
-        // Single-parameter containers
-        if (t.type === "Array" || t.type === "Ref") {
-            const elemIdx = this.visitET(t.value);
-            return this.emit(type, etv, TAG_FOR_TYPE[t.type], varint(elemIdx));
         }
-        if (t.type === "Set") {
-            const elemIdx = this.visitET(t.key);
-            return this.emit(type, etv, TAG_SET, varint(elemIdx));
-        }
-        if (t.type === "Vector" || t.type === "Matrix") {
-            const elemIdx = this.visitET(t.element);
-            return this.emit(type, etv, TAG_FOR_TYPE[t.type], varint(elemIdx));
-        }
-        if (t.type === "Dict") {
-            const ki = this.visitET(t.key);
-            const vi = this.visitET(t.value);
-            return this.emit(type, etv, TAG_DICT, varints(ki, vi));
-        }
-        if (t.type === "Struct") {
-            return this.emitNamedFields(type, etv, TAG_STRUCT, Object.keys(t.fields), (name) => this.visitET(t.fields[name]));
-        }
-        if (t.type === "Variant") {
-            return this.emitNamedFields(type, etv, TAG_VARIANT, Object.keys(t.cases), (name) => this.visitET(t.cases[name]));
-        }
-        if (t.type === "Function" || t.type === "AsyncFunction") {
-            return this.emitFunc(type, etv, t.type, t.inputs.map((i) => this.visitET(i)), this.visitET(t.output));
-        }
-        throw new Error(`Unknown EastType: ${t.type}`);
+        const idx = this.visitNode(etv);
+        this.byObject.set(etv, idx);
+        if (tid !== undefined)
+            this.byTid.set(tid, idx);
+        return idx;
     }
-    // ── EastTypeValue walker (for lazily-discovered types) ──────────────
-    visitETV(etv) {
-        const existing = this.etvMap.get(etv);
-        if (existing !== undefined)
-            return existing;
-        // Check type_id for cross-path dedup (ET path may have already added this type)
-        const etvTid = getTypeId(etv);
-        if (etvTid !== undefined) {
-            const tidIdx = this.tidMap.get(etvTid);
-            if (tidIdx !== undefined)
-                return tidIdx;
-        }
-        const caseName = etv.type;
-        if (caseName === "Recursive") {
-            const inner = etv.value;
-            if (inner.type === "wrapper") {
-                // Recursive wrapper: allocate first, recurse into inner, fill.
-                const idx = this.allocate();
-                this.entries[idx] = { tag: TAG_RECURSIVE, params: EMPTY };
-                this.registerETV(etv, idx);
-                // Register wrapper's bigint ID so refs can find it
-                const wrapperId = inner.value.id;
-                this.recIdMap.set(wrapperId, idx);
-                const innerIdx = this.visitETV(inner.value.inner);
-                this.entries[idx] = { tag: TAG_RECURSIVE, params: varint(innerIdx) };
-                return idx;
+    /** Commit the entry of a node after its children (post-order). */
+    visitNode(etv) {
+        switch (etv.type) {
+            case "Never":
+            case "Null":
+            case "Boolean":
+            case "Integer":
+            case "Float":
+            case "String":
+            case "DateTime":
+            case "Blob":
+                return this.commit(TAG_FOR_TYPE[etv.type], EMPTY);
+            case "Array":
+            case "Set":
+            case "Ref":
+            case "Vector":
+            case "Matrix":
+                return this.commit(TAG_FOR_TYPE[etv.type], varint(this.visit(etv.value)));
+            case "Dict": {
+                const ki = this.visit(etv.value.key);
+                const vi = this.visit(etv.value.value);
+                return this.commit(TAG_DICT, varints(ki, vi));
             }
-            // Self-reference Recursive(ref) — find existing wrapper by ID or type_id.
-            const refId = etv.value.value;
-            const recIdx = this.recIdMap.get(refId);
-            if (recIdx !== undefined)
-                return recIdx;
-            const tid = getTypeId(etv);
-            if (tid !== undefined) {
-                const tidIdx = this.tidMap.get(tid);
-                if (tidIdx !== undefined)
-                    return tidIdx;
+            case "Struct":
+            case "Variant": {
+                const members = etv.value;
+                const indices = members.map(m => this.visit(m.type));
+                const w = new BufferWriter();
+                w.writeVarint(members.length);
+                for (let i = 0; i < members.length; i++) {
+                    w.writeStringUtf8Varint(members[i].name);
+                    w.writeVarint(indices[i]);
+                }
+                return this.commit(TAG_FOR_TYPE[etv.type], w.toUint8Array());
             }
-            // Scan for wrapper by tag
-            for (let i = 0; i < this.entries.length; i++) {
-                if (this.entries[i]?.tag === TAG_RECURSIVE)
-                    return i;
+            case "Function":
+            case "AsyncFunction": {
+                const inputs = etv.value.inputs.map(i => this.visit(i));
+                const output = this.visit(etv.value.output);
+                const w = new BufferWriter();
+                w.writeVarint(inputs.length);
+                for (const ii of inputs)
+                    w.writeVarint(ii);
+                w.writeVarint(output);
+                return this.commit(TAG_FOR_TYPE[etv.type], w.toUint8Array());
             }
-            throw new Error("Recursive self-reference but no wrapper in table");
-        }
-        // Primitives
-        if (caseName === "Never" || caseName === "Null" || caseName === "Boolean" ||
-            caseName === "Integer" || caseName === "Float" || caseName === "String" ||
-            caseName === "DateTime" || caseName === "Blob") {
-            const idx = this.allocate();
-            this.registerETV(etv, idx);
-            this.entries[idx] = { tag: TAG_FOR_TYPE[caseName], params: EMPTY };
-            return idx;
-        }
-        // Single-parameter containers
-        if (caseName === "Array" || caseName === "Set" || caseName === "Ref" ||
-            caseName === "Vector" || caseName === "Matrix") {
-            const elemIdx = this.visitETV(etv.value);
-            const idx = this.allocate();
-            this.registerETV(etv, idx);
-            this.entries[idx] = { tag: TAG_FOR_TYPE[caseName], params: varint(elemIdx) };
-            return idx;
-        }
-        if (caseName === "Dict") {
-            const ki = this.visitETV(etv.value.key);
-            const vi = this.visitETV(etv.value.value);
-            const idx = this.allocate();
-            this.registerETV(etv, idx);
-            this.entries[idx] = { tag: TAG_DICT, params: varints(ki, vi) };
-            return idx;
-        }
-        if (caseName === "Struct") {
-            const fields = etv.value;
-            const indices = fields.map(f => this.visitETV(f.type));
-            const idx = this.emitNamedFieldsETV(etv, TAG_STRUCT, fields.map(f => f.name), indices);
-            return idx;
-        }
-        if (caseName === "Variant") {
-            const cases = etv.value;
-            const indices = cases.map(c => this.visitETV(c.type));
-            const idx = this.emitNamedFieldsETV(etv, TAG_VARIANT, cases.map(c => c.name), indices);
-            return idx;
-        }
-        if (caseName === "Function" || caseName === "AsyncFunction") {
-            const inputs = etv.value.inputs;
-            const inputIndices = inputs.map(i => this.visitETV(i));
-            const outputIdx = this.visitETV(etv.value.output);
-            const idx = this.emitFuncETV(etv, caseName, inputIndices, outputIdx);
-            return idx;
+            case "Recursive":
+                return this.visitRecursive(etv.value, etv);
+            default:
+                throw new Error(`Unknown EastTypeValue case: ${etv.type}`);
         }
-        throw new Error(`Unknown EastTypeValue case: ${caseName}`);
     }
-    // ── Helpers ─────────────────────────────────────────────────────────
-    allocate() {
+    visitRecursive(payload, etv) {
+        const id = recursiveId(payload);
+        // A self-reference — a ref, or the wrapper spelled out again inside its
+        // own body — names the wrapper being walked.
+        const open = this.openWrapper(id);
+        if (open !== undefined)
+            return open;
+        if (payload.type === "ref") {
+            // A ref outside its wrapper's body stands for the whole recursive type.
+            const committed = this.byWrapperId.get(id);
+            if (committed !== undefined)
+                return committed;
+            throw new Error(`beast2 type table: Recursive ref(${id}) is bound by no wrapper`);
+        }
+        // The wrapper's entry exists only once its body does, so a repeat is found
+        // by comparing types, not bytes — up to the naming of wrappers.
+        for (const w of this.wrappers) {
+            if (isTypeValueEqual(w.etv, etv)) {
+                // Bind THIS id to the shared entry too. One recursive type reaches a
+                // table under different wrapper ids — an interned type id in this
+                // process, a table index off the wire — and the id is a runtime
+                // artefact that is never written. Binding only the first wrapper's
+                // would leave a later bare `ref` under the second id bound by no
+                // wrapper, which is an encode failure, not a naming difference.
+                this.byWrapperId.set(id, w.idx);
+                return w.idx;
+            }
+        }
+        // Take the index before the body so its self-references resolve.
         const idx = this.entries.length;
-        this.entries.push(null); // placeholder, must be filled
+        this.entries.push(null);
+        this.open.push({ id, idx });
+        let innerIdx;
+        try {
+            innerIdx = this.visit(payload.value.inner);
+        }
+        finally {
+            this.open.pop();
+        }
+        this.entries[idx] = { tag: TAG_RECURSIVE, params: varint(innerIdx) };
+        this.wrappers.push({ etv, idx });
+        this.byWrapperId.set(id, idx);
         return idx;
     }
-    /** Register an EastTypeValue in both identity and type_id maps. */
-    registerETV(etv, idx) {
-        this.etvMap.set(etv, idx);
-        const tid = getTypeId(etv);
-        if (tid !== undefined)
-            this.tidMap.set(tid, idx);
-    }
-    emitPrimitive(et, etv, typeName) {
-        const idx = this.allocate();
-        this.etMap.set(et, idx);
-        this.registerETV(etv, idx);
-        this.entries[idx] = { tag: TAG_FOR_TYPE[typeName], params: EMPTY };
-        return idx;
-    }
-    emit(et, etv, tag, params) {
-        const idx = this.allocate();
-        this.etMap.set(et, idx);
-        this.registerETV(etv, idx);
-        this.entries[idx] = { tag, params };
-        return idx;
-    }
-    emitNamedFields(et, etv, tag, names, resolve) {
-        const indices = names.map(resolve);
-        const w = new BufferWriter();
-        w.writeVarint(names.length);
-        for (let i = 0; i < names.length; i++) {
-            w.writeStringUtf8Varint(names[i]);
-            w.writeVarint(indices[i]);
+    openWrapper(id) {
+        for (let i = this.open.length - 1; i >= 0; i--) {
+            if (this.open[i].id === id)
+                return this.open[i].idx;
         }
-        return this.emit(et, etv, tag, w.toUint8Array());
-    }
-    emitNamedFieldsETV(etv, tag, names, indices) {
-        const w = new BufferWriter();
-        w.writeVarint(names.length);
-        for (let i = 0; i < names.length; i++) {
-            w.writeStringUtf8Varint(names[i]);
-            w.writeVarint(indices[i]);
-        }
-        const idx = this.allocate();
-        this.registerETV(etv, idx);
-        this.entries[idx] = { tag, params: w.toUint8Array() };
-        return idx;
+        return undefined;
     }
-    emitFunc(et, etv, typeName, inputIndices, outputIdx) {
-        const w = new BufferWriter();
-        w.writeVarint(inputIndices.length);
-        for (const ii of inputIndices)
-            w.writeVarint(ii);
-        w.writeVarint(outputIdx);
-        return this.emit(et, etv, TAG_FOR_TYPE[typeName], w.toUint8Array());
-    }
-    emitFuncETV(etv, caseName, inputIndices, outputIdx) {
-        const w = new BufferWriter();
-        w.writeVarint(inputIndices.length);
-        for (const ii of inputIndices)
-            w.writeVarint(ii);
-        w.writeVarint(outputIdx);
-        const idx = this.allocate();
-        this.registerETV(etv, idx);
-        this.entries[idx] = { tag: TAG_FOR_TYPE[caseName], params: w.toUint8Array() };
+    /** Append an entry unless the same bytes are already in the table. */
+    commit(tag, params) {
+        const key = contentKey(tag, params);
+        const existing = this.byContent.get(key);
+        if (existing !== undefined)
+            return existing;
+        const idx = this.entries.length;
+        this.entries.push({ tag, params });
+        this.byContent.set(key, idx);
         return idx;
     }
 }
 const EMPTY = new Uint8Array(0);
+/** The id a `Recursive` payload names — the wrapper's own id, or a ref's. */
+function recursiveId(payload) {
+    return payload.type === "ref" ? payload.value : payload.value.id;
+}
+/** The entry's bytes as a map key (one code unit per byte). */
+function contentKey(tag, params) {
+    let key = String.fromCharCode(tag);
+    for (let i = 0; i < params.length; i++)
+        key += String.fromCharCode(params[i]);
+    return key;
+}
 function varint(value) {
     const w = new BufferWriter();
     w.writeVarint(value);
@@ -457,13 +410,25 @@ function parseTypeTableSectionPayload(payload) {
     // Phase 1: Parse raw entries
     const parsed = new Array(entryCount);
     for (let i = 0; i < entryCount; i++) {
-        parsed[i] = ENTRY_PARSERS[reader.readUint8()](reader);
+        const tag = reader.readUint8();
+        const parse = ENTRY_PARSERS[tag];
+        if (!parse)
+            throw new Error(`Type table entry ${i} has unknown tag 0x${tag.toString(16)}`);
+        parsed[i] = parse(reader);
+        // Every child index names an entry of this table.
+        for (const child of parsed[i].childIndices) {
+            if (child >= entryCount)
+                throw new Error(`Type table entry ${i} references entry ${child} of ${entryCount}`);
+        }
     }
     if (reader.offset !== payload.length) {
         throw new Error(`Type table size mismatch: expected offset ${payload.length}, got ${reader.offset}`);
     }
-    // Phase 2: Reconstruct EastTypeValue tree with depth-based Recursive references
-    const table = reconstructTypes(parsed, rootIdx);
+    if (rootIdx >= entryCount) {
+        throw new Error(`Type table root index ${rootIdx} out of range (${entryCount} entries)`);
+    }
+    // Phase 2: Reconstruct EastTypeValue tree with Recursive wrapper/ref references
+    const table = reconstructTypes(parsed);
     return { rootType: table[rootIdx], typeTable: table };
 }
 /**
@@ -528,7 +493,7 @@ const ENTRY_PARSERS = [
     /* 0x11 */ parseFunc(TAG_ASYNC_FUNCTION),
     /* 0x12 */ parseRecursive,
 ];
-// ─�� Reconstruction: flat table → EastTypeValue with Recursive(depth) ──
+// ── Reconstruction: flat table → EastTypeValue with wrapper/ref recursion ──
 const TAG_TO_CASE = [
     "Null", "String", "Integer", "Float", "Boolean", "DateTime", "Blob", "Never",
     "Variant", "Struct", "Array", "Dict", "Set", "Ref", "Vector", "Matrix",
@@ -547,165 +512,150 @@ const PRIMITIVE_ETV = [
 /**
  * Reconstruct EastTypeValue objects from parsed flat table entries.
  *
- * Recursive entries are converted to proper EastTypeValue trees where
- * self-references use depth-based Recursive(N) — compatible with
- * _decodeCursorFor's typeCtx stack mechanism.
+ * A Recursive entry becomes `wrapper({id, inner})` whose id is its table
+ * index; inside its body a reference back to it is `ref(id)`. The returned
+ * table holds every entry's **closed** form — built in no wrapper's scope, so
+ * it is a complete type wherever it is used (v4 value-table entries name
+ * element types by index).
  *
- * One table index yields exactly **one** object, shared by every reference to
- * it. That is what makes a decoded type round-trip: {@link TypeTableBuilder}
- * dedups EastTypeValues by identity, so re-encoding a decoded value must see
- * the same object wherever the wire table said "same index". Rebuilding a
- * nested recursive type per reference (as this did before) gave `IRType` 25
- * wrapper entries instead of 2 and made TS re-encode a decoded IR program to
- * 5426 bytes where east-c — which interns decoded types — produced the
- * original 1792.
+ * The same entry can be reached from inside a wrapper's body and from outside
+ * it — a canonical table writes `Array<T>` once whether it occurs as `T`'s
+ * child or as another field's type — and the two readings are different
+ * objects: inside, references to `T` are `ref`s; outside, they are the
+ * wrapper. So an object built under a wrapper (one that holds a `ref` to it)
+ * is memoized only for that wrapper's scope, and an object that references no
+ * open wrapper is closed and memoized for good. One table index yields one
+ * closed object, shared by every reference to it, so a decoded type is a
+ * canonical input to {@link TypeTableBuilder} in turn.
+ *
+ * The walk is top-down, so the outside reading of `Array<T>` can be under
+ * construction when `T` — its child, indexed before it — opens and its body
+ * reaches `Array<T>` again. That re-entry is `T`'s own recursion, built as
+ * the inside reading in `T`'s scope; only a cycle with no wrapper in it is
+ * malformed. So entries under construction are tracked per open wrapper
+ * (#773 — east-ui's `TreeView.nodes`, an `Array<Inner>` whose `Inner` has
+ * `children: Array<self>`, under the `UIComponentType` wrapper).
  */
-function reconstructTypes(parsed, _rootIdx) {
-    const table = new Array(parsed.length);
-    // Track which indices are Recursive wrappers and their inner indices
-    const recursiveEntries = new Map(); // wrapper_idx → inner_idx
-    // Wrapper indices whose rebuilt subtree references no *enclosing* wrapper.
-    // Such a wrapper is self-contained, so one object can serve every reference
-    // to it — see the `closed` computation below.
-    const closedWrappers = new Set();
-    // Shallowest depthStack position referenced by the subtree currently under
-    // construction (Infinity = nothing referenced). Read/reset around each
-    // wrapper to decide whether that wrapper escaped its own scope.
-    let minRefPos = Infinity;
-    // First pass: identify all Recursive entries
-    for (let i = 0; i < parsed.length; i++) {
-        if (parsed[i].tag === TAG_RECURSIVE) {
-            recursiveEntries.set(i, parsed[i].childIndices[0]);
-        }
-    }
-    // Build each entry. For non-recursive entries, this is straightforward.
-    // For the inner types of recursive entries, self-references (indices pointing
-    // back to a Recursive wrapper) must be replaced with Recursive(depth).
-    //
-    // We process bottom-up: entries with lower indices are built first (they
-    // have no forward references except through Recursive wrappers).
-    // recursionStack tracks which Recursive wrapper indices are "in scope"
-    // as we build types, so we can compute depth for Recursive(N) references.
-    function build(idx, depthStack) {
-        // If this index is a Recursive wrapper currently being built, emit Recursive(ref(id)).
-        // The id is the table index of the wrapper entry.
-        const stackPos = depthStack.indexOf(idx);
-        if (stackPos !== -1) {
-            if (stackPos < minRefPos)
-                minRefPos = stackPos;
+function reconstructTypes(parsed) {
+    const closed = new Array(parsed.length);
+    // Open wrapper indices, outermost first; `scopes[i]` memoizes what was
+    // built under `stack[i]` and reaches an open wrapper.
+    const stack = [];
+    const scopes = [];
+    // Non-wrapper entries under construction since the innermost open wrapper
+    // was pushed (`building[0]` for none): a cycle through them has no wrapper
+    // to close it and is malformed. Reaching one from inside a wrapper opened
+    // later is that wrapper's recursion, so each wrapper starts a fresh set.
+    const building = [new Set()];
+    // Shallowest stack position referenced by the subtree under construction
+    // (Infinity = nothing referenced).
+    let minRef = Infinity;
+    function build(idx) {
+        const pos = stack.indexOf(idx);
+        if (pos !== -1) {
+            if (pos < minRef)
+                minRef = pos;
             return variant("Recursive", variant("ref", BigInt(idx)));
         }
-        // If already built, reuse. A Recursive wrapper only qualifies once it is
-        // known to be closed: an *open* wrapper's `ref`s resolve against the scope
-        // it was built in, so it cannot be shared with a different scope.
-        if (table[idx] !== undefined && (!recursiveEntries.has(idx) || closedWrappers.has(idx))) {
-            return table[idx];
+        const done = closed[idx];
+        if (done !== undefined)
+            return done;
+        if (scopes.length > 0) {
+            const scoped = scopes[scopes.length - 1].get(idx);
+            if (scoped !== undefined) {
+                if (scoped.minRef < minRef)
+                    minRef = scoped.minRef;
+                return scoped.value;
+            }
         }
         const entry = parsed[idx];
-        // Recursive wrapper: push wrapper index on stack, recurse into inner compound.
-        // toEastTypeValue pushes BOTH the RecursiveType wrapper and the inner compound
-        // type onto its stack, so we mirror that here for matching depth values.
+        if (entry.tag <= TAG_NEVER) {
+            const primitive = PRIMITIVE_ETV[entry.tag];
+            closed[idx] = primitive;
+            return primitive;
+        }
+        const depth = stack.length;
+        const outerMinRef = minRef;
+        minRef = Infinity;
+        let result;
         if (entry.tag === TAG_RECURSIVE) {
-            const innerIdx = entry.childIndices[0];
-            const base = depthStack.length; // the position this wrapper occupies
-            const outerMinRefPos = minRefPos;
-            minRefPos = Infinity;
-            depthStack.push(idx); // Push wrapper — stays on stack for depth counting
-            const inner = buildCompound(innerIdx, depthStack, null);
-            depthStack.pop();
-            // Closed ⇔ nothing under this wrapper referenced a wrapper above it.
-            // East guarantees this for every type it can construct (RecursiveType
-            // rejects SCC > 1), so this is the universal case; the check only keeps
-            // a hand-crafted mutually-recursive table from sharing a scoped object.
-            const closed = minRefPos >= base;
-            minRefPos = closed ? outerMinRefPos : Math.min(outerMinRefPos, minRefPos);
-            const wrapped = variant("Recursive", variant("wrapper", { id: BigInt(idx), inner }));
-            table[idx] = wrapped;
-            if (closed)
-                closedWrappers.add(idx);
-            return wrapped;
+            stack.push(idx);
+            scopes.push(new Map());
+            building.push(new Set());
+            let inner;
+            try {
+                inner = build(entry.childIndices[0]);
+            }
+            finally {
+                stack.pop();
+                scopes.pop();
+                building.pop();
+            }
+            result = variant("Recursive", variant("wrapper", { id: BigInt(idx), inner }));
         }
-        // Primitives
-        if (entry.tag <= TAG_NEVER) {
-            table[idx] = PRIMITIVE_ETV[entry.tag];
-            return table[idx];
+        else {
+            const open = building[building.length - 1];
+            if (open.has(idx)) {
+                throw new Error(`Type table entry ${idx} refers to itself without a Recursive wrapper`);
+            }
+            open.add(idx);
+            try {
+                result = buildCompound(entry);
+            }
+            finally {
+                open.delete(idx);
+            }
+        }
+        const mine = minRef;
+        // Closed ⇔ nothing under this entry referenced a wrapper open above it
+        // (a wrapper's own self-references sit at `depth`, so it stays closed).
+        if (mine >= depth) {
+            closed[idx] = result;
         }
-        const result = buildCompound(idx, depthStack, null);
-        table[idx] = result;
+        else {
+            scopes[scopes.length - 1].set(idx, { value: result, minRef: mine });
+        }
+        minRef = Math.min(outerMinRef, mine);
         return result;
     }
-    /**
-     * Build a compound type entry, pushing to the depth stack.
-     * If recursiveOwner is set, self-references to that index (the Recursive
-     * wrapper) will be found on the stack at the position where this compound
-     * type is pushed.
-     */
-    function buildCompound(idx, depthStack, recursiveOwner) {
-        const entry = parsed[idx];
-        // Push: the index that self-references should find.
-        // If this compound is the inner type of a Recursive wrapper, push the
-        // wrapper's index so Recursive(depth) resolves to it.
-        const stackEntry = recursiveOwner ?? idx;
-        depthStack.push(stackEntry);
-        let result;
+    function buildCompound(entry) {
         switch (entry.tag) {
-            case TAG_VARIANT: {
-                const cases = entry.names.map((name, i) => ({
-                    name, type: build(entry.childIndices[i], depthStack),
-                }));
-                result = variant("Variant", cases);
-                break;
-            }
+            case TAG_VARIANT:
             case TAG_STRUCT: {
-                const fields = entry.names.map((name, i) => ({
-                    name, type: build(entry.childIndices[i], depthStack),
-                }));
-                result = variant("Struct", fields);
-                break;
+                const members = entry.names.map((name, i) => ({ name, type: build(entry.childIndices[i]) }));
+                return variant(TAG_TO_CASE[entry.tag], members);
             }
             case TAG_ARRAY:
-                result = variant("Array", build(entry.childIndices[0], depthStack));
-                break;
-            case TAG_DICT:
-                result = variant("Dict", {
-                    key: build(entry.childIndices[0], depthStack),
-                    value: build(entry.childIndices[1], depthStack),
-                });
-                break;
             case TAG_SET:
-                result = variant("Set", build(entry.childIndices[0], depthStack));
-                break;
             case TAG_REF:
-                result = variant("Ref", build(entry.childIndices[0], depthStack));
-                break;
             case TAG_VECTOR:
-                result = variant("Vector", build(entry.childIndices[0], depthStack));
-                break;
             case TAG_MATRIX:
-                result = variant("Matrix", build(entry.childIndices[0], depthStack));
-                break;
+                return variant(TAG_TO_CASE[entry.tag], build(entry.childIndices[0]));
+            case TAG_DICT: {
+                const key = build(entry.childIndices[0]);
+                const value = build(entry.childIndices[1]);
+                return variant("Dict", { key, value });
+            }
             case TAG_FUNCTION:
             case TAG_ASYNC_FUNCTION: {
                 const n = entry.childIndices.length - 1;
                 const inputs = [];
                 for (let i = 0; i < n; i++)
-                    inputs.push(build(entry.childIndices[i], depthStack));
-                const output = build(entry.childIndices[n], depthStack);
-                result = variant(TAG_TO_CASE[entry.tag], { inputs, output });
-                break;
+                    inputs.push(build(entry.childIndices[i]));
+                const output = build(entry.childIndices[n]);
+                return variant(TAG_TO_CASE[entry.tag], { inputs, output });
             }
             default:
                 throw new Error(`Unexpected compound tag 0x${entry.tag.toString(16)}`);
         }
-        depthStack.pop();
-        return result;
     }
-    // Build ALL entries (not just root-reachable). Extra entries from IR
-    // capture types are needed for function IR type restoration during decode.
+    // Build ALL entries (not just root-reachable) in their closed form. Extra
+    // entries from IR capture types are needed for function IR type restoration
+    // during v4 decode.
     for (let i = 0; i < parsed.length; i++) {
-        if (table[i] === undefined)
-            build(i, []);
+        if (closed[i] === undefined)
+            build(i);
     }
-    return table;
+    return closed;
 }
 //# sourceMappingURL=type-table.js.map