@astrale-os/kernel-core 0.4.1

package/dist/graph/edge/zod.js

@@ -0,0 +1,27 @@
+/**
+ * Zod schemas for `EdgeSpec` / `Edge` records.
+ *
+ * Source/target endpoints are any absolute `Path` subtype that
+ * self-identifies a node (AbsolutePath, DomainPath, IdPath, or any future
+ * subclass). No subtype-specific schema, no union: the constraint is
+ * purely "absolute".
+ */
+import { z } from 'zod';
+import { classPathSchema } from '#domain/addressing/paths/zod';
+import { pathSchema, slugSchema } from '#graph/nav/path';
+import { RelativePath } from '#graph/tree/path/relative';
+const addressSchema = pathSchema().refine((p) => !(p instanceof RelativePath), {
+    message: 'edge endpoint must be an absolute address',
+});
+/** Wire-accepting schema for an edge record. */
+export const edgeSchema = z.object({
+    class: classPathSchema(),
+    source: addressSchema,
+    target: addressSchema,
+    slug: slugSchema.optional(),
+    props: z.record(z.string(), z.unknown()),
+    id: z.string().optional(),
+    __labels: z.array(z.string()).optional(),
+    __type: z.string().optional(),
+});
+//# sourceMappingURL=zod.js.map

package/dist/graph/edge/zod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod.js","sourceRoot":"","sources":["../../../graph/edge/zod.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAA;AAC9D,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAExD,MAAM,aAAa,GAAG,UAAU,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,YAAY,YAAY,CAAC,EAAE;IAC7E,OAAO,EAAE,2CAA2C;CACrD,CAAC,CAAA;AAEF,gDAAgD;AAChD,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,CAAC,MAAM,CAAC;IACjC,KAAK,EAAE,eAAe,EAAE;IACxB,MAAM,EAAE,aAAa;IACrB,MAAM,EAAE,aAAa;IACrB,IAAI,EAAE,UAAU,CAAC,QAAQ,EAAE;IAC3B,KAAK,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC;IACxC,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACzB,QAAQ,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;IACxC,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAC9B,CAAC,CAAA"}

package/dist/graph/errors.d.ts

