@astrale-os/kernel-core 0.4.1

package/dist/domain/deserialize/deserialize.js

@@ -0,0 +1,863 @@
+/**
+ * deserializeDomainFromGraph — inverse of `materialize()`.
+ *
+ * The Domain node carries the full SchemaIR as a JSON blob (`schema`
+ * property, written at serialize time). That blob is the single source of
+ * truth for types, inheritance, imports, and the IR passthrough — no walk
+ * over Class/Interface nodes is needed for any of it.
+ *
+ * The graph is still read for:
+ *   - Class/Interface self node PATHS (layout may differ from defaultLayout
+ *     under a custom mount, so we pick up the real absolute paths).
+ *   - Per-type `propertyIndex` blobs — denormalized PropertyMapping snapshot
+ *     that lets us reconstruct DomainPropertyIndex without loading foreign
+ *     domains.
+ *   - Function nodes + `method_of` edges — the source of truth for
+ *     cross-domain method inheritance (local methods can also be read here
+ *     rather than duplicating resolution logic from IR).
+ *   - Core (instance) nodes — not part of IR, only present in the graph.
+ *
+ * Known, documented losses:
+ *   - `schema` (builder Schema) — Zod-opaque. Placeholder.
+ *   - `methods[*].fnDef` — source-form Zod validators don't round-trip.
+ *     Placeholder preserves `.config.{params,returns}` access.
+ */
+import { defRef } from '@astrale-os/kernel-dsl';
+import { bindAccessorMethods } from '#domain/accessors/bind';
+import { groupProperties } from '#domain/accessors/group';
+import { Key } from '#domain/addressing/keys/key';
+import { defaultLayout } from '#domain/addressing/layout/build';
+import { CORE_ANCHOR_SLUG } from '#domain/addressing/layout/default';
+import { isDefinitionNamespace } from '#domain/addressing/namespace';
+import { ClassPath } from '#domain/addressing/paths/class';
+import { CLASS_PREFIX, INTERFACE_PREFIX } from '#domain/addressing/paths/constants';
+import { DomainPath } from '#domain/addressing/paths/domain';
+import { InterfacePath } from '#domain/addressing/paths/interface';
+import { MethodPath } from '#domain/addressing/paths/method';
+import { Ref } from '#domain/addressing/refs/ref';
+import { coreNodeExternalId } from '#domain/compile/external-ids';
+import { methodsOf } from '#domain/compile/method/types';
+import { DomainOrigin as brandDomainOrigin } from '#domain/origin';
+import { PROPERTY_INDEX_BLOB_VERSION } from '#domain/serialize/schema';
+import { getExternalId } from '#graph/sync';
+import { K, REMOTE_KEYS } from '#kernel';
+import { DeserializationError } from './errors';
+// ── Kernel class raw strings (materialize writes these) ───────────────
+const CLS_DOMAIN = K.Domain.path.class.raw;
+const CLS_FOLDER = K.Folder.path.class.raw;
+const CLS_CLASS = K.Class.path.class.raw;
+const CLS_INTERFACE = K.Interface.path.class.raw;
+const CLS_FUNCTION = K.$.c('Function').path.class.raw;
+const CLS_HAS_PARENT = K.has_parent.path.class.raw;
+const CLS_METHOD_OF = K.method_of.path.class.raw;
+// ── Entry point ───────────────────────────────────────────────────────
+/**
+ * Deserialize a `Graph` into a `CompiledDomain`.
+ *
+ * Input is a `Graph` — well-formed (absolute paths,
+ * hydrated `Path` instances, deduped ids) by construction. Callers receiving
+ * wire-form `{ nodes, edges }` must run it through `Graph.from` first; the
+ * type signature makes that conversion explicit rather than implicit.
+ */
+export function deserializeDomainFromGraph(graph) {
+    const nodes = graph.nodes.all;
+    const edges = graph.edges.all;
+    const domainNode = findSingleDomainNode(nodes);
+    const ir = readSchemaIR(domainNode);
+    const origin = brandDomainOrigin(ir.domain);
+    const domainPath = domainNode.path;
+    const typePaths = collectTypePaths(nodes, domainPath, ir);
+    const properties = buildProperties(typePaths);
+    const methods = buildMethods(nodes, edges, typePaths, ir, domainPath, origin);
+    const methodDeclarations = collectLocalMethodDeclarations(nodes, ir);
+    const core = buildCore(nodes, edges, domainPath, origin);
+    const refs = buildRefs(origin, ir, typePaths, methods, core);
+    const { keys, paths } = buildFlatMaps(origin, refs, methodDeclarations);
+    const inheritanceChain = buildInheritanceChain(ir);
+    const interfaces = Object.fromEntries(Object.keys(ir.interfaces).map((name) => [name, {}]));
+    const classes = Object.fromEntries(Object.keys(ir.classes).map((name) => [name, {}]));
+    const imports = Object.fromEntries(Object.entries(ir.imports ?? {}).map(([name, entry]) => [name, entry.origin]));
+    const accessors = bindAccessorMethods(origin, properties, methods);
+    const $ = Object.freeze({
+        origin,
+        schema: placeholderSchema(origin),
+        layout: defaultLayout(origin),
+        refs,
+        paths,
+        keys,
+        interfaces,
+        classes,
+        imports,
+        core,
+        methods,
+        properties,
+        inheritanceChain: Object.freeze(inheritanceChain),
+        ir,
+        warnings: Object.freeze([]),
+        ...accessors,
+        group(className, flat) {
+            const byClass = properties.byClass[className];
+            if (!byClass) {
+                throw new Error(`deserializedDomain.group: unknown class "${className}" in domain "${origin}"`);
+            }
+            return groupProperties(byClass, className, origin, flat);
+        },
+        c: (name) => refs.classes[name],
+        i: (name) => refs.interfaces[name],
+    });
+    return Object.freeze({
+        $,
+        ...refs.classes,
+        ...refs.interfaces,
+    });
+}
+// ── Domain node + SchemaIR blob ───────────────────────────────────────
+function findSingleDomainNode(nodes) {
+    const domainNodes = nodes.filter((n) => n.class?.raw === CLS_DOMAIN);
+    if (domainNodes.length === 0) {
+        throw new DeserializationError('NO_DOMAIN_NODE', 'No Domain node found in graph');
+    }
+    if (domainNodes.length > 1) {
+        throw new DeserializationError('MULTIPLE_DOMAIN_NODES', `Expected exactly one Domain node, found ${domainNodes.length}`);
+    }
+    const n = domainNodes[0];
+    if (!n.path) {
+        throw new DeserializationError('MISSING_PATH', 'Domain node has no path property');
+    }
+    return n;
+}
+/**
+ * Does a Domain node carry a serialized SchemaIR blob?
+ *
+ * True for every domain materialized via `serialize` — the blob is the single
+ * source of truth `deserializeDomainFromGraph` reads. False only for the
+ * bootstrap kernel Domain node, created by raw boot Cypher that never writes
+ * the blob (consumers seed the kernel from the in-bundle compiled domain
+ * instead). Callers iterating Domain nodes use this to skip the ones that
+ * aren't graph-deserializable, rather than catching `MISSING_SCHEMA_IR`.
+ */
+export function carriesSchemaIR(node) {
+    const raw = node.props?.['schema'];
+    return typeof raw === 'string' && raw.length > 0;
+}
+function readSchemaIR(domainNode) {
+    if (!carriesSchemaIR(domainNode)) {
+        throw new DeserializationError('MISSING_SCHEMA_IR', 'Domain node has no `schema` property (serialized SchemaIR blob)');
+    }
+    const raw = domainNode.props?.['schema'];
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new DeserializationError('MALFORMED_SCHEMA_IR', 'Domain node `schema` property is not valid JSON');
+    }
+    if (!isSchemaIR(parsed)) {
+        throw new DeserializationError('MALFORMED_SCHEMA_IR', 'Domain node `schema` property does not conform to SchemaIR shape');
+    }
+    return parsed;
+}
+function isSchemaIR(v) {
+    if (v === null || typeof v !== 'object')
+        return false;
+    const o = v;
+    return (typeof o.domain === 'string' &&
+        o.interfaces !== null &&
+        typeof o.interfaces === 'object' &&
+        o.classes !== null &&
+        typeof o.classes === 'object');
+}
+/**
+ * Collect Class/Interface self node paths + per-type propertyIndex blobs,
+ * filtered to the types declared in the IR. Foreign self nodes (from a
+ * sibling domain's Tree merged into the same graph) are excluded by name.
+ */
+function collectTypePaths(nodes, domainPath, ir) {
+    const out = new Map();
+    const domainPrefix = domainPath.raw === '/' ? '/' : domainPath.raw + '/';
+    for (const n of nodes) {
+        const cls = n.class?.raw;
+        if (cls !== CLS_CLASS && cls !== CLS_INTERFACE)
+            continue;
+        if (!n.path)
+            continue;
+        if (!n.path.raw.startsWith(domainPrefix) && n.path.raw !== domainPath.raw)
+            continue;
+        // Class/Interface `name` is inherited from Named → canonical qualified key.
+        const name = n.props?.[K.Named.name.key];
+        if (!name)
+            continue;
+        const isInterface = cls === CLS_INTERFACE;
+        const local = isInterface ? ir.interfaces[name] : ir.classes[name];
+        if (!local)
+            continue;
+        if (n.path.isRoot)
+            continue;
+        const folderPath = n.path.parent();
+        out.set(name, {
+            path: n.path,
+            folderPath: folderPath,
+            propertyIndex: parsePropertyIndexBlob(n.props?.['propertyIndex']),
+            namespace: isInterface ? 'interface' : 'class',
+        });
+    }
+    return out;
+}
+function parsePropertyIndexBlob(raw) {
+    if (raw === undefined || raw === null)
+        return {};
+    if (typeof raw !== 'string' || raw.length === 0)
+        return {};
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new DeserializationError('MALFORMED_PROPERTY_INDEX', 'propertyIndex blob is not valid JSON');
+    }
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new DeserializationError('MALFORMED_PROPERTY_INDEX', 'propertyIndex blob is not a plain object');
+    }
+    const payload = parsed;
+    if (payload.version !== PROPERTY_INDEX_BLOB_VERSION) {
+        throw new DeserializationError('UNSUPPORTED_PROPERTY_INDEX_VERSION', `propertyIndex blob version ${String(payload.version)} not supported (expected ${PROPERTY_INDEX_BLOB_VERSION})`);
+    }
+    if (payload.byDomainOwner === null ||
+        typeof payload.byDomainOwner !== 'object' ||
+        Array.isArray(payload.byDomainOwner)) {
+        throw new DeserializationError('MALFORMED_PROPERTY_INDEX', 'propertyIndex.byDomainOwner is not a plain object');
+    }
+    const validated = {};
+    for (const [domain, byOwner] of Object.entries(payload.byDomainOwner)) {
+        if (byOwner === null || typeof byOwner !== 'object' || Array.isArray(byOwner)) {
+            throw new DeserializationError('MALFORMED_PROPERTY_INDEX', `propertyIndex.byDomainOwner["${domain}"] is not a plain object`);
+        }
+        const ownerMap = {};
+        for (const [ownerName, propMap] of Object.entries(byOwner)) {
+            if (propMap === null || typeof propMap !== 'object' || Array.isArray(propMap)) {
+                throw new DeserializationError('MALFORMED_PROPERTY_INDEX', `propertyIndex.byDomainOwner["${domain}"]["${ownerName}"] is not a plain object`);
+            }
+            const inner = {};
+            for (const [propName, mapping] of Object.entries(propMap)) {
+                if (!isPropertyMapping(mapping)) {
+                    throw new DeserializationError('MALFORMED_PROPERTY_INDEX', `propertyIndex.byDomainOwner["${domain}"]["${ownerName}"]["${propName}"] is not a valid PropertyMapping`);
+                }
+                inner[propName] = mapping;
+            }
+            ownerMap[ownerName] = inner;
+        }
+        validated[domain] = ownerMap;
+    }
+    return validated;
+}
+function isPropertyMapping(v) {
+    if (v === null || typeof v !== 'object')
+        return false;
+    const m = v;
+    return (typeof m.key === 'string' &&
+        typeof m.propName === 'string' &&
+        typeof m.owner === 'string' &&
+        typeof m.domain === 'string' &&
+        typeof m.private === 'boolean' &&
+        typeof m.isAttribute === 'boolean');
+}
+// ── Properties ────────────────────────────────────────────────────────
+function buildProperties(types) {
+    const byClass = {};
+    for (const [name, t] of types) {
+        if (t.namespace === 'interface')
+            continue;
+        const entry = {};
+        for (const [domain, byOwner] of Object.entries(t.propertyIndex)) {
+            const frozenByOwner = {};
+            for (const [ownerName, propMap] of Object.entries(byOwner)) {
+                const frozenProps = {};
+                for (const [propName, mapping] of Object.entries(propMap)) {
+                    frozenProps[propName] = Object.freeze({ ...mapping });
+                }
+                frozenByOwner[ownerName] = Object.freeze(frozenProps);
+            }
+            entry[domain] = Object.freeze(frozenByOwner);
+        }
+        byClass[name] = Object.freeze(entry);
+    }
+    const flat = {};
+    for (const [className, byDomain] of Object.entries(byClass)) {
+        const inner = {};
+        for (const byOwner of Object.values(byDomain)) {
+            for (const propMap of Object.values(byOwner)) {
+                for (const [propName, mapping] of Object.entries(propMap)) {
+                    inner[propName] = mapping;
+                }
+            }
+        }
+        flat[className] = Object.freeze(inner);
+    }
+    const frozenByClass = Object.freeze(byClass);
+    const frozenFlat = Object.freeze(flat);
+    return Object.freeze({
+        byClass: frozenByClass,
+        flat: frozenFlat,
+        resolveMember(key) {
+            const parsed = Key.tryParse(key);
+            if (!parsed || !parsed.isProperty)
+                return undefined;
+            const ownerName = parsed.member;
+            const propName = parsed.child;
+            for (const byDomain of Object.values(frozenByClass)) {
+                for (const byOwner of Object.values(byDomain)) {
+                    const mapping = byOwner[ownerName]?.[propName];
+                    if (mapping)
+                        return mapping;
+                }
+            }
+            return undefined;
+        },
+    });
+}
+// ── Methods (graph walk — Function + method_of) ───────────────────────
+/**
+ * Reconstruct `DomainMethodsMap` from Function nodes + method_of edges.
+ *
+ * Function nodes are the source of truth because cross-domain inheritance points
+ * at the ORIGIN Function node (under the foreign domain's layout). Resolving
+ * these from IR alone would require loading the foreign IR; reading the
+ * graph directly keeps the deserializer self-contained.
+ */
+function buildMethods(nodes, edges, types, _ir, domainPath, origin) {
+    const methods = indexMethods(nodes, origin, domainPath);
+    const out = {};
+    const pathToName = buildPathToNameIndex(nodes, domainPath);
+    for (const e of edges) {
+        if (e.class?.raw !== CLS_METHOD_OF)
+            continue;
+        const entry = methods.get(e.source.raw);
+        if (!entry)
+            continue;
+        // `Graph.from` canonicalization is lane-preserving: AbsolutePath
+        // authored targets collapse to `node.path.raw`, typed authored targets
+        // collapse to `node.semantic.raw`. `pathToName` is indexed under both
+        // forms so the lookup succeeds regardless of which lane the serializer
+        // authored. Out-of-graph owners keep their authored raw, which won't
+        // be in `pathToName` and are treated as unknown.
+        const targetRaw = e.target.raw;
+        const ownerName = pathToName.get(targetRaw);
+        if (!ownerName)
+            continue;
+        if (!types.has(ownerName)) {
+            if (entry.declaringName === ownerName) {
+                // The method node is local but its owner type isn't in this domain —
+                // inputs with cross-domain data but matching names would silently
+                // drop methods. Surface explicitly.
+                throw new DeserializationError('UNKNOWN_METHOD_OWNER', `method_of target "${ownerName}" at ${targetRaw} is not a type in this domain`);
+            }
+            continue;
+        }
+        const inheritance = translateInheritance(entry.declaringName, ownerName, entry.graphInheritance);
+        const memberKind = types.get(ownerName).namespace;
+        // Kind of the DECLARING def (may differ from memberKind for inherited
+        // methods); falls back to memberKind for own / out-of-graph origins.
+        const originKind = types.get(entry.declaringName)?.namespace ?? memberKind;
+        const isOwn = entry.declaringName === ownerName;
+        // Keyed by defRef so a class and an interface sharing a name don't collide.
+        const key = defRef(memberKind, ownerName);
+        const bucket = out[key] ?? (out[key] = {});
+        bucket[entry.methodName] = Object.freeze({
+            fnDef: placeholderFnDef(),
+            inheritance,
+            origin: entry.declaringName,
+            originKind,
+            isOwn,
+            isOverride: isOwn && inheritance === 'override',
+            shadowsSealed: false,
+            memberKind,
+            ref: Ref.method(memberKind, ownerName, entry.methodName).toString(),
+            path: MethodPath.from({
+                domain: origin,
+                member: ownerName,
+                memberKind,
+                method: entry.methodName,
+            }),
+        });
+    }
+    for (const name of Object.keys(out))
+        out[name] = Object.freeze(out[name]);
+    return Object.freeze(out);
+}
+function indexMethods(nodes, origin, domainPath) {
+    const out = new Map();
+    // Mount: parent of the Domain self-node — used to construct the typed
+    // `MethodPath` form consistent with how the schema serializer authors
+    // typed Function-node sources (`serialize/schema.ts:resolveMethodAddress`).
+    const mount = domainPath.isRoot ? domainPath : domainPath.parent();
+    for (const n of nodes) {
+        if (n.class?.raw !== CLS_FUNCTION)
+            continue;
+        if (!n.path) {
+            throw new DeserializationError('MISSING_PATH', 'Function node has no path property');
+        }
+        // Function node props use the canonical qualified storage form.
+        const rawRef = n.props?.[K.$.i('Function').ref.key];
+        if (!rawRef) {
+            throw new DeserializationError('INVALID_SYSCALL_REF', `Function node at ${n.path.raw} is missing its ${K.$.i('Function').ref.key} property.`);
+        }
+        // Only methods-of-a-class are indexed here. Standalone callables (the former
+        // `RemoteFunction`) are now `Function`-class nodes too, but they carry a
+        // non-method ref (default `function.<slug>`, which is not a valid namespace
+        // and so unparseable) and a `Function.binding` prop. The presence of the
+        // binding prop is the canonical "recognized callable" marker, used by
+        // `resolveCallableNodes`, the install flow, and identity registration.
+        //
+        // Reconciliation: a Function node that has NEITHER a parseable method ref
+        // NOR a Function.binding is corruption (the merge of Method + RemoteFunction
+        // removed the ref-must-be-method invariant, so the integrity check now keys
+        // on the structural "recognized callable" signal instead).
+        const ref = Ref.tryParse(rawRef);
+        if (!ref?.isMethod) {
+            const bindingKey = K.$.i('Function').binding.key;
+            const props = n.props ?? {};
+            const bindingValue = props[bindingKey];
+            const hasBinding = bindingValue !== undefined && bindingValue !== null && bindingValue !== '';
+            if (!hasBinding) {
+                throw new DeserializationError('INVALID_SYSCALL_REF', `Function node at ${n.path.raw} is unresolvable: ref "${rawRef}" is not a method ref and the node has no Function.binding.`);
+            }
+            continue;
+        }
+        const entry = {
+            declaringName: ref.member,
+            methodName: ref.child,
+            graphInheritance: n.props?.[K.$.i('Function').inheritance.key] ?? 'default',
+        };
+        // AbsolutePath form (legacy authoring convention).
+        out.set(n.path.raw, entry);
+        // Typed `MethodPath` form (symmetric authoring convention) — the
+        // schema serializer now emits `method_of` edges with this typed
+        // source, so the lookup at `buildMethods` line 450 must hit either
+        // form. The namespace ('class' | 'interface') comes from the ref.
+        if (!isDefinitionNamespace(ref.namespace))
+            continue;
+        const memberKind = ref.namespace;
+        out.set(MethodPath.from({ domain: origin, member: ref.member, memberKind, method: ref.child }, { parent: mount }).raw, entry);
+    }
+    return out;
+}
+function buildPathToNameIndex(nodes, domainPath) {
+    const out = new Map();
+    // Mount: everything before the Domain node's basename. Used to construct
+    // typed Path forms (ClassPath/InterfacePath) consistent with how the
+    // serializer authors them (serialize/schema.ts:129-130).
+    const mount = domainPath.isRoot ? domainPath : domainPath.parent();
+    const origin = domainPath.isRoot ? null : domainPath.slugs[domainPath.slugs.length - 1];
+    for (const n of nodes) {
+        if (!n.path)
+            continue;
+        const name = n.props?.[K.Named.name.key];
+        if (!name)
+            continue;
+        out.set(n.path.raw, name);
+        // Lane preservation (graph.ts:582-597): canonicalization keeps typed
+        // authored edge targets in the typed lane (collapsing to
+        // `node.semantic.raw` when populated, else preserving the authored
+        // form). Patch.toGraph doesn't populate `semantic`, so the authored
+        // typed form survives verbatim. Index Class/Interface nodes under
+        // their typed raw too so the method_of lookup hits both lanes.
+        if (origin === null)
+            continue;
+        const cls = n.class?.raw;
+        if (cls === CLS_CLASS) {
+            out.set(ClassPath.from({ domain: origin, className: name }, { parent: mount }).raw, name);
+        }
+        else if (cls === CLS_INTERFACE) {
+            out.set(InterfacePath.from({ domain: origin, interfaceName: name }, { parent: mount }).raw, name);
+        }
+        else if (cls === CLS_DOMAIN) {
+            out.set(DomainPath.from({ domain: name }, { parent: mount }).raw, name);
+        }
+    }
+    return out;
+}
+/**
+ * Translate graph-side inheritance marker to domain-side `DomainInheritance`,
+ * per owner.
+ *
+ * | graph marker | declaring == owner | declaring != owner  |
+ * |--------------|--------------------|---------------------|
+ * | 'own'        | 'own'              | (unreachable)       |
+ * | 'override'   | 'override'         | (unreachable)       |
+ * | 'sealed'     | 'sealed'           | 'sealed'            |
+ * | 'default'    | 'own'              | 'inherited-default' |
+ *
+ * Unknown markers fall back to 'sealed' — non-overridable and safe.
+ */
+function translateInheritance(declaringName, ownerName, graphInheritance) {
+    if (declaringName === ownerName) {
+        if (graphInheritance === 'sealed')
+            return 'sealed';
+        if (graphInheritance === 'override')
+            return 'override';
+        return 'own';
+    }
+    if (graphInheritance === 'sealed')
+        return 'sealed';
+    if (graphInheritance === 'default' || graphInheritance === 'inherited-default') {
+        return 'inherited-default';
+    }
+    return 'sealed';
+}
+/**
+ * Refs `keys` surface enumerates every locally-declared method, independent of
+ * inheritance fanout (source-path semantics). Collect declaration refs by
+ * walking method nodes whose declaring type is local to this domain.
+ */
+function collectLocalMethodDeclarations(nodes, ir) {
+    const out = new Set();
+    const localNames = new Set([...Object.keys(ir.interfaces), ...Object.keys(ir.classes)]);
+    for (const n of nodes) {
+        if (n.class?.raw !== CLS_FUNCTION)
+            continue;
+        const rawName = n.props?.['ref'] ?? n.props?.['name'] ?? '';
+        const ref = Ref.tryParse(rawName);
+        if (!ref || !ref.isMethod)
+            continue;
+        if (!localNames.has(ref.member))
+            continue;
+        out.add(ref.toString());
+    }
+    return out;
+}
+// ── Core (instance) nodes ─────────────────────────────────────────────
+function buildCore(nodes, edges, domainPath, origin) {
+    // The user-core anchor is `<domain>/core` (kernel Folder). Its presence is
+    // the structural signal that this domain has user core; its absence means
+    // no core.
+    const coreAnchorPath = domainPath.append(CORE_ANCHOR_SLUG);
+    const hasAnchor = nodes.some((n) => n.path?.raw === coreAnchorPath.raw && n.class?.raw === CLS_FOLDER);
+    if (!hasAnchor)
+        return undefined;
+    const anchorSlugCount = coreAnchorPath.slugs.length;
+    const coreNodesByPath = new Map();
+    for (const n of nodes) {
+        if (!n.path)
+            continue;
+        const cls = n.class?.raw;
+        if (!cls)
+            continue;
+        if (n.path.raw === coreAnchorPath.raw)
+            continue; // the anchor itself
+        if (!isUnder(n.path, coreAnchorPath))
+            continue;
+        if (!getExternalId(n.props ?? {}, REMOTE_KEYS))
+            continue;
+        const ref = relativeRef(n.path, anchorSlugCount);
+        if (!ref)
+            continue;
+        coreNodesByPath.set(n.path.raw, { path: n.path, ref, node: n });
+    }
+    // Top-level user entries `has_parent → anchor`. The anchor itself
+    // `has_parent → Domain root`, which is fine — its edge is not in the user
+    // core walk. The Domain root has two equivalent forms on edge targets:
+    // its AbsolutePath (`/<origin>`) and its typed `DomainPath` (`/:<origin>`).
+    const allowedParentRaws = new Set([
+        coreAnchorPath.raw,
+        domainPath.raw,
+        DomainPath.from({ domain: origin }, { parent: domainPath.parent() }).raw,
+    ]);
+    const parentByPath = new Map();
+    for (const e of edges) {
+        if (e.class?.raw !== CLS_HAS_PARENT)
+            continue;
+        const src = e.source.raw;
+        const tgt = e.target.raw;
+        if (!coreNodesByPath.has(src))
+            continue;
+        const tgtCore = coreNodesByPath.get(tgt);
+        if (tgtCore) {
+            parentByPath.set(src, tgtCore.ref);
+            continue;
+        }
+        if (allowedParentRaws.has(tgt))
+            continue;
+        throw new DeserializationError('CORE_PARENT_MISSING', `Core node ${src} has_parent → ${tgt}, which is not a core node, the anchor, or the domain root`);
+    }
+    const refs = {};
+    const keys = {};
+    const paths = {};
+    const externalIds = {};
+    const entries = {};
+    for (const { path, ref, node } of coreNodesByPath.values()) {
+        const className = node.class?.className;
+        if (!className)
+            continue;
+        const classDomain = brandDomainOrigin(node.class.domain);
+        const externalId = getExternalId(node.props, REMOTE_KEYS) ?? coreNodeExternalId(origin, path);
+        refs[ref] = ref;
+        keys[ref] = Key.of(origin, Ref.member('core', ref)).toString();
+        paths[ref] = path;
+        externalIds[ref] = externalId;
+        entries[ref] = Object.freeze({
+            ref,
+            className,
+            classDomain,
+            path,
+            externalId,
+            parentRef: parentByPath.get(path.raw),
+            data: stripRemoteKeys(node.props),
+        });
+    }
+    // User-defined core edges: source is a core node. Target may be a core node,
+    // a class/interface meta-node (declared via `selfOf`), or a cross-domain node.
+    // Edge class may belong to this domain or to an imported domain.
+    // `has_parent` edges from core nodes are excluded — they were processed
+    // above as the structural parent backbone.
+    const coreEdges = [];
+    for (const e of edges) {
+        if (!e.class || e.class.raw === CLS_HAS_PARENT)
+            continue;
+        if (!coreNodesByPath.has(e.source.raw))
+            continue;
+        coreEdges.push(Object.freeze({
+            className: e.class.className,
+            classDomain: brandDomainOrigin(e.class.domain),
+            fromPath: e.source,
+            toPath: e.target,
+            data: stripRemoteKeys(e.props),
+        }));
+    }
+    return Object.freeze({
+        refs: Object.freeze(refs),
+        keys: Object.freeze(keys),
+        paths: Object.freeze(paths),
+        externalIds: Object.freeze(externalIds),
+        entries: Object.freeze(entries),
+        edges: Object.freeze(coreEdges),
+    });
+}
+function isUnder(candidate, ancestor) {
+    if (candidate.raw === ancestor.raw)
+        return false;
+    const prefix = ancestor.raw === '/' ? '/' : ancestor.raw + '/';
+    return candidate.raw.startsWith(prefix);
+}
+function relativeRef(path, domainSlugCount) {
+    const slugs = path.slugs.slice(domainSlugCount);
+    if (slugs.length === 0)
+        return undefined;
+    return slugs.join('.');
+}
+function stripRemoteKeys(props) {
+    if (!props)
+        return Object.freeze({});
+    const remoteKeySet = new Set(Object.values(REMOTE_KEYS));
+    const out = {};
+    for (const [key, value] of Object.entries(props)) {
+        if (remoteKeySet.has(key))
+            continue;
+        out[key] = value;
+    }
+    return Object.freeze(out);
+}
+// ── Refs ──────────────────────────────────────────────────────────────
+function buildRefs(origin, ir, types, methods, core) {
+    const interfaces = {};
+    const classes = {};
+    for (const name of Object.keys(ir.interfaces)) {
+        const entry = buildMemberEntry(origin, name, 'interface', types, methods);
+        if (entry)
+            interfaces[name] = entry;
+    }
+    for (const name of Object.keys(ir.classes)) {
+        const entry = buildMemberEntry(origin, name, 'class', types, methods);
+        if (entry)
+            classes[name] = entry;
+    }
+    return Object.freeze({
+        interfaces: Object.freeze(interfaces),
+        classes: Object.freeze(classes),
+        core: core ? buildCoreGroup(origin, core) : Object.freeze({}),
+    });
+}
+function buildMemberEntry(origin, name, namespace, types, methods) {
+    const typePath = types.get(name);
+    if (!typePath)
+        return undefined;
+    const memberRef = Ref.member(namespace, name);
+    const memberRefStr = memberRef.toString();
+    const memberKey = Key.of(origin, memberRef).toString();
+    const memberPath = Object.freeze({
+        domain: memberSemanticPath(origin, memberRef.qualified, name),
+        absolute: typePath.path,
+        class: ClassPath.from({ domain: origin, className: name }),
+    });
+    const methodEntries = {};
+    const ownerMethods = methodsOf(methods, namespace, name);
+    if (ownerMethods) {
+        for (const [methodName, rm] of Object.entries(ownerMethods)) {
+            if (!rm.isOwn && (rm.inheritance === 'sealed' || rm.inheritance === 'inherited-default')) {
+                continue;
+            }
+            const mRef = Ref.method(namespace, name, methodName);
+            const mAbs = typePath.folderPath.append(methodName);
+            const mPath = Object.freeze({
+                method: methodSemanticPath(origin, mRef.qualified, mRef.child),
+                absolute: mAbs,
+            });
+            methodEntries[methodName] = Object.freeze({
+                ref: mRef.toString(),
+                key: Key.of(origin, mRef).toString(),
+                path: mPath,
+            });
+        }
+    }
+    const accessors = Object.freeze({
+        m: (n) => methodEntries[n],
+        // Deserialization doesn't reconstruct PropertyRefEntry — refs expose
+        // the method surface only. Callers needing property refs consume
+        // compiled.$.properties directly.
+        p: (_n) => undefined,
+    });
+    return Object.freeze({
+        ref: memberRefStr,
+        key: memberKey,
+        path: memberPath,
+        $: accessors,
+        ...methodEntries,
+    });
+}
+function buildCoreGroup(origin, core) {
+    const result = {};
+    for (const [name, entry] of Object.entries(core.entries)) {
+        const ref = Ref.member('core', name);
+        const refPath = Object.freeze({
+            domain: DomainPath.from({ domain: origin, member: ref.qualified }),
+            absolute: entry.path,
+        });
+        result[name] = Object.freeze({
+            ref: ref.toString(),
+            key: Key.of(origin, ref).toString(),
+            path: refPath,
+        });
+    }
+    return Object.freeze(result);
+}
+// ── Flat maps ─────────────────────────────────────────────────────────
+function buildFlatMaps(origin, refs, methodDeclarations) {
+    const keys = {};
+    const absolute = {};
+    const classMap = {};
+    emitGroup(refs.interfaces);
+    emitGroup(refs.classes);
+    for (const entry of Object.values(refs.core)) {
+        keys[entry.ref] = entry.key;
+        absolute[entry.ref] = entry.path.absolute;
+    }
+    for (const refStr of methodDeclarations) {
+        if (refStr in keys)
+            continue;
+        keys[refStr] = Key.of(origin, Ref.parse(refStr)).toString();
+    }
+    return {
+        keys: keys,
+        paths: Object.freeze({
+            absolute: Object.freeze(absolute),
+            class: Object.freeze(classMap),
+        }),
+    };
+    function emitGroup(group) {
+        for (const member of Object.values(group)) {
+            keys[member.ref] = member.key;
+            absolute[member.ref] = member.path.absolute;
+            classMap[member.ref] = member.path.class;
+            for (const [key, value] of Object.entries(member)) {
+                if (key === 'ref' || key === 'key' || key === 'path' || key === '$')
+                    continue;
+                if (typeof value !== 'object' || value === null)
+                    continue;
+                const sub = value;
+                if (!sub.ref || !sub.path)
+                    continue;
+                keys[sub.ref] = sub.key;
+                absolute[sub.ref] = sub.path.absolute;
+            }
+        }
+    }
+}
+// ── Inheritance chain (derived from IR) ───────────────────────────────
+function buildInheritanceChain(ir) {
+    // Parents are always INTERFACES (classes `implements` interfaces; interfaces
+    // `extends` interfaces). Keyed by interface name — unique among interfaces,
+    // so a class/interface homonym (e.g. `Function`) does not collide here.
+    const ifaceExtends = new Map();
+    for (const [name, decl] of Object.entries(ir.interfaces)) {
+        ifaceExtends.set(name, decl.extends);
+    }
+    // `seen` is keyed by defRef (`<kind>.<name>`), not bare name, and seeded with
+    // the self's defRef. This matches the canonical compiler `buildInheritanceChains`
+    // (compile/inheritance.ts), which dedups by def IDENTITY: a class `Function`
+    // and a same-named interface `Function` are distinct keys (`class.Function` vs
+    // `interface.Function`), so the class walks INTO the interface to inherit its
+    // ancestors (Container, Identity, …). Genuine cycles (e.g. interface A extends
+    // B, B extends A) collapse correctly to `[A, B]` because the back-edge to A
+    // hits the seeded self defRef. Every parent is an interface by construction
+    // (classes `implements` interfaces; interfaces `extends` interfaces).
+    const walk = (selfKind, selfName, directParents) => {
+        const chain = [selfName];
+        const seen = new Set([defRef(selfKind, selfName)]);
+        const queue = [...directParents];
+        while (queue.length > 0) {
+            const p = queue.shift();
+            const pKey = defRef('interface', p);
+            if (seen.has(pKey))
+                continue;
+            seen.add(pKey);
+            chain.push(p);
+            for (const pp of ifaceExtends.get(p) ?? [])
+                queue.push(pp);
+        }
+        return Object.freeze(chain);
+    };
+    const out = {};
+    for (const [name, decl] of Object.entries(ir.interfaces)) {
+        out[defRef('interface', name)] = walk('interface', name, decl.extends);
+    }
+    for (const [name, decl] of Object.entries(ir.classes)) {
+        out[defRef('class', name)] = walk('class', name, decl.implements ?? []);
+    }
+    return out;
+}
+// ── Placeholders ──────────────────────────────────────────────────────
+/**
+ * Structurally-valid builder `Schema` placeholder. Holds no Zod types —
+ * consumers that need real validators must call `compileDomain(original)`.
+ */
+function placeholderSchema(origin) {
+    return {
+        domain: origin,
+        interfaces: {},
+        classes: {},
+        functions: {},
+        imports: [],
+    };
+}
+function placeholderFnDef() {
+    return {
+        config: { params: undefined, returns: undefined },
+        __placeholder: true,
+    };
+}
+// ── Path constructors that dispatch on the member's namespace prefix ────
+function memberSemanticPath(origin, qualified, name) {
+    if (qualified.startsWith(CLASS_PREFIX)) {
+        return ClassPath.from({ domain: origin, className: name });
+    }
+    if (qualified.startsWith(INTERFACE_PREFIX)) {
+        return InterfacePath.from({ domain: origin, interfaceName: name });
+    }
+    return DomainPath.from({ domain: origin, member: qualified });
+}
+function methodSemanticPath(origin, qualified, child) {
+    const memberKind = qualified.startsWith(INTERFACE_PREFIX)
+        ? 'interface'
+        : 'class';
+    return MethodPath.from({ domain: origin, member: qualified, memberKind, method: child });
+}
+//# sourceMappingURL=deserialize.js.map