@astrale-os/kernel-core 0.4.1

package/dist/graph/graph/graph.d.ts

@@ -0,0 +1,136 @@
+import type { Path } from '#graph/nav/path';
+import type { Step } from '#graph/nav/path/step';
+import type { EdgeId, NodeId } from '#ids';
+import type { Edge } from '../edge';
+import type { Node } from '../node';
+import type { PathIndex } from './indexes/path-index';
+import type { EdgeNamespace, NodeNamespace } from './namespaces';
+import type { WalkResult } from './walker';
+import { type GraphInputData } from './build';
+import { type AliasesWire } from './wire';
+/**
+ * A labeled, directed multigraph of Nodes and Edges, keyed by id and by primary
+ * `AbsolutePath.raw`. Immutable by construction: all nodes and edges are
+ * minted; there is no mutation API. To "change" a graph, derive a `Patch`
+ * (§4.7), apply it via the adapter pipeline, and promote the result.
+ *
+ * Address resolution separates into three primitives (§2.5):
+ * - `nodes.at(p)` — O(1) index hit; AbsolutePath only.
+ * - `nodes.get(p)` — walker-backed; any Path; returns Node or null (escape collapses).
+ * - `walk(p, start?)` — tagged `WalkResult`; escape-aware.
+ *
+ * Nodes and edges live in symmetric sub-namespaces (`graph.nodes`, `graph.edges`).
+ * Each exposes `all` (array), `byId`, `.length`, `filter`/`find`/`map`/iterator,
+ * plus typed queries (`nodes.at`/`nodes.get`; `edges.at`/`byClass`/`byStep`/`incident`).
+ *
+ * The walker algorithm itself lives in `./walker` as free functions over a
+ * `WalkContext` — this class wires its private index maps into that context
+ * and delegates. See `./walker` for `walkSteps`, `traverseStep`, and friends.
+ */
+export declare class Graph {
+    readonly root: Node;
+    private readonly _nodes;
+    private readonly _edges;
+    private readonly _nodeById;
+    private readonly _edgeById;
+    private readonly _nodeByPath;
+    private readonly _edgesByClass;
+    private readonly _edgesByEndpoint;
+    private readonly _edgesByEdgeClass;
+    private readonly _pathIndex;
+    private readonly _aliases;
+    readonly nodes: NodeNamespace;
+    readonly edges: EdgeNamespace;
+    /**
+     * Constructor — internal. Call sites must use `Graph.from` /
+     * `Graph.empty` / `Graph.fromWire`. The factory in `./from`
+     * pre-computes all index maps and passes them in.
+     *
+     * @internal
+     */
+    constructor(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);
+    /**
+     * Producer-supplied typed-form aliases (`nodeId → typed Path`),
+     * preserved as-is from the `GraphData.aliases` sidecar passed to
+     * `Graph.from`. Survives `toWire` / `fromWire` round-trips so wire
+     * consumers can rebuild a correct `PathIndex` over partial subgraphs
+     * (e.g. depth-0 trees from `getTree`) without having to re-derive
+     * what the producer already knew.
+     */
+    get aliases(): ReadonlyArray<readonly [NodeId, Path]> | null;
+    walk(path: Path, start?: Node): WalkResult;
+    /**
+     * Step-level walker variant — package-internal. Consumers should prefer
+     * `walk(path)`; `walkSteps` exists for the push pipeline's resolver which
+     * synthesizes a reversed step list rather than a concrete Path (§7).
+     */
+    walkSteps(steps: readonly Step[], start: Node): WalkResult;
+    /**
+     * Resolve a path to a node: primary AbsolutePath index → PathIndex
+     * typed-form aliases → full forward walk (escape-aware fallback).
+     * The PathIndex hop covers typed forms whose forward walk can't
+     * terminate (e.g. virtual mount-parents like `/space` in a nested
+     * DomainPath).
+     */
+    private _nodeGet;
+    /**
+     * Bundle the index references the walker reads from. Built fresh on
+     * every walk — the underlying maps are immutable post-construction,
+     * so this is just an object-literal allocation.
+     */
+    private _walkContext;
+    /**
+     * JSON-safe projection. All Paths collapse to `raw`. Symmetric with
+     * `Graph.fromWire`.
+     *
+     * Omits the virtual root (auto-injected via I1 when the caller did not
+     * supply a `/` node). Its class is a placeholder that wouldn't round-trip
+     * through the schema parser; since `fromWire` / `Graph.from` re-inject on
+     * read, the round-trip remains structure-preserving for virtual roots.
+     * Caller-supplied roots (real class, real id) are preserved.
+     *
+     * Emits `aliases` only when the producer supplied a non-empty alias
+     * sidecar (see {@link Graph.aliases}). Wire consumers rebuild a
+     * correct `PathIndex` over partial subgraphs by passing this back
+     * through {@link Graph.fromWire}; without it, typed-form lookups
+     * would silently miss on any tree shallow enough that `walkChain`
+     * can't derive the alias locally (every depth-0 `getTree`).
+     *
+     * Each alias's Path leaf collapses to its `.raw` string here —
+     * symmetric with `nodeToWire` / `edgeToWire`. Producers shouldn't
+     * rely on `JSON.stringify` to do the conversion; consumers downstream
+     * (notably `graphSchema.parse`) validate the in-process object before
+     * transport, expecting strings throughout.
+     */
+    toWire(): {
+        nodes: unknown[];
+        edges: unknown[];
+        aliases?: AliasesWire;
+    };
+    static empty(): Graph;
+    /**
+     * Build a `Graph` from `{ nodes, edges }`.
+     *
+     * Accepts typed specs (Path instances) and JSON-shaped specs (raw strings
+     * from `toWire`). If no `/`-pathed node is supplied, a virtual root with
+     * id `__SYSTEM__` is injected (I1). More than one `/` node raises.
+     *
+     * Implementation lives in `./from` to keep this class file focused on the
+     * post-construction surface (instance methods + namespaces).
+     */
+    static from(data: GraphInputData): Graph;
+    static fromWire(wire: WireGraph): Graph;
+}
+/**
+ * Wire-form input accepted by `Graph.fromWire` — the JSON shape a caller
+ * loads from disk or receives over the network. Exported so wire-boundary
+ * callers (CLI minters, host installers, codec utilities) can type their
+ * spec parameters directly instead of re-deriving via
+ * `Parameters<typeof Graph.fromWire>[0]`.
+ */
+export interface WireGraph {
+    readonly nodes: readonly unknown[];
+    readonly edges: readonly unknown[];
+    readonly aliases?: AliasesWire;
+}
+//# sourceMappingURL=graph.d.ts.map

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

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

