@statelyai/graph 0.13.0 → 1.0.0

package/dist/index.mjs

@@ -1,7 +1,8 @@
-import { o as invalidateIndex, t as getIndex } from "./indexing-DUl3kTqm.mjs";
-import { $ as createGraphPort, A as isAcyclic, B as getShortestPaths, C as getPreorder, D as getConnectedComponents, E as dfs, F as genSimplePaths, G as GraphInstance, H as getSimplePaths, I as getAStarPath, J as addNode, K as addEdge, L as getAllPairsShortestPaths, M as isTree, N as genCycles, O as getTopologicalSort, P as genShortestPaths, Q as createGraphNode, R as getCycles, S as getPostorders, T as bfs, U as getStronglyConnectedComponents, V as getSimplePath, W as joinPaths, X as createGraphEdge, Y as createGraph, Z as createGraphFromTransition, _ as getPageRank, a as genGirvanNewmanCommunities, at as getNode, b as genPreorders, c as getLabelPropagationCommunities, ct as updateEdge, d as getClosenessCentrality, et as createVisualGraph, f as getDegreeCentrality, g as getOutDegreeCentrality, h as getInDegreeCentrality, i as getBridges, it as getEdge, j as isConnected, k as hasPath, l as getModularity, lt as updateEntities, m as getHITS, n as getArticulationPoints, nt as deleteEntities, o as getGirvanNewmanCommunities, ot as hasEdge, p as getEigenvectorCentrality, q as addEntities, r as getBiconnectedComponents, rt as deleteNode, s as getGreedyModularityCommunities, st as hasNode, t as isIsomorphic, tt as deleteEdge, u as getBetweennessCentrality, ut as updateNode, v as getMinimumSpanningTree, w as getPreorders, x as getPostorder, y as genPostorders, z as getShortestPath } from "./algorithms-BNDQcHU3.mjs";
+import { o as invalidateIndex, t as getIndex } from "./indexing-DR8M1vBy.mjs";
+import { $ as createGraphPort, A as isAcyclic, B as getShortestPaths, C as getPreorder, D as getConnectedComponents, E as dfs, F as genSimplePaths, G as GraphInstance, H as getSimplePaths, I as getAStarPath, J as addNode, K as addEdge, L as getAllPairsShortestPaths, M as isTree, N as genCycles, O as getTopologicalSort, P as genShortestPaths, Q as createGraphNode, R as getCycles, S as getPostorders, T as bfs, U as getStronglyConnectedComponents, V as getSimplePath, W as joinPaths, X as createGraphEdge, Y as createGraph, Z as createGraphFromTransition, _ as getPageRank, a as genGirvanNewmanCommunities, at as getNode, b as genPreorders, c as getLabelPropagationCommunities, ct as updateEdge, d as getClosenessCentrality, et as createVisualGraph, f as getDegreeCentrality, g as getOutDegreeCentrality, h as getInDegreeCentrality, i as getBridges, it as getEdge, j as isConnected, k as hasPath, l as getModularity, lt as updateEntities, m as getHITS, n as getArticulationPoints, nt as deleteEntities, o as getGirvanNewmanCommunities, ot as hasEdge, p as getEigenvectorCentrality, q as addEntities, r as getBiconnectedComponents, rt as deleteNode, s as getGreedyModularityCommunities, st as hasNode, t as isIsomorphic, tt as deleteEdge, u as getBetweennessCentrality, ut as updateNode, v as getMinimumSpanningTree, w as getPreorders, x as getPostorder, y as genPostorders, z as getShortestPath } from "./algorithms-Ba7o7niK.mjs";
+import { n as isEdgeDirected, t as getEdgeMode } from "./mode-D8OnHFBk.mjs";
 import { getAncestors, getChildren, getDegree, getDepth, getDescendants, getEdgesBetween, getEdgesByPort, getEdgesOf, getInDegree, getInEdges, getLCA, getNeighbors, getOutDegree, getOutEdges, getParent, getPort, getPorts, getPredecessors, getRelativeDistance, getRelativeDistanceMap, getRoots, getSiblings, getSinks, getSources, getSuccessors, isCompound, isLeaf } from "./queries.mjs";
