@statelyai/graph 1.0.0 → 2.0.0

package/dist/schemas.d.mts

@@ -1,4 +1,4 @@
-import { _ as GraphNode, b as GraphPort, p as GraphEdge, u as Graph } from "./types-3-FS9NV2.mjs";
+import { d as Graph, m as GraphEdge, v as GraphNode, x as GraphPort } from "./types-DNYdIU21.mjs";
 import * as z from "zod";
 
 //#region src/schemas.d.ts

package/dist/schemas.mjs

@@ -1,3 +1,4 @@
+import { t as getGraphIssues$1 } from "./validate-TtH-x3JV.mjs";
 import * as z from "zod";
 
 //#region src/schemas.ts
@@ -116,37 +117,30 @@ function createIssue(code, message, path) {
 		path
 	};
 }
-function getDuplicateIndexes(items, getKey) {
-	const indexesByKey = /* @__PURE__ */ new Map();
-	items.forEach((item, index) => {
-		const key = getKey(item);
-		if (key == null) return;
-		const indexes = indexesByKey.get(key) ?? [];
-		indexes.push(index);
-		indexesByKey.set(key, indexes);
-	});
-	for (const [key, indexes] of indexesByKey) if (indexes.length < 2) indexesByKey.delete(key);
-	return indexesByKey;
+/** Maps structural issue codes from `validate.ts` to this module's codes. */
+const STRUCTURAL_CODE_MAP = {
+	"duplicate-node-id": "duplicate_node_id",
+	"duplicate-edge-id": "duplicate_edge_id",
+	"missing-initial-node": "missing_initial_node",
+	"missing-parent": "missing_parent",
+	"missing-node-initial": "missing_node_initial",
+	"duplicate-port-name": "duplicate_port_name",
+	"parent-cycle": "parent_cycle",
+	"missing-source-port": "missing_source_port",
+	"missing-target-port": "missing_target_port"
+};
+function toValidationIssue(issue) {
+	const path = issue.path ?? [];
+	let code = STRUCTURAL_CODE_MAP[issue.code] ?? issue.code;
+	if (issue.code === "dangling-edge-endpoint") code = path[path.length - 1] === "sourceId" ? "missing_source_node" : "missing_target_node";
+	return {
+		code,
+		message: issue.message,
+		path
+	};
 }
 function getGraphInvariantIssues(graph) {
-	const issues = [];
-	const nodeIndexes = /* @__PURE__ */ new Map();
-	const nodesById = /* @__PURE__ */ new Map();
-	for (const [id, indexes] of getDuplicateIndexes(graph.nodes, (node) => node.id)) for (const index of indexes) issues.push(createIssue("duplicate_node_id", `Duplicate node id "${id}"`, [
-		"nodes",
-		index,
-		"id"
-	]));
-	for (const [id, indexes] of getDuplicateIndexes(graph.edges, (edge) => edge.id)) for (const index of indexes) issues.push(createIssue("duplicate_edge_id", `Duplicate edge id "${id}"`, [
-		"edges",
-		index,
-		"id"
-	]));
-	graph.nodes.forEach((node, index) => {
-		nodeIndexes.set(node.id, index);
-		nodesById.set(node.id, node);
-	});
-	if (graph.initialNodeId && !nodeIndexes.has(graph.initialNodeId)) issues.push(createIssue("missing_initial_node", `Initial node "${graph.initialNodeId}" does not exist`, ["initialNodeId"]));
+	const issues = getGraphIssues$1(graph).map(toValidationIssue);
 	graph.nodes.forEach((node, index) => {
 		if (node.id === "") issues.push(createIssue("empty_node_id", "Node id must be a non-empty string", [
 			"nodes",
@@ -158,68 +152,13 @@ function getGraphInvariantIssues(graph) {
 			index,
 			"parentId"
 		]));
-		else if (node.parentId != null && !nodeIndexes.has(node.parentId)) issues.push(createIssue("missing_parent", `Parent node "${node.parentId}" does not exist`, [
-			"nodes",
-			index,
-			"parentId"
-		]));
-		if (node.initialNodeId && !nodeIndexes.has(node.initialNodeId)) issues.push(createIssue("missing_node_initial", `Initial node "${node.initialNodeId}" does not exist`, [
-			"nodes",
-			index,
-			"initialNodeId"
-		]));
-		for (const [name, indexes] of getDuplicateIndexes(node.ports ?? [], (port) => port.name)) for (const portIndex of indexes) issues.push(createIssue("duplicate_port_name", `Duplicate port name "${name}" on node "${node.id}"`, [
-			"nodes",
-			index,
-			"ports",
-			portIndex,
-			"name"
-		]));
 	});
-	for (const node of graph.nodes) {
-		const seen = /* @__PURE__ */ new Set();
-		let current = node.parentId;
-		while (current != null) {
-			if (current === node.id || seen.has(current)) {
-				issues.push(createIssue("parent_cycle", `Node "${node.id}" is part of a parent cycle`, [
-					"nodes",
-					nodeIndexes.get(node.id) ?? 0,
-					"parentId"
-				]));
-				break;
-			}
-			seen.add(current);
-			current = nodesById.get(current)?.parentId;
-		}
-	}
 	graph.edges.forEach((edge, index) => {
 		if (edge.id === "") issues.push(createIssue("empty_edge_id", "Edge id must be a non-empty string", [
 			"edges",
 			index,
 			"id"
 		]));
-		const source = nodesById.get(edge.sourceId);
-		const target = nodesById.get(edge.targetId);
-		if (!source) issues.push(createIssue("missing_source_node", `Source node "${edge.sourceId}" does not exist`, [
-			"edges",
-			index,
-			"sourceId"
-		]));
-		if (!target) issues.push(createIssue("missing_target_node", `Target node "${edge.targetId}" does not exist`, [
-			"edges",
-			index,
-			"targetId"
-		]));
-		if (source && edge.sourcePort !== void 0 && !source.ports?.some((port) => port.name === edge.sourcePort)) issues.push(createIssue("missing_source_port", `Port "${edge.sourcePort}" does not exist on source node "${edge.sourceId}"`, [
-			"edges",
-			index,
-			"sourcePort"
-		]));
-		if (target && edge.targetPort !== void 0 && !target.ports?.some((port) => port.name === edge.targetPort)) issues.push(createIssue("missing_target_port", `Port "${edge.targetPort}" does not exist on target node "${edge.targetId}"`, [
-			"edges",
-			index,
-			"targetPort"
-		]));
 	});
 	return issues;
 }

package/dist/{types-3-FS9NV2.d.mts → types-DNYdIU21.d.mts}

@@ -177,15 +177,64 @@ interface VisualGraphConfig<TNodeData = any, TEdgeData = any, TGraphData = any,
 interface DeleteNodeOptions {
   reparent?: boolean;
 }
+/**
+ * Update payload for {@link updateNode}/`updateEntities`.
+ *
+ * Optional fields (`x`, `y`, `width`, `height`, `shape`, `color`, `style`,
+ * `ports`) accept `null` to **unset** the field. `undefined` (or omitting the
+ * key) leaves the field unchanged. `null` is used for unsetting so update
+ * payloads stay JSON-serializable.
+ */
+interface NodeUpdate<TNodeData = any, TPortData = any> {
+  parentId?: string | null;
+  initialNodeId?: string | null;
+  label?: string | null;
+  data?: TNodeData;
+  /** New ports for the node, or `null` to remove all ports. */
+  ports?: PortConfig<TPortData>[] | null;
+  x?: number | null;
+  y?: number | null;
+  width?: number | null;
+  height?: number | null;
+  shape?: string | null;
+  color?: string | null;
+  style?: Record<string, string | number | boolean> | null;
+}
+/**
+ * Update payload for {@link updateEdge}/`updateEntities`.
+ *
+ * Optional fields (`weight`, `mode`, `sourcePort`, `targetPort`, `x`, `y`,
+ * `width`, `height`, `color`, `style`) accept `null` to **unset** the field.
+ * `undefined` (or omitting the key) leaves the field unchanged. `null` is
+ * used for unsetting so update payloads stay JSON-serializable.
+ */
+interface EdgeUpdate<TEdgeData = any> {
+  sourceId?: string;
+  targetId?: string;
+  label?: string | null;
+  data?: TEdgeData;
+  weight?: number | null;
+  mode?: GraphMode | null;
+  /** Port name on the source node, or `null` to clear the port reference. */
+  sourcePort?: string | null;
+  /** Port name on the target node, or `null` to clear the port reference. */
+  targetPort?: string | null;
+  x?: number | null;
+  y?: number | null;
+  width?: number | null;
+  height?: number | null;
+  color?: string | null;
+  style?: Record<string, string | number | boolean> | null;
+}
 interface EntitiesConfig<TNodeData = any, TEdgeData = any, TPortData = any> {
   nodes?: NodeConfig<TNodeData, TPortData>[];
   edges?: EdgeConfig<TEdgeData>[];
 }
 interface EntitiesUpdate<TNodeData = any, TEdgeData = any, TPortData = any> {
-  nodes?: (Partial<Omit<NodeConfig<TNodeData, TPortData>, 'id'>> & {
+  nodes?: (NodeUpdate<TNodeData, TPortData> & {
     id: string;
   })[];
-  edges?: (Partial<Omit<EdgeConfig<TEdgeData>, 'id'>> & {
+  edges?: (EdgeUpdate<TEdgeData> & {
     id: string;
   })[];
 }
@@ -281,7 +330,7 @@ type GraphPatch<TNodeData = any, TEdgeData = any> = {
 } | {
   op: 'updateNode';
   id: string;
-  data: Partial<Omit<NodeConfig<TNodeData>, 'id'>>;
+  data: NodeUpdate<TNodeData>;
   description?: string;
 } | {
   op: 'deleteNode';
@@ -294,7 +343,7 @@ type GraphPatch<TNodeData = any, TEdgeData = any> = {
 } | {
   op: 'updateEdge';
   id: string;
-  data: Partial<Omit<EdgeConfig<TEdgeData>, 'id'>>;
+  data: EdgeUpdate<TEdgeData>;
   description?: string;
 } | {
   op: 'deleteEdge';
@@ -375,4 +424,4 @@ interface TransitionOptions<TState, TEvent> {
   id?: string;
 }
 //#endregion
-export { TraversalOptions as A, WeightedWalkOptions as B, NodeChange as C, PortDirection as D, PortConfig as E, VisualGraphFormatConverter as F, VisualNode as I, VisualPort as L, VisualGraph as M, VisualGraphConfig as N, SinglePathOptions as O, VisualGraphEntity as P, WalkContext as R, MSTOptions as S, PathOptions as T, GraphNode as _, EdgeChange as a, GraphPort as b, EntitiesUpdate as c, GraphConfig as d, GraphDiff as f, GraphMode as g, GraphFormatConverter as h, DeleteNodeOptions as i, VisualEdge as j, TransitionOptions as k, EntityRect as l, GraphEntity as m, AllPairsShortestPathsOptions as n, EdgeConfig as o, GraphEdge as p, CoverageStats as r, EntitiesConfig as s, AStarOptions as t, Graph as u, GraphPatch as v, NodeConfig as w, GraphStep as x, GraphPath as y, WalkOptions as z };
+export { SinglePathOptions as A, WalkContext as B, MSTOptions as C, PathOptions as D, NodeUpdate as E, VisualGraphConfig as F, WeightedWalkOptions as H, VisualGraphEntity as I, VisualGraphFormatConverter as L, TraversalOptions as M, VisualEdge as N, PortConfig as O, VisualGraph as P, VisualNode as R, GraphStep as S, NodeConfig as T, WalkOptions as V, GraphMode as _, EdgeChange as a, GraphPath as b, EntitiesConfig as c, Graph as d, GraphConfig as f, GraphFormatConverter as g, GraphEntity as h, DeleteNodeOptions as i, TransitionOptions as j, PortDirection as k, EntitiesUpdate as l, GraphEdge as m, AllPairsShortestPathsOptions as n, EdgeConfig as o, GraphDiff as p, CoverageStats as r, EdgeUpdate as s, AStarOptions as t, EntityRect as u, GraphNode as v, NodeChange as w, GraphPort as x, GraphPatch as y, VisualPort as z };

package/dist/validate-TtH-x3JV.mjs

@@ -0,0 +1,190 @@
+//#region src/validate.ts
+function getDuplicateIndexes(items, getKey) {
+	const indexesByKey = /* @__PURE__ */ new Map();
+	items.forEach((item, index) => {
+		const key = getKey(item);
+		if (key == null) return;
+		const indexes = indexesByKey.get(key) ?? [];
+		indexes.push(index);
+		indexesByKey.set(key, indexes);
+	});
+	for (const [key, indexes] of indexesByKey) if (indexes.length < 2) indexesByKey.delete(key);
+	return indexesByKey;
+}
+/**
+* Returns the parent cycles in a graph's hierarchy, each cycle reported once
+* as the list of node ids forming the cycle (cycle members only — nodes whose
+* ancestry merely *leads into* a cycle are not included).
+*/
+function getParentCycles(nodesById) {
+	const cycles = [];
+	const visited = /* @__PURE__ */ new Set();
+	for (const startId of nodesById.keys()) {
+		if (visited.has(startId)) continue;
+		const path = [];
+		const positions = /* @__PURE__ */ new Map();
+		let currentId = startId;
+		while (currentId != null && !visited.has(currentId) && nodesById.has(currentId)) {
+			const position = positions.get(currentId);
+			if (position !== void 0) {
+				cycles.push(path.slice(position));
+				break;
+			}
+			positions.set(currentId, path.length);
+			path.push(currentId);
+			currentId = nodesById.get(currentId).parentId;
+		}
+		for (const id of path) visited.add(id);
+	}
+	return cycles;
+}
+/**
+* Validates the structural invariants of a graph and returns the issues
+* found, or `[]` when the graph is valid. Pure — never throws, never mutates.
+*
+* This is the recommended gate for untrusted or imported graphs (e.g. parsed
+* from a file or received over the wire) before handing them to queries and
+* algorithms: the mutation APIs (`addNode`, `addEdge`, `updateNode`, …)
+* validate incrementally, but `createGraph` does **not** — it accepts
+* dangling `parentId`/edge references and even `parentId` cycles as-is.
+*
+* For Zod-based shape validation of arbitrary unknown values, see
+* `validateGraph` in `@statelyai/graph/schemas` (which reuses these checks).
+*
+* Issue codes: `duplicate-node-id`, `duplicate-edge-id`,
+* `missing-initial-node`, `missing-parent`, `missing-node-initial`,
+* `duplicate-port-name`, `parent-cycle`, `dangling-edge-endpoint`,
+* `missing-source-port`, `missing-target-port`.
+*
+* @example
+* ```ts
+* const graph = createGraph({
+*   nodes: [{ id: 'a', parentId: 'ghost' }],
+*   edges: [{ id: 'e1', sourceId: 'a', targetId: 'b' }],
+* });
+* getGraphIssues(graph);
+* // => [
+* //   { code: 'missing-parent', message: '...', path: ['nodes', 0, 'parentId'] },
+* //   { code: 'dangling-edge-endpoint', message: '...', path: ['edges', 0, 'targetId'] },
+* // ]
+* ```
+*/
+function getGraphIssues(graph) {
+	const issues = [];
+	const nodeIndexes = /* @__PURE__ */ new Map();
+	const nodesById = /* @__PURE__ */ new Map();
+	graph.nodes.forEach((node, index) => {
+		nodeIndexes.set(node.id, index);
+		nodesById.set(node.id, node);
+	});
+	for (const [id, indexes] of getDuplicateIndexes(graph.nodes, (node) => node.id)) for (const index of indexes) issues.push({
+		code: "duplicate-node-id",
+		message: `Duplicate node id "${id}". Node ids must be unique; rename or remove the duplicates.`,
+		path: [
+			"nodes",
+			index,
+			"id"
+		]
+	});
+	for (const [id, indexes] of getDuplicateIndexes(graph.edges, (edge) => edge.id)) for (const index of indexes) issues.push({
+		code: "duplicate-edge-id",
+		message: `Duplicate edge id "${id}". Edge ids must be unique; rename or remove the duplicates.`,
+		path: [
+			"edges",
+			index,
+			"id"
+		]
+	});
+	if (graph.initialNodeId && !nodesById.has(graph.initialNodeId)) issues.push({
+		code: "missing-initial-node",
+		message: `Graph initialNodeId references missing node "${graph.initialNodeId}". Add that node or update the graph's initialNodeId.`,
+		path: ["initialNodeId"]
+	});
+	graph.nodes.forEach((node, index) => {
+		if (node.parentId != null && !nodesById.has(node.parentId)) issues.push({
+			code: "missing-parent",
+			message: `Node "${node.id}" has parentId "${node.parentId}", which does not exist. Add that node or remove the parentId.`,
+			path: [
+				"nodes",
+				index,
+				"parentId"
+			]
+		});
+		if (node.initialNodeId && !nodesById.has(node.initialNodeId)) issues.push({
+			code: "missing-node-initial",
+			message: `Node "${node.id}" has initialNodeId "${node.initialNodeId}", which does not exist. Add that node or remove the initialNodeId.`,
+			path: [
+				"nodes",
+				index,
+				"initialNodeId"
+			]
+		});
+		for (const [name, portIndexes] of getDuplicateIndexes(node.ports ?? [], (port) => port.name)) for (const portIndex of portIndexes) issues.push({
+			code: "duplicate-port-name",
+			message: `Duplicate port name "${name}" on node "${node.id}". Port names must be unique per node; rename or remove the duplicates.`,
+			path: [
+				"nodes",
+				index,
+				"ports",
+				portIndex,
+				"name"
+			]
+		});
+	});
+	for (const cycle of getParentCycles(nodesById)) {
+		const chain = [...cycle, cycle[0]].join(" → ");
+		issues.push({
+			code: "parent-cycle",
+			message: `Parent cycle detected: ${chain}. Break the cycle by changing the parentId of one of these nodes.`,
+			path: [
+				"nodes",
+				nodeIndexes.get(cycle[0]) ?? 0,
+				"parentId"
+			]
+		});
+	}
+	graph.edges.forEach((edge, index) => {
+		const source = nodesById.get(edge.sourceId);
+		const target = nodesById.get(edge.targetId);
+		if (!source) issues.push({
+			code: "dangling-edge-endpoint",
+			message: `Edge "${edge.id}" has sourceId "${edge.sourceId}", which references a missing node. Add that node or fix the edge's sourceId.`,
+			path: [
+				"edges",
+				index,
+				"sourceId"
+			]
+		});
+		if (!target) issues.push({
+			code: "dangling-edge-endpoint",
+			message: `Edge "${edge.id}" has targetId "${edge.targetId}", which references a missing node. Add that node or fix the edge's targetId.`,
+			path: [
+				"edges",
+				index,
+				"targetId"
+			]
+		});
+		if (source && edge.sourcePort !== void 0 && !source.ports?.some((port) => port.name === edge.sourcePort)) issues.push({
+			code: "missing-source-port",
+			message: `Edge "${edge.id}" has sourcePort "${edge.sourcePort}", but source node "${edge.sourceId}" has no port with that name. Add the port or fix the edge's sourcePort.`,
+			path: [
+				"edges",
+				index,
+				"sourcePort"
+			]
+		});
+		if (target && edge.targetPort !== void 0 && !target.ports?.some((port) => port.name === edge.targetPort)) issues.push({
+			code: "missing-target-port",
+			message: `Edge "${edge.id}" has targetPort "${edge.targetPort}", but target node "${edge.targetId}" has no port with that name. Add the port or fix the edge's targetPort.`,
+			path: [
+				"edges",
+				index,
+				"targetPort"
+			]
+		});
+	});
+	return issues;
+}
+
+//#endregion
+export { getGraphIssues as t };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@statelyai/graph",
   "type": "module",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "A TypeScript-first graph library with plain JSON-serializable objects",
   "author": "David Khourshid <david@stately.ai>",
   "license": "MIT",
@@ -52,12 +52,13 @@
     "schemas"
   ],
   "devDependencies": {
-    "publint": "^0.3.15",
     "@changesets/changelog-github": "^0.5.2",
     "@changesets/cli": "^2.29.8",
+    "@dagrejs/graphlib": "^4.0.1",
     "@types/d3-array": "^3.2.2",
     "@types/d3-force": "^3.0.10",
     "@types/node": "^25.0.3",
+    "@vitest/coverage-v8": "^4.0.18",
     "@xyflow/system": "^0.0.75",
     "bumpp": "^10.3.2",
     "cytoscape": "^3.33.1",
@@ -66,6 +67,14 @@
     "dotparser": "^1.1.1",
     "elkjs": "^0.11.1",
     "fast-xml-parser": "^5.3.4",
+    "graphology": "^0.26.0",
+    "graphology-components": "^1.5.4",
+    "graphology-metrics": "^2.4.0",
+    "graphology-shortest-path": "^2.1.0",
+    "graphology-types": "^0.24.8",
+    "ngraph.graph": "^20.1.2",
+    "ngraph.path": "^1.6.1",
+    "publint": "^0.3.15",
     "tsdown": "^0.18.1",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
@@ -114,6 +123,7 @@
     "generate-schema": "tsx scripts/generate-json-schema.ts",
     "changeset": "changeset",
     "version": "changeset version",
-    "release": "pnpm run build && changeset publish"
+    "release": "pnpm run build && changeset publish",
+    "bench:compare": "tsx bench/compare/run.ts"
   }
 }

package/dist/indexing-DR8M1vBy.mjs

@@ -1,137 +0,0 @@
-//#region src/indexing.ts
-const indexes = /* @__PURE__ */ new WeakMap();
-/**
-* Get or lazily build the index for a graph.
-* Auto-rebuilds when node/edge count changes.
-*
-* @example
-* ```ts
-* import { createGraph, getIndex } from '@statelyai/graph';
-*
-* const graph = createGraph({
-*   nodes: [{ id: 'a' }, { id: 'b' }],
-*   edges: [{ id: 'e1', sourceId: 'a', targetId: 'b' }],
-* });
-*
-* const idx = getIndex(graph);
-* idx.nodeById.get('a'); // 0
-* idx.outEdges.get('a'); // ['e1']
-* ```
-*/
-function getIndex(graph) {
-	let idx = indexes.get(graph);
-	const sameStructure = idx && idx.nodeCount === graph.nodes.length && idx.edgeCount === graph.edges.length;
-	const signature = idx !== void 0 && sameStructure && idx.nodesRef === graph.nodes && idx.edgesRef === graph.edges ? getIndexSignature(graph) : void 0;
-	if (!idx || idx.nodeCount !== graph.nodes.length || idx.edgeCount !== graph.edges.length || signature !== void 0 && idx.signature !== signature) {
-		idx = buildIndex(graph, signature ?? getIndexSignature(graph));
-		indexes.set(graph, idx);
-	}
-	return idx;
-}
-/**
-* Clear the cached index. Call this if you mutate graph.nodes/edges directly.
-*
-* @example
-* ```ts
-* import { createGraph, invalidateIndex, getIndex } from '@statelyai/graph';
-*
-* const graph = createGraph({ nodes: [{ id: 'a' }], edges: [] });
-* // manually mutate nodes array
-* graph.nodes.push({ type: 'node', id: 'b', parentId: null, initialNodeId: null, label: '', data: undefined });
-* invalidateIndex(graph); // forces rebuild on next getIndex()
-* ```
-*/
-function invalidateIndex(graph) {
-	indexes.delete(graph);
-}
-function getIndexSignature(graph) {
-	const nodeParts = graph.nodes.map((node) => `${node.id}\u0000${node.parentId ?? ""}`);
-	const edgeParts = graph.edges.map((edge) => `${edge.id}\u0000${edge.sourceId}\u0000${edge.targetId}`);
-	return `${nodeParts.join("
")}\u0002${edgeParts.join("
")}`;
-}
-function buildIndex(graph, signature) {
-	const nodeById = /* @__PURE__ */ new Map();
-	const edgeById = /* @__PURE__ */ new Map();
-	const outEdges = /* @__PURE__ */ new Map();
-	const inEdges = /* @__PURE__ */ new Map();
-	const childNodes = /* @__PURE__ */ new Map();
-	for (let i = 0; i < graph.nodes.length; i++) {
-		const n = graph.nodes[i];
-		nodeById.set(n.id, i);
-		outEdges.set(n.id, []);
-		inEdges.set(n.id, []);
-		const parent = n.parentId ?? null;
-		if (!childNodes.has(parent)) childNodes.set(parent, []);
-		childNodes.get(parent).push(n.id);
-	}
-	for (let i = 0; i < graph.edges.length; i++) {
-		const e = graph.edges[i];
-		edgeById.set(e.id, i);
-		outEdges.get(e.sourceId)?.push(e.id);
-		inEdges.get(e.targetId)?.push(e.id);
-	}
-	return {
-		nodeById,
-		edgeById,
-		outEdges,
-		inEdges,
-		childNodes,
-		nodeCount: graph.nodes.length,
-		edgeCount: graph.edges.length,
-		signature,
-		nodesRef: graph.nodes,
-		edgesRef: graph.edges
-	};
-}
-function indexAddNode(idx, node, arrayIndex) {
-	idx.nodeById.set(node.id, arrayIndex);
-	idx.outEdges.set(node.id, []);
-	idx.inEdges.set(node.id, []);
-	const parent = node.parentId ?? null;
-	if (!idx.childNodes.has(parent)) idx.childNodes.set(parent, []);
-	idx.childNodes.get(parent).push(node.id);
-	idx.nodeCount++;
-	idx.signature = "";
-}
-function indexAddEdge(idx, edge, arrayIndex) {
-	idx.edgeById.set(edge.id, arrayIndex);
-	idx.outEdges.get(edge.sourceId)?.push(edge.id);
-	idx.inEdges.get(edge.targetId)?.push(edge.id);
-	idx.edgeCount++;
-	idx.signature = "";
-}
-/** Update childNodes index when a node's parentId changes. */
-function indexReparentNode(idx, nodeId, oldParentId, newParentId) {
-	const oldSiblings = idx.childNodes.get(oldParentId ?? null);
-	if (oldSiblings) {
-		const pos = oldSiblings.indexOf(nodeId);
-		if (pos !== -1) oldSiblings.splice(pos, 1);
-	}
-	const np = newParentId ?? null;
-	if (!idx.childNodes.has(np)) idx.childNodes.set(np, []);
-	idx.childNodes.get(np).push(nodeId);
-	idx.signature = "";
-}
-/** Update adjacency lists when an edge's sourceId/targetId changes. */
-function indexUpdateEdgeEndpoints(idx, edgeId, oldSourceId, oldTargetId, newSourceId, newTargetId) {
-	if (oldSourceId !== newSourceId) {
-		const oldOut = idx.outEdges.get(oldSourceId);
-		if (oldOut) {
-			const pos = oldOut.indexOf(edgeId);
-			if (pos !== -1) oldOut.splice(pos, 1);
-		}
-		idx.outEdges.get(newSourceId)?.push(edgeId);
-	}
-	if (oldTargetId !== newTargetId) {
-		const oldIn = idx.inEdges.get(oldTargetId);
-		if (oldIn) {
-			const pos = oldIn.indexOf(edgeId);
-			if (pos !== -1) oldIn.splice(pos, 1);
-		}
-		idx.inEdges.get(newTargetId)?.push(edgeId);
-	}
-	idx.signature = "";
-}
-
-//#endregion
-export { indexUpdateEdgeEndpoints as a, indexReparentNode as i, indexAddEdge as n, invalidateIndex as o, indexAddNode as r, getIndex as t };