package/dist/graph/graph/graph.js

@@ -0,0 +1,220 @@
+import { AbsolutePath } from '../tree/path/absolute-path';
+import { graphFrom } from './build';
+import { EMPTY_EDGES } from './indexes/edges';
+import { isVirtualRoot } from './root';
+import { edgesByStep as walkerEdgesByStep, edgeIncident as walkerEdgeIncident, walkSteps, } from './walker';
+import { aliasesFromWire, edgeToWire, nodeToWire } from './wire';
+/**
+ * A labeled, directed multigraph of Nodes and Edges, keyed by id and by primary
+ * `AbsolutePath.raw`. Immutable by construction: all nodes and edges are
+ * minted; there is no mutation API. To "change" a graph, derive a `Patch`
+ * (§4.7), apply it via the adapter pipeline, and promote the result.
+ *
+ * Address resolution separates into three primitives (§2.5):
+ * - `nodes.at(p)` — O(1) index hit; AbsolutePath only.
+ * - `nodes.get(p)` — walker-backed; any Path; returns Node or null (escape collapses).
+ * - `walk(p, start?)` — tagged `WalkResult`; escape-aware.
+ *
+ * Nodes and edges live in symmetric sub-namespaces (`graph.nodes`, `graph.edges`).
+ * Each exposes `all` (array), `byId`, `.length`, `filter`/`find`/`map`/iterator,
+ * plus typed queries (`nodes.at`/`nodes.get`; `edges.at`/`byClass`/`byStep`/`incident`).
+ *
+ * The walker algorithm itself lives in `./walker` as free functions over a
+ * `WalkContext` — this class wires its private index maps into that context
+ * and delegates. See `./walker` for `walkSteps`, `traverseStep`, and friends.
+ */
+export class Graph {
+    root;
+    _nodes;
+    _edges;
+    _nodeById;
+    _edgeById;
+    _nodeByPath;
+    _edgesByClass;
+    _edgesByEndpoint;
+    _edgesByEdgeClass;
+    _pathIndex;
+    _aliases;
+    nodes;
+    edges;
+    /**
+     * Constructor — internal. Call sites must use `Graph.from` /
+     * `Graph.empty` / `Graph.fromWire`. The factory in `./from`
+     * pre-computes all index maps and passes them in.
+     *
+     * @internal
+     */
+    constructor(nodes, edges, nodeById, edgeById, nodeByPath, edgesByClass, edgesByEndpoint, edgesByEdgeClass, root, pathIndex = null, aliases = null) {
+        this._nodes = nodes;
+        this._edges = edges;
+        this._nodeById = nodeById;
+        this._edgeById = edgeById;
+        this._nodeByPath = nodeByPath;
+        this._edgesByClass = edgesByClass;
+        this._edgesByEndpoint = edgesByEndpoint;
+        this._edgesByEdgeClass = edgesByEdgeClass;
+        this._pathIndex = pathIndex;
+        this._aliases = aliases;
+        this.root = root;
+        const allNodes = this._nodes;
+        this.nodes = {
+            all: allNodes,
+            get length() {
+                return allNodes.length;
+            },
+            byId: (id) => this._nodeById.get(id),
+            at: (p) => this._nodeByPath.get(p.raw),
+            get: (p) => this._nodeGet(p),
+            filter: (fn) => allNodes.filter(fn),
+            find: (fn) => allNodes.find(fn),
+            map: (fn) => allNodes.map(fn),
+            some: (fn) => allNodes.some(fn),
+            every: (fn) => allNodes.every(fn),
+            forEach: (fn) => allNodes.forEach(fn),
+            [Symbol.iterator]: () => allNodes[Symbol.iterator](),
+        };
+        const allEdges = this._edges;
+        this.edges = {
+            all: allEdges,
+            get length() {
+                return allEdges.length;
+            },
+            byId: (id) => this._edgeById.get(id),
+            at: (p) => this._edgesByEndpoint.get(p.raw) ?? EMPTY_EDGES,
+            byClass: (cls) => this._edgesByClass.get(cls.raw) ?? EMPTY_EDGES,
+            byStep: (step) => walkerEdgesByStep(step, this._walkContext()),
+            incident: (from, step) => walkerEdgeIncident(from, step, this._walkContext()),
+            filter: (fn) => allEdges.filter(fn),
+            find: (fn) => allEdges.find(fn),
+            map: (fn) => allEdges.map(fn),
+            some: (fn) => allEdges.some(fn),
+            every: (fn) => allEdges.every(fn),
+            forEach: (fn) => allEdges.forEach(fn),
+            [Symbol.iterator]: () => allEdges[Symbol.iterator](),
+        };
+    }
+    /**
+     * Producer-supplied typed-form aliases (`nodeId → typed Path`),
+     * preserved as-is from the `GraphData.aliases` sidecar passed to
+     * `Graph.from`. Survives `toWire` / `fromWire` round-trips so wire
+     * consumers can rebuild a correct `PathIndex` over partial subgraphs
+     * (e.g. depth-0 trees from `getTree`) without having to re-derive
+     * what the producer already knew.
+     */
+    get aliases() {
+        return this._aliases;
+    }
+    // ── Walker delegation ────────────────────────────────────────
+    walk(path, start = this.root) {
+        return walkSteps(path.steps, start, this._walkContext());
+    }
+    /**
+     * Step-level walker variant — package-internal. Consumers should prefer
+     * `walk(path)`; `walkSteps` exists for the push pipeline's resolver which
+     * synthesizes a reversed step list rather than a concrete Path (§7).
+     */
+    walkSteps(steps, start) {
+        return walkSteps(steps, start, this._walkContext());
+    }
+    /**
+     * Resolve a path to a node: primary AbsolutePath index → PathIndex
+     * typed-form aliases → full forward walk (escape-aware fallback).
+     * The PathIndex hop covers typed forms whose forward walk can't
+     * terminate (e.g. virtual mount-parents like `/space` in a nested
+     * DomainPath).
+     */
+    _nodeGet(path) {
+        if (path instanceof AbsolutePath) {
+            const direct = this._nodeByPath.get(path.raw);
+            if (direct !== undefined)
+                return direct;
+        }
+        if (this._pathIndex) {
+            const indexed = this._pathIndex.get(path.raw);
+            if (indexed !== null)
+                return indexed;
+        }
+        const result = this.walk(path, this.root);
+        return result.kind === 'node' ? result.node : null;
+    }
+    /**
+     * Bundle the index references the walker reads from. Built fresh on
+     * every walk — the underlying maps are immutable post-construction,
+     * so this is just an object-literal allocation.
+     */
+    _walkContext() {
+        return {
+            root: this.root,
+            nodeById: this._nodeById,
+            nodeByPath: this._nodeByPath,
+            edgesByEdgeClass: this._edgesByEdgeClass,
+            pathIndex: this._pathIndex,
+        };
+    }
+    // ── Serialization ───────────────────────────────────────────
+    /**
+     * JSON-safe projection. All Paths collapse to `raw`. Symmetric with
+     * `Graph.fromWire`.
+     *
+     * Omits the virtual root (auto-injected via I1 when the caller did not
+     * supply a `/` node). Its class is a placeholder that wouldn't round-trip
+     * through the schema parser; since `fromWire` / `Graph.from` re-inject on
+     * read, the round-trip remains structure-preserving for virtual roots.
+     * Caller-supplied roots (real class, real id) are preserved.
+     *
+     * Emits `aliases` only when the producer supplied a non-empty alias
+     * sidecar (see {@link Graph.aliases}). Wire consumers rebuild a
+     * correct `PathIndex` over partial subgraphs by passing this back
+     * through {@link Graph.fromWire}; without it, typed-form lookups
+     * would silently miss on any tree shallow enough that `walkChain`
+     * can't derive the alias locally (every depth-0 `getTree`).
+     *
+     * Each alias's Path leaf collapses to its `.raw` string here —
+     * symmetric with `nodeToWire` / `edgeToWire`. Producers shouldn't
+     * rely on `JSON.stringify` to do the conversion; consumers downstream
+     * (notably `graphSchema.parse`) validate the in-process object before
+     * transport, expecting strings throughout.
+     */
+    toWire() {
+        const nodes = [];
+        for (const n of this._nodes) {
+            if (isVirtualRoot(n))
+                continue;
+            nodes.push(nodeToWire(n));
+        }
+        const wire = {
+            nodes,
+            edges: this._edges.map(edgeToWire),
+        };
+        if (this._aliases !== null && this._aliases.length > 0) {
+            wire.aliases = this._aliases.map(([id, p]) => [id, p.raw]);
+        }
+        return wire;
+    }
+    // ── Factories ───────────────────────────────────────────────
+    static empty() {
+        return Graph.from({ nodes: [], edges: [] });
+    }
+    /**
+     * Build a `Graph` from `{ nodes, edges }`.
+     *
+     * Accepts typed specs (Path instances) and JSON-shaped specs (raw strings
+     * from `toWire`). If no `/`-pathed node is supplied, a virtual root with
+     * id `__SYSTEM__` is injected (I1). More than one `/` node raises.
+     *
+     * Implementation lives in `./from` to keep this class file focused on the
+     * post-construction surface (instance methods + namespaces).
+     */
+    static from(data) {
+        return graphFrom(data, Graph);
+    }
+    static fromWire(wire) {
+        const data = {
+            nodes: wire.nodes,
+            edges: wire.edges,
+            ...(wire.aliases ? { aliases: aliasesFromWire(wire.aliases) } : {}),
+        };
+        return Graph.from(data);
+    }
+}
+//# sourceMappingURL=graph.js.map