@@ -0,0 +1,100 @@
+import type { Step } from '#graph/nav/path/step';
+import type { EdgeId, NodeId } from '#ids';
+export type GraphViolation = {
+    kind: 'duplicate_node_id';
+    nodeId: NodeId;
+} | {
+    kind: 'duplicate_edge_id';
+    edgeId: EdgeId;
+} | {
+    kind: 'missing_node_id';
+    slug: string;
+} | {
+    kind: 'missing_edge_id';
+    index: number;
+} | {
+    kind: 'missing_node_slug';
+    index: number;
+} | {
+    kind: 'missing_node_class';
+    slug: string;
+} | {
+    kind: 'missing_node_path';
+    index: number;
+} | {
+    kind: 'non_absolute_node_path';
+    index: number;
+    path: string;
+} | {
+    kind: 'missing_edge_endpoint';
+    index: number;
+    side: 'source' | 'target';
+} | {
+    kind: 'non_absolute_edge_endpoint';
+    index: number;
+    side: 'source' | 'target';
+    path: string;
+};
+export declare class GraphValidationError extends Error {
+    readonly violations: readonly GraphViolation[];
+    constructor(violations: GraphViolation[]);
+}
+/**
+ * Thrown when multiple candidates satisfy a single step/address.
+ *
+ * Raised by `Graph.walk` / `Graph.findIncidentEdge` when a traversal step
+ * matches more than one edge, and by `resolveInternal` when more than one
+ * minted candidate verifies the same reference. Paths are deterministic
+ * addresses (≤ 1 node per path); multi-match means graph inconsistency.
+ */
+export declare class AmbiguousWalkError extends Error {
+    readonly step: Step;
+    readonly fromPath: string | undefined;
+    readonly matches: number;
+    constructor(step: Step, fromPath: string | undefined, matches: number);
+}
+/**
+ * Thrown when a mutation would delete the system Root node (`__system__`).
+ *
+ * Root is the structural anchor for the entire graph — every node reaches
+ * it through `:has_parent`, every domain installs under it, every
+ * AbsolutePath resolves through it. Deleting Root cascades into a full
+ * graph wipe via `DETACH DELETE` (see META_TRACE entry #25). The kernel
+ * refuses such deletes both at the syscall layer and at the storage
+ * layer; this error is the surface for either guard firing.
+ */
+export declare class RootProtectedError extends Error {
+    readonly path: {
+        readonly raw: string;
+    };
+    constructor(path: {
+        readonly raw: string;
+    });
+}
+/**
+ * Thrown when `Node.deleteNode` is called on a node that still has
+ * children (i.e. `:has_parent` incoming edges). Deleting such a node
+ * would orphan its children — they retain `:has_parent` edges to a
+ * non-existent target and become unreachable by tree path
+ * (META_TRACE entry #26).
+ *
+ * Callers must drain the subtree first (recursively delete leaves
+ * before parents). The kernel does not auto-cascade; cascade is a
+ * separate primitive (see `markSubtreeDeleting` + `apply` for
+ * patch-mode cascade).
+ */
+export declare class NodeNotEmptyError extends Error {
+    readonly path: {
+        readonly raw: string;
+    };
+    readonly childCount: number;
+    readonly sampleChildren: readonly {
+        readonly raw: string;
+    }[];
+    constructor(path: {
+        readonly raw: string;
+    }, childCount: number, sampleChildren?: readonly {
+        readonly raw: string;
+    }[]);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/graph/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../graph/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAA;AAChD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAI1C,MAAM,MAAM,cAAc,GACtB;IAAE,IAAI,EAAE,mBAAmB,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAC7C;IAAE,IAAI,EAAE,mBAAmB,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAC7C;IAAE,IAAI,EAAE,iBAAiB,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACzC;IAAE,IAAI,EAAE,iBAAiB,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC1C;IAAE,IAAI,EAAE,mBAAmB,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC5C;IAAE,IAAI,EAAE,oBAAoB,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC5C;IAAE,IAAI,EAAE,mBAAmB,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC5C;IAAE,IAAI,EAAE,wBAAwB,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC/D;IAAE,IAAI,EAAE,uBAAuB,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,QAAQ,GAAG,QAAQ,CAAA;CAAE,GAC3E;IACE,IAAI,EAAE,4BAA4B,CAAA;IAClC,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,QAAQ,GAAG,QAAQ,CAAA;IACzB,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAIL,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,QAAQ,CAAC,UAAU,EAAE,SAAS,cAAc,EAAE,CAAA;IAE9C,YAAY,UAAU,EAAE,cAAc,EAAE,EAiCvC;CACF;AAID;;;;;;;GAOG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;IACnB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAA;IACrC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IAExB,YAAY,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,OAAO,EAAE,MAAM,EASpE;CACF;AAcD;;;;;;;;;GASG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,QAAQ,CAAC,IAAI,EAAE;QAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAA;IAEvC,YAAY,IAAI,EAAE;QAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;KAAE,EAMzC;CACF;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C,QAAQ,CAAC,IAAI,EAAE;QAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAA;IACvC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,cAAc,EAAE,SAAS;QAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;IAE5D,YACE,IAAI,EAAE;QAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;KAAE,EAC9B,UAAU,EAAE,MAAM,EAClB,cAAc,GAAE,SAAS;QAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;KAAE,EAAO,EAczD;CACF"}

package/dist/graph/errors.js

@@ -0,0 +1,117 @@
+// ─── Error class ────────────────────────────────────────────
+export class GraphValidationError extends Error {
+    violations;
+    constructor(violations) {
+        const summary = violations
+            .slice(0, 5)
+            .map((v) => {
+            switch (v.kind) {
+                case 'duplicate_node_id':
+                    return `duplicate node id "${v.nodeId}"`;
+                case 'duplicate_edge_id':
+                    return `duplicate edge id "${v.edgeId}"`;
+                case 'missing_node_id':
+                    return `node "${v.slug}" has no id`;
+                case 'missing_edge_id':
+                    return `edge at index ${v.index} has no id`;
+                case 'missing_node_slug':
+                    return `node at index ${v.index} has no slug`;
+                case 'missing_node_class':
+                    return `node "${v.slug}" has no class`;
+                case 'missing_node_path':
+                    return `node at index ${v.index} has no path`;
+                case 'non_absolute_node_path':
+                    return `node at index ${v.index} has non-absolute path "${v.path}" (Graph requires AbsolutePath)`;
+                case 'missing_edge_endpoint':
+                    return `edge at index ${v.index} has no ${v.side}`;
+                case 'non_absolute_edge_endpoint':
+                    return `edge at index ${v.index} has non-absolute ${v.side} "${v.path}" (Graph edge endpoints must be absolute addresses)`;
+            }
+        })
+            .join('; ');
+        const more = violations.length > 5 ? ` (+${violations.length - 5} more)` : '';
+        super(`Graph validation failed: ${summary}${more}`);
+        this.name = 'GraphValidationError';
+        this.violations = violations;
+    }
+}
+// ─── Walk errors ────────────────────────────────────────────
+/**
+ * Thrown when multiple candidates satisfy a single step/address.
+ *
+ * Raised by `Graph.walk` / `Graph.findIncidentEdge` when a traversal step
+ * matches more than one edge, and by `resolveInternal` when more than one
+ * minted candidate verifies the same reference. Paths are deterministic
+ * addresses (≤ 1 node per path); multi-match means graph inconsistency.
+ */
+export class AmbiguousWalkError extends Error {
+    step;
+    fromPath;
+    matches;
+    constructor(step, fromPath, matches) {
+        const where = fromPath ? ` from "${fromPath}"` : '';
+        super(`Ambiguous resolution: step ${formatStep(step)}${where} matched ${matches} candidates; paths must be deterministic.`);
+        this.name = 'AmbiguousWalkError';
+        this.step = step;
+        this.fromPath = fromPath;
+        this.matches = matches;
+    }
+}
+function formatStep(step) {
+    if (step.kind === 'anchor')
+        return `@${step.id}`;
+    const dir = step.from === 'target' && step.to === 'source' ? 'IN' : 'OUT';
+    const pred = step.predicate?.kind === 'property'
+        ? ` ${step.predicate.property}="${step.predicate.value}"`
+        : '';
+    return `${step.edgeClass} ${dir}${pred}`;
+}
+// ─── Mutation guards ────────────────────────────────────────
+/**
+ * Thrown when a mutation would delete the system Root node (`__system__`).
+ *
+ * Root is the structural anchor for the entire graph — every node reaches
+ * it through `:has_parent`, every domain installs under it, every
+ * AbsolutePath resolves through it. Deleting Root cascades into a full
+ * graph wipe via `DETACH DELETE` (see META_TRACE entry #25). The kernel
+ * refuses such deletes both at the syscall layer and at the storage
+ * layer; this error is the surface for either guard firing.
+ */
+export class RootProtectedError extends Error {
+    path;
+    constructor(path) {
+        super(`Cannot delete the system Root (path "${path.raw}"). Root is the structural anchor for the graph and is unconditionally undeletable.`);
+        this.name = 'RootProtectedError';
+        this.path = path;
+    }
+}
+/**
+ * Thrown when `Node.deleteNode` is called on a node that still has
+ * children (i.e. `:has_parent` incoming edges). Deleting such a node
+ * would orphan its children — they retain `:has_parent` edges to a
+ * non-existent target and become unreachable by tree path
+ * (META_TRACE entry #26).
+ *
+ * Callers must drain the subtree first (recursively delete leaves
+ * before parents). The kernel does not auto-cascade; cascade is a
+ * separate primitive (see `markSubtreeDeleting` + `apply` for
+ * patch-mode cascade).
+ */
+export class NodeNotEmptyError extends Error {
+    path;
+    childCount;
+    sampleChildren;
+    constructor(path, childCount, sampleChildren = []) {
+        const SHOW = 3;
+        const shown = sampleChildren.slice(0, SHOW);
+        const sample = shown.map((p) => `"${p.raw}"`).join(', ');
+        const more = childCount > shown.length ? ` (+${childCount - shown.length} more)` : '';
+        super(`Cannot delete "${path.raw}": node has ${childCount} ${childCount === 1 ? 'child' : 'children'}${sample ? ` (${sample}${more})` : ''}. ` +
+            `Drain the subtree first or use a cascade primitive — Node.deleteNode refuses to orphan descendants.`);
+        this.name = 'NodeNotEmptyError';
+        this.path = path;
+        this.childCount = childCount;
+        this.sampleChildren = sampleChildren;
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/graph/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../graph/errors.ts"],"names":[],"mappings":"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"}

package/dist/graph/graph/build/from.d.ts

@@ -0,0 +1,62 @@
+import type { Path } from '#graph/nav/path';
+import type { EdgeId, NodeId } from '#ids';
+import type { Edge, EdgeSpec } from '../../edge';
+import type { Node, NodeSpec } from '../../node';
+import type { Graph } from '../graph';
+import { PathIndex } from '../indexes';
+/**
+ * Input shape accepted by `Graph.from` / `Graph.fromWire`.
+ *
+ * Nodes and edges may carry either typed Path instances or raw strings
+ * (the wire shape after `JSON.stringify`). `normalizeNodeSpec` /
+ * `normalizeEdgeSpec` rehydrate raws into Path instances before the
+ * rest of the pipeline runs.
+ *
+ * `aliases` is the producer-supplied typed-form seed (see
+ * {@link GraphData.aliases}). Same shape on both sides of the wire —
+ * `Path.toJSON` projects embedded Paths to raw strings on serialize.
+ * `Graph.fromWire` parses raws back via `aliasesFromWire` before
+ * delegating here. Stored on the resulting {@link Graph} instance and
+ * re-emitted by {@link Graph.toWire}, so the seed survives multi-hop
+ * wires (server → client → cache → replay).
+ */
+export interface GraphInputData {
+    readonly nodes: readonly (Node | NodeSpec)[];
+    readonly edges: readonly (Edge | EdgeSpec)[];
+    readonly aliases?: ReadonlyArray<readonly [NodeId, Path]>;
+}
+/**
+ * Constructor signature for the `Graph` class. Captured here so this
+ * factory can stay decoupled from the class definition (no static
+ * import of `Graph`'s value), avoiding a runtime circular import
+ * between `./graph` and `./from`.
+ */
+type GraphConstructor = new (nodes: readonly Node[], edges: readonly Edge[], nodeById: ReadonlyMap<NodeId, Node>, edgeById: ReadonlyMap<EdgeId, Edge>, nodeByPath: ReadonlyMap<string, Node>, edgesByClass: ReadonlyMap<string, readonly Edge[]>, edgesByEndpoint: ReadonlyMap<string, readonly Edge[]>, edgesByEdgeClass: ReadonlyMap<string, readonly Edge[]>, root: Node, pathIndex: PathIndex | null, aliases: ReadonlyArray<readonly [NodeId, Path]> | null) => Graph;
+/**
+ * Build a `Graph` from a `{ nodes, edges }` input.
+ *
+ * Pipeline:
+ *   1. Normalize specs — rehydrate string raws into typed Path
+ *      instances (`normalize.ts`).
+ *   2. Dedupe virtual roots — collapse duplicate auto-injected `/`
+ *      nodes that appear when merging graphs (`root.ts`).
+ *   3. Validate paths — every node's `path` must be `AbsolutePath`;
+ *      every edge endpoint must be Path-shaped + absolute
+ *      (`validate.ts`).
+ *   4. Build id indexes — collect duplicate-id violations
+ *      (`ids.ts`); throw `GraphValidationError` if any violations
+ *      surfaced.
+ *   5. Ensure root — if no `/` node, prepend a virtual root
+ *      (`root.ts`).
+ *   6. Build the multi-key `PathIndex` via fixpoint over
+ *      `BuildTimeView`. Each pass adds typed-form aliases; later
+ *      passes resolve typed edge endpoints whose target acquired its
+ *      alias on a prior pass.
+ *   7. Construct the `Graph` instance with all index maps wired.
+ *
+ * `GraphCtor` is passed in (rather than imported) so this module
+ * stays free of the runtime cycle with `./graph`.
+ */
+export declare function graphFrom(data: GraphInputData, GraphCtor: GraphConstructor): Graph;
+export {};
+//# sourceMappingURL=from.d.ts.map

package/dist/graph/graph/build/from.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"from.d.ts","sourceRoot":"","sources":["../../../../graph/graph/build/from.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAI1C,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAChD,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAChD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAA;AAGrC,OAAO,EAEL,SAAS,EAMV,MAAM,YAAY,CAAA;AAKnB;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,IAAI,GAAG,QAAQ,CAAC,EAAE,CAAA;IAC5C,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,IAAI,GAAG,QAAQ,CAAC,EAAE,CAAA;IAC5C,QAAQ,CAAC,OAAO,CAAC,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAA;CAC1D;AAED;;;;;GAKG;AACH,KAAK,gBAAgB,GAAG,KACtB,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,EACnC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,EACnC,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,EACrC,YAAY,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,IAAI,EAAE,CAAC,EAClD,eAAe,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,IAAI,EAAE,CAAC,EACrD,gBAAgB,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,IAAI,EAAE,CAAC,EACtD,IAAI,EAAE,IAAI,EACV,SAAS,EAAE,SAAS,GAAG,IAAI,EAC3B,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,GAAG,IAAI,KACnD,KAAK,CAAA;AAEV;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,cAAc,EAAE,SAAS,EAAE,gBAAgB,GAAG,KAAK,CAmClF"}

package/dist/graph/graph/build/from.js

@@ -0,0 +1,47 @@
+import { PathTypeRegistry } from '#graph/nav/path';
+import { GraphValidationError } from '../../errors';
+import { BuildTimeView, PathIndex, buildEdgesByClass, buildEdgesByEdgeClass, buildEdgesByEndpoint, buildIdIndexes, buildNodeByPath, } from '../indexes';
+import { dedupeVirtualRoots, ensureRoot } from '../root';
+import { mapIfChanged, normalizeEdgeSpec, normalizeNodeSpec } from './normalize';
+import { validatePaths } from './validate';
+/**
+ * Build a `Graph` from a `{ nodes, edges }` input.
+ *
+ * Pipeline:
+ *   1. Normalize specs — rehydrate string raws into typed Path
+ *      instances (`normalize.ts`).
+ *   2. Dedupe virtual roots — collapse duplicate auto-injected `/`
+ *      nodes that appear when merging graphs (`root.ts`).
+ *   3. Validate paths — every node's `path` must be `AbsolutePath`;
+ *      every edge endpoint must be Path-shaped + absolute
+ *      (`validate.ts`).
+ *   4. Build id indexes — collect duplicate-id violations
+ *      (`ids.ts`); throw `GraphValidationError` if any violations
+ *      surfaced.
+ *   5. Ensure root — if no `/` node, prepend a virtual root
+ *      (`root.ts`).
+ *   6. Build the multi-key `PathIndex` via fixpoint over
+ *      `BuildTimeView`. Each pass adds typed-form aliases; later
+ *      passes resolve typed edge endpoints whose target acquired its
+ *      alias on a prior pass.
+ *   7. Construct the `Graph` instance with all index maps wired.
+ *
+ * `GraphCtor` is passed in (rather than imported) so this module
+ * stays free of the runtime cycle with `./graph`.
+ */
+export function graphFrom(data, GraphCtor) {
+    const rawNodes = mapIfChanged(data.nodes, normalizeNodeSpec);
+    const rawEdges = mapIfChanged(data.edges, normalizeEdgeSpec);
+    const nodes = dedupeVirtualRoots(rawNodes);
+    const violations = [];
+    validatePaths(nodes, rawEdges, violations);
+    const { nodeById, edgeById } = buildIdIndexes(nodes, rawEdges, violations);
+    if (violations.length > 0)
+        throw new GraphValidationError(violations);
+    const { nodes: withRoot, root } = ensureRoot(nodes);
+    const nodeByPath = buildNodeByPath(withRoot);
+    const edgesByEdgeClass = buildEdgesByEdgeClass(rawEdges);
+    const pathIndex = PathIndex.build(withRoot, PathTypeRegistry.all(), (resolveByRaw) => new BuildTimeView(nodeById, resolveByRaw, edgesByEdgeClass), data.aliases);
+    return new GraphCtor(withRoot, rawEdges, nodeById, edgeById, nodeByPath, buildEdgesByClass(rawEdges), buildEdgesByEndpoint(rawEdges), edgesByEdgeClass, root, pathIndex, data.aliases ?? null);
+}
+//# sourceMappingURL=from.js.map

package/dist/graph/graph/build/from.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"from.js","sourceRoot":"","sources":["../../../../graph/graph/build/from.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AAMlD,OAAO,EAAE,oBAAoB,EAAuB,MAAM,cAAc,CAAA;AACxE,OAAO,EACL,aAAa,EACb,SAAS,EACT,iBAAiB,EACjB,qBAAqB,EACrB,oBAAoB,EACpB,cAAc,EACd,eAAe,GAChB,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AACxD,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAChF,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AA4C1C;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,UAAU,SAAS,CAAC,IAAoB,EAAE,SAA2B;IACzE,MAAM,QAAQ,GAAG,YAAY,CAAC,IAAI,CAAC,KAAwB,EAAE,iBAAiB,CAAC,CAAA;IAC/E,MAAM,QAAQ,GAAG,YAAY,CAAC,IAAI,CAAC,KAAwB,EAAE,iBAAiB,CAAC,CAAA;IAE/E,MAAM,KAAK,GAAG,kBAAkB,CAAC,QAAQ,CAAC,CAAA;IAE1C,MAAM,UAAU,GAAqB,EAAE,CAAA;IACvC,aAAa,CAAC,KAAK,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAA;IAC1C,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,GAAG,cAAc,CAAC,KAAK,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAA;IAC1E,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC;QAAE,MAAM,IAAI,oBAAoB,CAAC,UAAU,CAAC,CAAA;IAErE,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG,UAAU,CAAC,KAAK,CAAC,CAAA;IACnD,MAAM,UAAU,GAAG,eAAe,CAAC,QAAQ,CAAC,CAAA;IAE5C,MAAM,gBAAgB,GAAG,qBAAqB,CAAC,QAAQ,CAAC,CAAA;IACxD,MAAM,SAAS,GAAG,SAAS,CAAC,KAAK,CAC/B,QAAQ,EACR,gBAAgB,CAAC,GAAG,EAAE,EACtB,CAAC,YAAY,EAAE,EAAE,CAAC,IAAI,aAAa,CAAC,QAAQ,EAAE,YAAY,EAAE,gBAAgB,CAAC,EAC7E,IAAI,CAAC,OAAO,CACb,CAAA;IAED,OAAO,IAAI,SAAS,CAClB,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,UAAU,EACV,iBAAiB,CAAC,QAAQ,CAAC,EAC3B,oBAAoB,CAAC,QAAQ,CAAC,EAC9B,gBAAgB,EAChB,IAAI,EACJ,SAAS,EACT,IAAI,CAAC,OAAO,IAAI,IAAI,CACrB,CAAA;AACH,CAAC"}

package/dist/graph/graph/build/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Construction pipeline for `Graph` — internal to the kernel,
+ * surfaced to the class only via `graphFrom` (the static `Graph.from`
+ * delegates here).
+ *
+ * Stages: spec normalization → virtual-root dedupe → path validation
+ * → id indexing → root injection → multi-key path index (fixpoint) →
+ * `Graph` instantiation.
+ */
+export { graphFrom, type GraphInputData } from './from';
+//# sourceMappingURL=index.d.ts.map

package/dist/graph/graph/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../graph/graph/build/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,SAAS,EAAE,KAAK,cAAc,EAAE,MAAM,QAAQ,CAAA"}

package/dist/graph/graph/build/index.js

@@ -0,0 +1,11 @@
+/**
+ * Construction pipeline for `Graph` — internal to the kernel,
+ * surfaced to the class only via `graphFrom` (the static `Graph.from`
+ * delegates here).
+ *
+ * Stages: spec normalization → virtual-root dedupe → path validation
+ * → id indexing → root injection → multi-key path index (fixpoint) →
+ * `Graph` instantiation.
+ */
+export { graphFrom } from './from';
+//# sourceMappingURL=index.js.map

package/dist/graph/graph/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../graph/graph/build/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,SAAS,EAAuB,MAAM,QAAQ,CAAA"}

package/dist/graph/graph/build/normalize.d.ts

@@ -0,0 +1,20 @@
+import type { Edge } from '../../edge';
+import type { Node } from '../../node';
+/**
+ * Normalize a `Node` spec — replace string raws on `class` / `path`
+ * with typed Path instances. Returns the original reference when no
+ * field changes (cheap identity passthrough for already-typed inputs).
+ */
+export declare function normalizeNodeSpec<N extends Node>(node: N): N;
+/**
+ * Normalize an `Edge` spec — replace string raws on `class` /
+ * `source` / `target` with typed Path instances. Identity passthrough
+ * for already-typed inputs.
+ */
+export declare function normalizeEdgeSpec<E extends Edge>(edge: E): E;
+/**
+ * Map an array, returning the original array reference when no element
+ * changed. Saves an allocation on the common already-typed path.
+ */
+export declare function mapIfChanged<T>(items: readonly T[], fn: (item: T) => T): readonly T[];
+//# sourceMappingURL=normalize.d.ts.map

package/dist/graph/graph/build/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../../graph/graph/build/normalize.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AACtC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAWtC;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,IAAI,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,CAI5D;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,IAAI,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,CAO5D;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC,EAAE,CASrF"}

package/dist/graph/graph/build/normalize.js

@@ -0,0 +1,49 @@
+import { toPath } from '#graph/nav/path';
+/**
+ * Convert a string raw to the typed Path shape, or pass through an
+ * existing Path / undefined unchanged. Used to normalize specs that
+ * arrive from the wire (raws) into the typed shape `Graph` expects.
+ */
+function toPathOr(value) {
+    return (value === undefined ? undefined : toPath(value));
+}
+/**
+ * Normalize a `Node` spec — replace string raws on `class` / `path`
+ * with typed Path instances. Returns the original reference when no
+ * field changes (cheap identity passthrough for already-typed inputs).
+ */
+export function normalizeNodeSpec(node) {
+    const cls = toPathOr(node.class);
+    const path = toPathOr(node.path);
+    return cls === node.class && path === node.path ? node : { ...node, class: cls, path };
+}
+/**
+ * Normalize an `Edge` spec — replace string raws on `class` /
+ * `source` / `target` with typed Path instances. Identity passthrough
+ * for already-typed inputs.
+ */
+export function normalizeEdgeSpec(edge) {
+    const cls = toPathOr(edge.class);
+    const source = toPathOr(edge.source);
+    const target = toPathOr(edge.target);
+    return cls === edge.class && source === edge.source && target === edge.target
+        ? edge
+        : { ...edge, class: cls, source, target };
+}
+/**
+ * Map an array, returning the original array reference when no element
+ * changed. Saves an allocation on the common already-typed path.
+ */
+export function mapIfChanged(items, fn) {
+    let out;
+    for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        const mapped = fn(item);
+        if (mapped !== item && !out)
+            out = items.slice(0, i);
+        if (out)
+            out.push(mapped);
+    }
+    return out ?? items;
+}
+//# sourceMappingURL=normalize.js.map

package/dist/graph/graph/build/normalize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.js","sourceRoot":"","sources":["../../../../graph/graph/build/normalize.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AAKxC;;;;GAIG;AACH,SAAS,QAAQ,CAA6B,KAA6B;IACzE,OAAO,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,KAAsB,CAAC,CAAkB,CAAA;AAC5F,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAiB,IAAO;IACvD,MAAM,GAAG,GAAG,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAsB,CAAA;IACrD,MAAM,IAAI,GAAG,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAqB,CAAA;IACpD,OAAO,GAAG,KAAK,IAAI,CAAC,KAAK,IAAI,IAAI,KAAK,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAE,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,IAAI,EAAQ,CAAA;AAC/F,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAiB,IAAO;IACvD,MAAM,GAAG,GAAG,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAsB,CAAA;IACrD,MAAM,MAAM,GAAG,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAuB,CAAA;IAC1D,MAAM,MAAM,GAAG,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAuB,CAAA;IAC1D,OAAO,GAAG,KAAK,IAAI,CAAC,KAAK,IAAI,MAAM,KAAK,IAAI,CAAC,MAAM,IAAI,MAAM,KAAK,IAAI,CAAC,MAAM;QAC3E,CAAC,CAAC,IAAI;QACN,CAAC,CAAE,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAQ,CAAA;AACpD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,YAAY,CAAI,KAAmB,EAAE,EAAkB;IACrE,IAAI,GAAoB,CAAA;IACxB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACtC,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAE,CAAA;QACtB,MAAM,MAAM,GAAG,EAAE,CAAC,IAAI,CAAC,CAAA;QACvB,IAAI,MAAM,KAAK,IAAI,IAAI,CAAC,GAAG;YAAE,GAAG,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAQ,CAAA;QAC3D,IAAI,GAAG;YAAE,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;IAC3B,CAAC;IACD,OAAO,GAAG,IAAI,KAAK,CAAA;AACrB,CAAC"}

package/dist/graph/graph/build/validate.d.ts

@@ -0,0 +1,11 @@
+import type { Edge } from '../../edge';
+import type { GraphViolation } from '../../errors';
+import type { Node } from '../../node';
+/**
+ * Structural-shape validation — ensures every node has a path-shaped
+ * `path` and that path is an `AbsolutePath`; ensures every edge has
+ * path-shaped, absolute endpoints. Pushes findings into `violations`
+ * for the caller to decide whether to throw.
+ */
+export declare function validatePaths(nodes: readonly Node[], edges: readonly Edge[], violations: GraphViolation[]): void;
+//# sourceMappingURL=validate.d.ts.map

package/dist/graph/graph/build/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../../graph/graph/build/validate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AACtC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAClD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAItC;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,UAAU,EAAE,cAAc,EAAE,GAC3B,IAAI,CAqBN"}

package/dist/graph/graph/build/validate.js

@@ -0,0 +1,56 @@
+import { AbsolutePath } from '../../tree/path/absolute-path';
+/**
+ * Structural-shape validation — ensures every node has a path-shaped
+ * `path` and that path is an `AbsolutePath`; ensures every edge has
+ * path-shaped, absolute endpoints. Pushes findings into `violations`
+ * for the caller to decide whether to throw.
+ */
+export function validatePaths(nodes, edges, violations) {
+    for (let i = 0; i < nodes.length; i++) {
+        const path = nodes[i].path;
+        if (path === undefined || path === null) {
+            violations.push({ kind: 'missing_node_path', index: i });
+            continue;
+        }
+        if (!(path instanceof AbsolutePath)) {
+            violations.push({
+                kind: 'non_absolute_node_path',
+                index: i,
+                path: formatPath(path),
+            });
+        }
+    }
+    for (let i = 0; i < edges.length; i++) {
+        const e = edges[i];
+        checkEndpoint(e.source, i, 'source', violations);
+        checkEndpoint(e.target, i, 'target', violations);
+    }
+}
+function checkEndpoint(path, index, side, violations) {
+    if (path === undefined || path === null) {
+        violations.push({ kind: 'missing_edge_endpoint', index, side });
+        return;
+    }
+    const hasRaw = typeof path === 'object' && path !== null && typeof path.raw === 'string';
+    // Relativity is structural: an absolute path's first step is an
+    // anchor; a relative path's first step is a traversal.
+    const stepsArr = typeof path === 'object' && path !== null
+        ? (path.steps ?? null)
+        : null;
+    const isRelative = stepsArr !== null && stepsArr.length > 0 && stepsArr[0].kind !== 'anchor';
+    if (!hasRaw || isRelative) {
+        violations.push({
+            kind: 'non_absolute_edge_endpoint',
+            index,
+            side,
+            path: formatPath(path),
+        });
+    }
+}
+function formatPath(p) {
+    if (p && typeof p === 'object' && 'raw' in p && typeof p.raw === 'string') {
+        return p.raw;
+    }
+    return typeof p === 'string' ? p : String(p);
+}
+//# sourceMappingURL=validate.js.map

package/dist/graph/graph/build/validate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.js","sourceRoot":"","sources":["../../../../graph/graph/build/validate.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AAE5D;;;;;GAKG;AACH,MAAM,UAAU,aAAa,CAC3B,KAAsB,EACtB,KAAsB,EACtB,UAA4B;IAE5B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACtC,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAE,CAAC,IAAe,CAAA;QACtC,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;YACxC,UAAU,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,mBAAmB,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAA;YACxD,SAAQ;QACV,CAAC;QACD,IAAI,CAAC,CAAC,IAAI,YAAY,YAAY,CAAC,EAAE,CAAC;YACpC,UAAU,CAAC,IAAI,CAAC;gBACd,IAAI,EAAE,wBAAwB;gBAC9B,KAAK,EAAE,CAAC;gBACR,IAAI,EAAE,UAAU,CAAC,IAAI,CAAC;aACvB,CAAC,CAAA;QACJ,CAAC;IACH,CAAC;IAED,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACtC,MAAM,CAAC,GAAG,KAAK,CAAC,CAAC,CAAE,CAAA;QACnB,aAAa,CAAC,CAAC,CAAC,MAAiB,EAAE,CAAC,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAA;QAC3D,aAAa,CAAC,CAAC,CAAC,MAAiB,EAAE,CAAC,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAA;IAC7D,CAAC;AACH,CAAC;AAED,SAAS,aAAa,CACpB,IAAa,EACb,KAAa,EACb,IAAyB,EACzB,UAA4B;IAE5B,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;QACxC,UAAU,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,uBAAuB,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAA;QAC/D,OAAM;IACR,CAAC;IACD,MAAM,MAAM,GACV,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,IAAI,IAAI,OAAQ,IAA0B,CAAC,GAAG,KAAK,QAAQ,CAAA;IAClG,gEAAgE;IAChE,uDAAuD;IACvD,MAAM,QAAQ,GACZ,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,IAAI;QACvC,CAAC,CAAC,CAAE,IAAgD,CAAC,KAAK,IAAI,IAAI,CAAC;QACnE,CAAC,CAAC,IAAI,CAAA;IACV,MAAM,UAAU,GAAG,QAAQ,KAAK,IAAI,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAE,CAAC,IAAI,KAAK,QAAQ,CAAA;IAC7F,IAAI,CAAC,MAAM,IAAI,UAAU,EAAE,CAAC;QAC1B,UAAU,CAAC,IAAI,CAAC;YACd,IAAI,EAAE,4BAA4B;YAClC,KAAK;YACL,IAAI;YACJ,IAAI,EAAE,UAAU,CAAC,IAAI,CAAC;SACvB,CAAC,CAAA;IACJ,CAAC;AACH,CAAC;AAED,SAAS,UAAU,CAAC,CAAU;IAC5B,IAAI,CAAC,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,KAAK,IAAI,CAAC,IAAI,OAAQ,CAAsB,CAAC,GAAG,KAAK,QAAQ,EAAE,CAAC;QAChG,OAAQ,CAAqB,CAAC,GAAG,CAAA;IACnC,CAAC;IACD,OAAO,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;AAC9C,CAAC"}