-import { n as createFormatConverter } from "./converter-Dspillnn.mjs";
+import { n as createFormatConverter } from "./converter-udLITX36.mjs";
 
 //#region src/equivalence.ts
 /** Shallow-compare two values, returning true if they differ. */
@@ -541,7 +542,7 @@ function flatten(graph) {
 	}));
 	return createGraph({
 		id: graph.id,
-		type: graph.type,
+		mode: graph.mode,
 		nodes: leafNodes,
 		edges: flatEdges,
 		data: graph.data
@@ -607,7 +608,7 @@ function getSubgraph(graph, nodeIds) {
 	const nodeIdSet = new Set(nodeIds);
 	return createGraph({
 		id: graph.id,
-		type: graph.type,
+		mode: graph.mode,
 		initialNodeId: graph.initialNodeId && nodeIdSet.has(graph.initialNodeId) ? graph.initialNodeId : void 0,
 		nodes: graph.nodes.filter((n) => nodeIdSet.has(n.id)).map((n) => nodeToConfig(n, nodeIdSet)),
 		edges: graph.edges.filter((e) => nodeIdSet.has(e.sourceId) && nodeIdSet.has(e.targetId)).map(edgeToConfig),
@@ -641,7 +642,7 @@ function reverseGraph(graph, filterEdge) {
 	const edges = filterEdge ? graph.edges.filter(filterEdge) : graph.edges;
 	return createGraph({
 		id: graph.id,
-		type: graph.type,
+		mode: graph.mode,
 		initialNodeId: graph.initialNodeId ?? void 0,
 		nodes: graph.nodes.map((n) => nodeToConfig(n)),
 		edges: edges.map((e) => {
@@ -905,4 +906,4 @@ function getCoverage(graph, steps, options) {
 }
 
 //#endregion
-export { GraphInstance, LAYOUT_KEYS, addEdge, addEntities, addNode, applyPatches, areEntitiesEqual, bfs, createFormatConverter, createGraph, createGraphEdge, createGraphFromTransition, createGraphNode, createGraphPort, createVisualGraph, deleteEdge, deleteEntities, deleteNode, dfs, flatten, genCycles, genGirvanNewmanCommunities, genPostorders, genPredefinedWalk, genPreorders, genQuickRandomWalk, genRandomWalk, genShortestPaths, genSimplePaths, genWeightedRandomWalk, getAStarPath, getAllPairsShortestPaths, getAncestors, getArticulationPoints, getBetweennessCentrality, getBiconnectedComponents, getBridges, getChildren, getClosenessCentrality, getConnectedComponents, getCoverage, getCycles, getDegree, getDegreeCentrality, getDepth, getDescendants, getDiff, getEdge, getEdgesBetween, getEdgesByPort, getEdgesOf, getEigenvectorCentrality, getGirvanNewmanCommunities, getGreedyModularityCommunities, getHITS, getInDegree, getInDegreeCentrality, getInEdges, getLCA, getLabelPropagationCommunities, getMinimumSpanningTree, getModularity, getNeighbors, getNode, getOutDegree, getOutDegreeCentrality, getOutEdges, getPageRank, getParent, getPatches, getPort, getPorts, getPostorder, getPostorders, getPredecessors, getPreorder, getPreorders, getRelativeDistance, getRelativeDistanceMap, getRoots, getShortestPath, getShortestPaths, getSiblings, getSimplePath, getSimplePaths, getSinks, getSources, getStronglyConnectedComponents, getSubgraph, getSuccessors, getTopologicalSort, hasEdge, hasNode, hasPath, invalidateIndex, invertDiff, isAcyclic, isCompound, isConnected, isEmptyDiff, isIsomorphic, isLayoutEqual, isLeaf, isNonLayoutEqual, isTree, joinPaths, reverseGraph, takeSteps, takeUntilEdge, takeUntilEdgeCoverage, takeUntilNode, takeUntilNodeCoverage, toDiff, toPatches, updateEdge, updateEntities, updateNode };
+export { GraphInstance, LAYOUT_KEYS, addEdge, addEntities, addNode, applyPatches, areEntitiesEqual, bfs, createFormatConverter, createGraph, createGraphEdge, createGraphFromTransition, createGraphNode, createGraphPort, createVisualGraph, deleteEdge, deleteEntities, deleteNode, dfs, flatten, genCycles, genGirvanNewmanCommunities, genPostorders, genPredefinedWalk, genPreorders, genQuickRandomWalk, genRandomWalk, genShortestPaths, genSimplePaths, genWeightedRandomWalk, getAStarPath, getAllPairsShortestPaths, getAncestors, getArticulationPoints, getBetweennessCentrality, getBiconnectedComponents, getBridges, getChildren, getClosenessCentrality, getConnectedComponents, getCoverage, getCycles, getDegree, getDegreeCentrality, getDepth, getDescendants, getDiff, getEdge, getEdgeMode, getEdgesBetween, getEdgesByPort, getEdgesOf, getEigenvectorCentrality, getGirvanNewmanCommunities, getGreedyModularityCommunities, getHITS, getInDegree, getInDegreeCentrality, getInEdges, getLCA, getLabelPropagationCommunities, getMinimumSpanningTree, getModularity, getNeighbors, getNode, getOutDegree, getOutDegreeCentrality, getOutEdges, getPageRank, getParent, getPatches, getPort, getPorts, getPostorder, getPostorders, getPredecessors, getPreorder, getPreorders, getRelativeDistance, getRelativeDistanceMap, getRoots, getShortestPath, getShortestPaths, getSiblings, getSimplePath, getSimplePaths, getSinks, getSources, getStronglyConnectedComponents, getSubgraph, getSuccessors, getTopologicalSort, hasEdge, hasNode, hasPath, invalidateIndex, invertDiff, isAcyclic, isCompound, isConnected, isEdgeDirected, isEmptyDiff, isIsomorphic, isLayoutEqual, isLeaf, isNonLayoutEqual, isTree, joinPaths, reverseGraph, takeSteps, takeUntilEdge, takeUntilEdgeCoverage, takeUntilNode, takeUntilNodeCoverage, toDiff, toPatches, updateEdge, updateEntities, updateNode };

package/dist/mode-D8OnHFBk.mjs

@@ -0,0 +1,15 @@
+//#region src/mode.ts
+/**
+* Resolve an edge's effective directedness. Falls back to the graph's
+* {@link Graph.mode} when the edge has no per-edge override.
+*/
+function getEdgeMode(graph, edge) {
+	return edge.mode ?? graph.mode;
+}
+/** Whether an edge points only from source to target. */
+function isEdgeDirected(graph, edge) {
+	return getEdgeMode(graph, edge) === "directed";
+}
+
+//#endregion
+export { isEdgeDirected as n, getEdgeMode as t };

package/dist/queries-BlkA1HAN.d.mts

@@ -0,0 +1,516 @@
+import { _ as GraphNode, b as GraphPort, p as GraphEdge, u as Graph } from "./types-3-FS9NV2.mjs";
+
+//#region src/queries.d.ts
+
+/**
+ * Returns all edges (incoming + outgoing) connected to a node.
+ *
+ * @example
+ * ```ts
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
+ *   edges: [
+ *     { id: 'e1', sourceId: 'a', targetId: 'b' },
+ *     { id: 'e2', sourceId: 'c', targetId: 'b' },
+ *   ],
+ * });
+ * getEdgesOf(graph, 'b');
+ * // => [edge e1, edge e2]
+ * ```
+ */
+declare function getEdgesOf<N, E>(graph: Graph<N, E>, nodeId: string): GraphEdge<E>[];
+/**
+ * Returns incoming edges to a node.
+ *
+ * @example
+ * ```ts
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }],
+ *   edges: [{ id: 'e1', sourceId: 'a', targetId: 'b' }],
+ * });
+ * getInEdges(graph, 'b');
+ * // => [edge e1]
+ * getInEdges(graph, 'a');
+ * // => []
+ * ```
+ */
+declare function getInEdges<N, E>(graph: Graph<N, E>, nodeId: string): GraphEdge<E>[];
+/**
+ * Returns outgoing edges from a node.
+ *
+ * @example
+ * ```ts
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }],
+ *   edges: [{ id: 'e1', sourceId: 'a', targetId: 'b' }],
+ * });
+ * getOutEdges(graph, 'a');
+ * // => [edge e1]
+ * getOutEdges(graph, 'b');
+ * // => []
+ * ```
+ */
+declare function getOutEdges<N, E>(graph: Graph<N, E>, nodeId: string): GraphEdge<E>[];
+/**
+ * Returns all edges from `sourceId` to `targetId`.
+ * Edges whose effective mode is not `'directed'` are matched both ways.
+ *
+ * @example
+ * ```ts
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }],
+ *   edges: [{ id: 'e1', sourceId: 'a', targetId: 'b' }],
+ * });
+ * getEdgesBetween(graph, 'a', 'b');
+ * // => [edge e1]
+ * getEdgesBetween(graph, 'b', 'a');
+ * // => [] (directed edge)
+ * ```
+ */
+declare function getEdgesBetween<N, E>(graph: Graph<N, E>, sourceId: string, targetId: string): GraphEdge<E>[];
+/**
+ * Returns direct successor nodes (targets of outgoing edges).
+ *
+ * @example
+ * ```ts
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
+ *   edges: [
+ *     { id: 'e1', sourceId: 'a', targetId: 'b' },
+ *     { id: 'e2', sourceId: 'a', targetId: 'c' },
+ *   ],
+ * });
+ * getSuccessors(graph, 'a');
+ * // => [node b, node c]
+ * ```
+ */
+declare function getSuccessors<N>(graph: Graph<N>, nodeId: string): GraphNode<N>[];
+/**
+ * Returns direct predecessor nodes (sources of incoming edges).
+ *
+ * @example
+ * ```ts
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
+ *   edges: [
+ *     { id: 'e1', sourceId: 'a', targetId: 'c' },
+ *     { id: 'e2', sourceId: 'b', targetId: 'c' },
+ *   ],
+ * });
+ * getPredecessors(graph, 'c');
+ * // => [node a, node b]
+ * ```
+ */
+declare function getPredecessors<N>(graph: Graph<N>, nodeId: string): GraphNode<N>[];
+/**
+ * Returns all neighbor nodes (successors + predecessors).
+ *
+ * @example
+ * ```ts
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
+ *   edges: [
+ *     { id: 'e1', sourceId: 'a', targetId: 'b' },
+ *     { id: 'e2', sourceId: 'c', targetId: 'b' },
+ *   ],
+ * });
+ * getNeighbors(graph, 'b');
+ * // => [node a, node c]
+ * ```
+ */
+declare function getNeighbors<N>(graph: Graph<N>, nodeId: string): GraphNode<N>[];
+/**
+ * Returns the total degree of a node (inDegree + outDegree).
+ * For graphs whose default mode is not `'directed'`, each incident edge is
+ * counted once.
+ *
+ * @example
+ * ```ts
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
+ *   edges: [
+ *     { id: 'e1', sourceId: 'a', targetId: 'b' },
+ *     { id: 'e2', sourceId: 'c', targetId: 'b' },
+ *   ],
+ * });
+ * getDegree(graph, 'b'); // => 2
+ * getDegree(graph, 'a'); // => 1
+ * ```
+ */
+declare function getDegree(graph: Graph, nodeId: string): number;
+/**
+ * Returns the in-degree of a node (number of incoming edges).
+ *
+ * @example
+ * ```ts
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }],
+ *   edges: [{ id: 'e1', sourceId: 'a', targetId: 'b' }],
+ * });
+ * getInDegree(graph, 'b'); // => 1
+ * getInDegree(graph, 'a'); // => 0
+ * ```
+ */
+declare function getInDegree(graph: Graph, nodeId: string): number;
+/**
+ * Returns the out-degree of a node (number of outgoing edges).
+ *
+ * @example
+ * ```ts
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }],
+ *   edges: [{ id: 'e1', sourceId: 'a', targetId: 'b' }],
+ * });
+ * getOutDegree(graph, 'a'); // => 1
+ * getOutDegree(graph, 'b'); // => 0
+ * ```
+ */
+declare function getOutDegree(graph: Graph, nodeId: string): number;
+/**
+ * Returns direct children of a node in the hierarchy.
+ * Pass `null` to get root-level nodes.
+ *
+ * @example
+ * ```ts
+ * const graph = createGraph({
+ *   nodes: [
+ *     { id: 'parent' },
+ *     { id: 'child1', parentId: 'parent' },
+ *     { id: 'child2', parentId: 'parent' },
+ *   ],
+ * });
+ * getChildren(graph, 'parent');
+ * // => [node child1, node child2]
+ * getChildren(graph, null);
+ * // => [node parent]
+ * ```
+ */
+declare function getChildren<N>(graph: Graph<N>, nodeId: string | null): GraphNode<N>[];
+/**
+ * Returns the parent node in the hierarchy, or `undefined` if root-level.
+ *
+ * @example
+ * ```ts
+ * const graph = createGraph({
+ *   nodes: [
+ *     { id: 'parent' },
+ *     { id: 'child', parentId: 'parent' },
+ *   ],
+ * });
+ * getParent(graph, 'child');
+ * // => node parent
+ * getParent(graph, 'parent');
+ * // => undefined
+ * ```
+ */
+declare function getParent<N>(graph: Graph<N>, nodeId: string): GraphNode<N> | undefined;
+/**
+ * Returns all ancestors from the node up to the root (nearest parent first).
+ *
+ * @example
+ * ```ts
+ * const graph = createGraph({
+ *   nodes: [
+ *     { id: 'root' },
+ *     { id: 'mid', parentId: 'root' },
+ *     { id: 'leaf', parentId: 'mid' },
+ *   ],
+ * });
+ * getAncestors(graph, 'leaf');
+ * // => [node mid, node root]
+ * ```
+ */
+declare function getAncestors<N>(graph: Graph<N>, nodeId: string): GraphNode<N>[];
+/**
+ * Returns all descendants recursively (depth-first).
+ *
+ * @example
+ * ```ts
+ * const graph = createGraph({
+ *   nodes: [
+ *     { id: 'root' },
+ *     { id: 'child', parentId: 'root' },
+ *     { id: 'grandchild', parentId: 'child' },
+ *   ],
+ * });
+ * getDescendants(graph, 'root');
+ * // => [node child, node grandchild]
+ * ```
+ */
+declare function getDescendants<N>(graph: Graph<N>, nodeId: string): GraphNode<N>[];
+/**
+ * Returns all root nodes (nodes with no parent).
+ *
+ * @example
+ * ```ts
+ * const graph = createGraph({
+ *   nodes: [
+ *     { id: 'root1' },
+ *     { id: 'root2' },
+ *     { id: 'child', parentId: 'root1' },
+ *   ],
+ * });
+ * getRoots(graph);
+ * // => [node root1, node root2]
+ * ```
+ */
+declare function getRoots<N>(graph: Graph<N>): GraphNode<N>[];
+/**
+ * Whether a node has children (is a compound/group node).
+ *
+ * @example
+ * ```ts
+ * const graph = createGraph({
+ *   nodes: [
+ *     { id: 'parent' },
+ *     { id: 'child', parentId: 'parent' },
+ *   ],
+ * });
+ * isCompound(graph, 'parent'); // => true
+ * isCompound(graph, 'child');  // => false
+ * ```
+ */
+declare function isCompound(graph: Graph, nodeId: string): boolean;
+/**
+ * Whether a node has no children (is a leaf/atomic node).
+ *
+ * @example
+ * ```ts
+ * const graph = createGraph({
+ *   nodes: [
+ *     { id: 'parent' },
+ *     { id: 'child', parentId: 'parent' },
+ *   ],
+ * });
+ * isLeaf(graph, 'child');  // => true
+ * isLeaf(graph, 'parent'); // => false
+ * ```
+ */
+declare function isLeaf(graph: Graph, nodeId: string): boolean;
+/**
+ * Depth of a node in the hierarchy (root = 0).
+ * Returns -1 if the node is not found.
+ *
+ * @example
+ * ```ts
+ * const graph = createGraph({
+ *   nodes: [
+ *     { id: 'root' },
+ *     { id: 'child', parentId: 'root' },
+ *     { id: 'grandchild', parentId: 'child' },
+ *   ],
+ * });
+ * getDepth(graph, 'root');       // => 0
+ * getDepth(graph, 'child');      // => 1
+ * getDepth(graph, 'grandchild'); // => 2
+ * ```
+ */
+declare function getDepth(graph: Graph, nodeId: string): number;
+/**
+ * Sibling nodes (same parentId, excluding the node itself).
+ *
+ * @example
+ * ```ts
+ * const graph = createGraph({
+ *   nodes: [
+ *     { id: 'parent' },
+ *     { id: 'a', parentId: 'parent' },
+ *     { id: 'b', parentId: 'parent' },
+ *     { id: 'c', parentId: 'parent' },
+ *   ],
+ * });
+ * getSiblings(graph, 'a');
+ * // => [node b, node c]
+ * ```
+ */
+declare function getSiblings<N>(graph: Graph<N>, nodeId: string): GraphNode<N>[];
+/**
+ * Least Common Ancestor -- deepest proper ancestor of all given nodes.
+ * A proper ancestor excludes the input nodes themselves.
+ *
+ * @example
+ * ```ts
+ * const graph = createGraph({
+ *   nodes: [
+ *     { id: 'root' },
+ *     { id: 'a', parentId: 'root' },
+ *     { id: 'b', parentId: 'root' },
+ *     { id: 'a1', parentId: 'a' },
+ *   ],
+ * });
+ * getLCA(graph, 'a1', 'b');
+ * // => node root
+ * getLCA(graph, 'a', 'b');
+ * // => node root
+ * ```
+ */
+declare function getLCA<N>(graph: Graph<N>, ...nodeIds: string[]): GraphNode<N> | undefined;
+/**
+ * Returns a map of nodeId → shortest-path distance for all sibling nodes
+ * (same parentId). Distance is measured from the parent's `initialNodeId`
+ * (or `graph.initialNodeId` for root-level nodes).
+ *
+ * Only follows edges between siblings. Unreachable siblings are omitted.
+ *
+ * @example Root-level nodes (uses `graph.initialNodeId`):
+ * ```ts
+ * const graph = createGraph({
+ *   initialNodeId: 'a',
+ *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
+ *   edges: [
+ *     { id: 'e1', sourceId: 'a', targetId: 'b' },
+ *     { id: 'e2', sourceId: 'b', targetId: 'c' },
+ *   ],
+ * });
+ * getRelativeDistanceMap(graph, null);
+ * // => { a: 0, b: 1, c: 2 }
+ * ```
+ *
+ * @example Nested nodes (uses parent's `initialNodeId`):
+ * ```ts
+ * const graph = createGraph({
+ *   nodes: [
+ *     { id: 'parent', initialNodeId: 's1' },
+ *     { id: 's1', parentId: 'parent' },
+ *     { id: 's2', parentId: 'parent' },
+ *     { id: 's3', parentId: 'parent' },
+ *   ],
+ *   edges: [
+ *     { id: 'e1', sourceId: 's1', targetId: 's2' },
+ *     { id: 'e2', sourceId: 's2', targetId: 's3' },
+ *   ],
+ * });
+ * getRelativeDistanceMap(graph, 'parent');
+ * // => { s1: 0, s2: 1, s3: 2 }
+ * ```
+ */
+declare function getRelativeDistanceMap(graph: Graph, parentId: string | null): Record<string, number>;
+/**
+ * Returns the shortest-path distance of a node from its parent's initial node.
+ * Automatically scopes to the node's sibling group (same `parentId`).
+ *
+ * Returns `undefined` if the node is not found or unreachable.
+ *
+ * @example
+ * ```ts
+ * const graph = createGraph({
+ *   initialNodeId: 'a',
+ *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
+ *   edges: [
+ *     { id: 'e1', sourceId: 'a', targetId: 'b' },
+ *     { id: 'e2', sourceId: 'b', targetId: 'c' },
+ *   ],
+ * });
+ * getRelativeDistance(graph, 'a'); // => 0
+ * getRelativeDistance(graph, 'b'); // => 1
+ * getRelativeDistance(graph, 'c'); // => 2
+ * ```
+ *
+ * @example Nested nodes:
+ * ```ts
+ * const graph = createGraph({
+ *   nodes: [
+ *     { id: 'parent', initialNodeId: 's1' },
+ *     { id: 's1', parentId: 'parent' },
+ *     { id: 's2', parentId: 'parent' },
+ *   ],
+ *   edges: [{ id: 'e1', sourceId: 's1', targetId: 's2' }],
+ * });
+ * getRelativeDistance(graph, 's1'); // => 0
+ * getRelativeDistance(graph, 's2'); // => 1
+ * ```
+ */
+declare function getRelativeDistance(graph: Graph, nodeId: string): number | undefined;
+/**
+ * Nodes with no incoming edges (inDegree 0).
+ *
+ * @example
+ * ```ts
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
+ *   edges: [
+ *     { id: 'e1', sourceId: 'a', targetId: 'b' },
+ *     { id: 'e2', sourceId: 'b', targetId: 'c' },
+ *   ],
+ * });
+ * getSources(graph);
+ * // => [node a]
+ * ```
+ */
+declare function getSources<N>(graph: Graph<N>): GraphNode<N>[];
+/**
+ * Nodes with no outgoing edges (outDegree 0).
+ *
+ * @example
+ * ```ts
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
+ *   edges: [
+ *     { id: 'e1', sourceId: 'a', targetId: 'b' },
+ *     { id: 'e2', sourceId: 'b', targetId: 'c' },
+ *   ],
+ * });
+ * getSinks(graph);
+ * // => [node c]
+ * ```
+ */
+declare function getSinks<N>(graph: Graph<N>): GraphNode<N>[];
+/**
+ * Get a port by name on a node, or `undefined` if not found.
+ *
+ * @example
+ * ```ts
+ * const graph = createGraph({
+ *   nodes: [{
+ *     id: 'a',
+ *     ports: [{ name: 'out', direction: 'out' }],
+ *   }],
+ * });
+ * getPort(graph, 'a', 'out'); // => { name: 'out', direction: 'out', ... }
+ * getPort(graph, 'a', 'missing'); // => undefined
+ * ```
+ */
+declare function getPort<N, E, G, P>(graph: Graph<N, E, G, P>, nodeId: string, portName: string): GraphPort<P> | undefined;
+/**
+ * Get all ports on a node. Returns `[]` if the node has no ports or doesn't exist.
+ *
+ * @example
+ * ```ts
+ * const graph = createGraph({
+ *   nodes: [{
+ *     id: 'a',
+ *     ports: [
+ *       { name: 'in', direction: 'in' },
+ *       { name: 'out', direction: 'out' },
+ *     ],
+ *   }],
+ * });
+ * getPorts(graph, 'a'); // => [port in, port out]
+ * ```
+ */
+declare function getPorts<N, E, G, P>(graph: Graph<N, E, G, P>, nodeId: string): GraphPort<P>[];
+/**
+ * Get all edges connected to a specific port on a node.
+ *
+ * Returns edges where:
+ * - `sourceId === nodeId && sourcePort === portName`, or
+ * - `targetId === nodeId && targetPort === portName`
+ *
+ * @example
+ * ```ts
+ * const graph = createGraph({
+ *   nodes: [
+ *     { id: 'a', ports: [{ name: 'out', direction: 'out' }] },
+ *     { id: 'b', ports: [{ name: 'in', direction: 'in' }] },
+ *   ],
+ *   edges: [{
+ *     id: 'e1', sourceId: 'a', targetId: 'b',
+ *     sourcePort: 'out', targetPort: 'in',
+ *   }],
+ * });
+ * getEdgesByPort(graph, 'a', 'out'); // => [edge e1]
+ * ```
+ */
+declare function getEdgesByPort<N, E>(graph: Graph<N, E>, nodeId: string, portName: string): GraphEdge<E>[];
+//#endregion
+export { getSinks as C, isLeaf as D, isCompound as E, getSiblings as S, getSuccessors as T, getPorts as _, getDescendants as a, getRelativeDistanceMap as b, getEdgesOf as c, getLCA as d, getNeighbors as f, getPort as g, getParent as h, getDepth as i, getInDegree as l, getOutEdges as m, getChildren as n, getEdgesBetween as o, getOutDegree as p, getDegree as r, getEdgesByPort as s, getAncestors as t, getInEdges as u, getPredecessors as v, getSources as w, getRoots as x, getRelativeDistance as y };