package/dist/graph/graph/graph.js.map

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

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

@@ -0,0 +1,24 @@
+/**
+ * Public surface of the `graph/graph/` module — the kernel `Graph`
+ * class, its construction-time input shape, sub-namespace types, and
+ * the build-time view consumed by the nav backward walker.
+ *
+ * `isVirtualRoot` is exposed for cross-module consumers (diff,
+ * deserialize, …) that need to skip the auto-injected `/` node when
+ * iterating user-visible content. Other `./root` helpers stay private.
+ * Index concerns (PathIndex, GraphView, edge/node index builders)
+ * live in the nested `./indexes/` subdomain — internal machinery for
+ * `Graph` construction, with `GraphView` / `BuildTimeView` re-exported
+ * here for nav consumption.
+ */
+export { Graph } from './graph';
+export type { WireGraph } from './graph';
+export { isVirtualRoot } from './root';
+export type { NodeNamespace, EdgeNamespace } from './namespaces';
+export type { WalkResult } from './walker';
+export type { GraphInputData } from './build';
+export type { GraphView } from './indexes';
+export { BuildTimeView } from './indexes';
+export { aliasesFromWire } from './wire';
+export type { AliasesWire } from './wire';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../graph/graph/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/B,YAAY,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAA;AACtC,YAAY,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAChE,YAAY,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAC1C,YAAY,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAC7C,YAAY,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAEzC,OAAO,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAA;AACxC,YAAY,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAA"}

package/dist/graph/graph/index.js

@@ -0,0 +1,18 @@
+/**
+ * Public surface of the `graph/graph/` module — the kernel `Graph`
+ * class, its construction-time input shape, sub-namespace types, and
+ * the build-time view consumed by the nav backward walker.
+ *
+ * `isVirtualRoot` is exposed for cross-module consumers (diff,
+ * deserialize, …) that need to skip the auto-injected `/` node when
+ * iterating user-visible content. Other `./root` helpers stay private.
+ * Index concerns (PathIndex, GraphView, edge/node index builders)
+ * live in the nested `./indexes/` subdomain — internal machinery for
+ * `Graph` construction, with `GraphView` / `BuildTimeView` re-exported
+ * here for nav consumption.
+ */
+export { Graph } from './graph';
+export { isVirtualRoot } from './root';
+export { BuildTimeView } from './indexes';
+export { aliasesFromWire } from './wire';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../graph/graph/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAE/B,OAAO,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAA;AAKtC,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAEzC,OAAO,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAA"}

package/dist/graph/graph/indexes/edges.d.ts

@@ -0,0 +1,23 @@
+import type { Edge } from '../../edge';
+/** Empty-edge sentinel reused by callers that return-on-miss. */
+export declare const EMPTY_EDGES: readonly Edge[];
+/**
+ * Index edges by full ClassPath raw (`class.<className>` form).
+ *
+ * Used by `Graph.edges.byClass(cls)` for O(1) class-keyed lookup.
+ */
+export declare function buildEdgesByClass(edges: readonly Edge[]): ReadonlyMap<string, readonly Edge[]>;
+/**
+ * Index edges by short class name (the `className` slug).
+ *
+ * Used by the walker — step predicates carry the short edge class
+ * name, not the fully-qualified ClassPath raw.
+ */
+export declare function buildEdgesByEdgeClass(edges: readonly Edge[]): ReadonlyMap<string, readonly Edge[]>;
+/**
+ * Index edges by either endpoint's raw — the `edges.at(path)` lookup
+ * returns every edge incident at the address, regardless of role.
+ * Self-loops register only once.
+ */
+export declare function buildEdgesByEndpoint(edges: readonly Edge[]): ReadonlyMap<string, readonly Edge[]>;
+//# sourceMappingURL=edges.d.ts.map

package/dist/graph/graph/indexes/edges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edges.d.ts","sourceRoot":"","sources":["../../../../graph/graph/indexes/edges.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAEtC,iEAAiE;AACjE,eAAO,MAAM,WAAW,EAAE,SAAS,IAAI,EAAsB,CAAA;AAE7D;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,GAAG,WAAW,CAAC,MAAM,EAAE,SAAS,IAAI,EAAE,CAAC,CAI9F;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,SAAS,IAAI,EAAE,GACrB,WAAW,CAAC,MAAM,EAAE,SAAS,IAAI,EAAE,CAAC,CAItC;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,GAAG,WAAW,CAAC,MAAM,EAAE,SAAS,IAAI,EAAE,CAAC,CASjG"}

package/dist/graph/graph/indexes/edges.js

@@ -0,0 +1,49 @@
+/** Empty-edge sentinel reused by callers that return-on-miss. */
+export const EMPTY_EDGES = Object.freeze([]);
+/**
+ * Index edges by full ClassPath raw (`class.<className>` form).
+ *
+ * Used by `Graph.edges.byClass(cls)` for O(1) class-keyed lookup.
+ */
+export function buildEdgesByClass(edges) {
+    const idx = new Map();
+    for (const e of edges)
+        pushTo(idx, e.class.raw, e);
+    return idx;
+}
+/**
+ * Index edges by short class name (the `className` slug).
+ *
+ * Used by the walker — step predicates carry the short edge class
+ * name, not the fully-qualified ClassPath raw.
+ */
+export function buildEdgesByEdgeClass(edges) {
+    const idx = new Map();
+    for (const e of edges)
+        pushTo(idx, e.class.className, e);
+    return idx;
+}
+/**
+ * Index edges by either endpoint's raw — the `edges.at(path)` lookup
+ * returns every edge incident at the address, regardless of role.
+ * Self-loops register only once.
+ */
+export function buildEdgesByEndpoint(edges) {
+    const idx = new Map();
+    for (const e of edges) {
+        const src = e.source.raw;
+        const tgt = e.target.raw;
+        pushTo(idx, src, e);
+        if (tgt !== src)
+            pushTo(idx, tgt, e);
+    }
+    return idx;
+}
+function pushTo(map, key, value) {
+    const bucket = map.get(key);
+    if (bucket)
+        bucket.push(value);
+    else
+        map.set(key, [value]);
+}
+//# sourceMappingURL=edges.js.map

package/dist/graph/graph/indexes/edges.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"edges.js","sourceRoot":"","sources":["../../../../graph/graph/indexes/edges.ts"],"names":[],"mappings":"AAEA,iEAAiE;AACjE,MAAM,CAAC,MAAM,WAAW,GAAoB,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAA;AAE7D;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,KAAsB;IACtD,MAAM,GAAG,GAAG,IAAI,GAAG,EAAkB,CAAA;IACrC,KAAK,MAAM,CAAC,IAAI,KAAK;QAAE,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,CAAA;IAClD,OAAO,GAAG,CAAA;AACZ,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,qBAAqB,CACnC,KAAsB;IAEtB,MAAM,GAAG,GAAG,IAAI,GAAG,EAAkB,CAAA;IACrC,KAAK,MAAM,CAAC,IAAI,KAAK;QAAE,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC,CAAC,CAAA;IACxD,OAAO,GAAG,CAAA;AACZ,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,oBAAoB,CAAC,KAAsB;IACzD,MAAM,GAAG,GAAG,IAAI,GAAG,EAAkB,CAAA;IACrC,KAAK,MAAM,CAAC,IAAI,KAAK,EAAE,CAAC;QACtB,MAAM,GAAG,GAAG,CAAC,CAAC,MAAM,CAAC,GAAG,CAAA;QACxB,MAAM,GAAG,GAAG,CAAC,CAAC,MAAM,CAAC,GAAG,CAAA;QACxB,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,CAAA;QACnB,IAAI,GAAG,KAAK,GAAG;YAAE,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,CAAA;IACtC,CAAC;IACD,OAAO,GAAG,CAAA;AACZ,CAAC;AAED,SAAS,MAAM,CAAI,GAAmB,EAAE,GAAM,EAAE,KAAW;IACzD,MAAM,MAAM,GAAG,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;IAC3B,IAAI,MAAM;QAAE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;;QACzB,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,CAAA;AAC5B,CAAC"}

package/dist/graph/graph/indexes/ids.d.ts

@@ -0,0 +1,15 @@
+import type { EdgeId, NodeId } from '#ids';
+import type { Edge } from '../../edge';
+import type { GraphViolation } from '../../errors';
+import type { Node } from '../../node';
+/**
+ * Build O(1) id-keyed maps for nodes and edges. Pushes
+ * `duplicate_node_id` / `duplicate_edge_id` violations into the shared
+ * accumulator when the same id appears twice — the caller decides
+ * whether to throw based on the full violation list.
+ */
+export declare function buildIdIndexes(nodes: readonly Node[], edges: readonly Edge[], violations: GraphViolation[]): {
+    nodeById: ReadonlyMap<NodeId, Node>;
+    edgeById: ReadonlyMap<EdgeId, Edge>;
+};
+//# sourceMappingURL=ids.d.ts.map

package/dist/graph/graph/indexes/ids.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ids.d.ts","sourceRoot":"","sources":["../../../../graph/graph/indexes/ids.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAE1C,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;AAEtC;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,UAAU,EAAE,cAAc,EAAE,GAC3B;IAAE,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,CAAA;CAAE,CAmB9E"}

package/dist/graph/graph/indexes/ids.js

@@ -0,0 +1,30 @@
+/**
+ * Build O(1) id-keyed maps for nodes and edges. Pushes
+ * `duplicate_node_id` / `duplicate_edge_id` violations into the shared
+ * accumulator when the same id appears twice — the caller decides
+ * whether to throw based on the full violation list.
+ */
+export function buildIdIndexes(nodes, edges, violations) {
+    const nodeById = new Map();
+    const edgeById = new Map();
+    for (const n of nodes) {
+        const id = n.id;
+        if (id === undefined)
+            continue;
+        if (nodeById.has(id))
+            violations.push({ kind: 'duplicate_node_id', nodeId: id });
+        else
+            nodeById.set(id, n);
+    }
+    for (const e of edges) {
+        const id = e.id;
+        if (id === undefined)
+            continue;
+        if (edgeById.has(id))
+            violations.push({ kind: 'duplicate_edge_id', edgeId: id });
+        else
+            edgeById.set(id, e);
+    }
+    return { nodeById, edgeById };
+}
+//# sourceMappingURL=ids.js.map

package/dist/graph/graph/indexes/ids.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ids.js","sourceRoot":"","sources":["../../../../graph/graph/indexes/ids.ts"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAC5B,KAAsB,EACtB,KAAsB,EACtB,UAA4B;IAE5B,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAgB,CAAA;IACxC,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAgB,CAAA;IAExC,KAAK,MAAM,CAAC,IAAI,KAAK,EAAE,CAAC;QACtB,MAAM,EAAE,GAAG,CAAC,CAAC,EAAE,CAAA;QACf,IAAI,EAAE,KAAK,SAAS;YAAE,SAAQ;QAC9B,IAAI,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YAAE,UAAU,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,mBAAmB,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,CAAA;;YAC3E,QAAQ,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC,CAAA;IAC1B,CAAC;IAED,KAAK,MAAM,CAAC,IAAI,KAAK,EAAE,CAAC;QACtB,MAAM,EAAE,GAAG,CAAC,CAAC,EAAE,CAAA;QACf,IAAI,EAAE,KAAK,SAAS;YAAE,SAAQ;QAC9B,IAAI,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YAAE,UAAU,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,mBAAmB,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,CAAA;;YAC3E,QAAQ,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC,CAAA;IAC1B,CAAC;IAED,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAA;AAC/B,CAAC"}

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

@@ -0,0 +1,22 @@
+/**
+ * All index data structures and builders for `Graph`.
+ *
+ * Two layers:
+ *   - **Builders** — pure functions called by `Graph.from` to derive
+ *     the index maps from raw node/edge arrays (`ids`, `nodes`,
+ *     `edges`).
+ *   - **Composite indexes** — the multi-key {@link PathIndex} (built
+ *     via fixpoint) and the {@link GraphView} read interface that
+ *     wraps them for the backward walker.
+ *
+ * Internal to `Graph` construction; not part of the kernel's
+ * authoring surface. `GraphView` and `BuildTimeView` are re-exported
+ * from `#graph` for the nav layer.
+ */
+export { buildIdIndexes } from './ids';
+export { buildNodeByPath } from './nodes';
+export { EMPTY_EDGES, buildEdgesByClass, buildEdgesByEdgeClass, buildEdgesByEndpoint, } from './edges';
+export { PathIndex } from './path-index';
+export type { GraphView } from './view';
+export { BuildTimeView } from './view';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../graph/graph/indexes/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,OAAO,CAAA;AACtC,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AACzC,OAAO,EACL,WAAW,EACX,iBAAiB,EACjB,qBAAqB,EACrB,oBAAoB,GACrB,MAAM,SAAS,CAAA;AAChB,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AACxC,YAAY,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;AACvC,OAAO,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAA"}

package/dist/graph/graph/indexes/index.js

@@ -0,0 +1,21 @@
+/**
+ * All index data structures and builders for `Graph`.
+ *
+ * Two layers:
+ *   - **Builders** — pure functions called by `Graph.from` to derive
+ *     the index maps from raw node/edge arrays (`ids`, `nodes`,
+ *     `edges`).
+ *   - **Composite indexes** — the multi-key {@link PathIndex} (built
+ *     via fixpoint) and the {@link GraphView} read interface that
+ *     wraps them for the backward walker.
+ *
+ * Internal to `Graph` construction; not part of the kernel's
+ * authoring surface. `GraphView` and `BuildTimeView` are re-exported
+ * from `#graph` for the nav layer.
+ */
+export { buildIdIndexes } from './ids';
+export { buildNodeByPath } from './nodes';
+export { EMPTY_EDGES, buildEdgesByClass, buildEdgesByEdgeClass, buildEdgesByEndpoint, } from './edges';
+export { PathIndex } from './path-index';
+export { BuildTimeView } from './view';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../graph/graph/indexes/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,OAAO,CAAA;AACtC,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AACzC,OAAO,EACL,WAAW,EACX,iBAAiB,EACjB,qBAAqB,EACrB,oBAAoB,GACrB,MAAM,SAAS,CAAA;AAChB,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAExC,OAAO,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAA"}

package/dist/graph/graph/indexes/nodes.d.ts

@@ -0,0 +1,15 @@
+import type { Node } from '../../node';
+/**
+ * Build the primary path-keyed index: `path.raw` → Node.
+ *
+ * Distinct from {@link PathIndex} — this map is keyed only by each
+ * node's primary `AbsolutePath.raw`. The PathIndex is a multi-key
+ * superset that also registers typed-form aliases produced by
+ * registered PathTypes.
+ *
+ * Used by `Graph` for `nodes.at(path)` (O(1) AbsolutePath lookup) and
+ * by the walker's `traverseStep` to advance to an in-graph endpoint
+ * when the edge's target raw is a primary AbsolutePath.
+ */
+export declare function buildNodeByPath(nodes: readonly Node[]): ReadonlyMap<string, Node>;
+//# sourceMappingURL=nodes.d.ts.map

package/dist/graph/graph/indexes/nodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodes.d.ts","sourceRoot":"","sources":["../../../../graph/graph/indexes/nodes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAEtC;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,GAAG,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,CAMjF"}