@statelyai/graph 0.13.0 → 2.0.0

package/dist/queries.mjs

@@ -1,768 +1,3 @@
-import { t as getIndex } from "./indexing-DUl3kTqm.mjs";
+import { C as getSinks, D as isLeaf, E as isCompound, S as getSiblings, T as getSuccessors, _ as getPorts, a as getDescendants, b as getRelativeDistanceMap, c as getEdgesOf, d as getLCA, f as getNeighbors, g as getPort, h as getParent, i as getDepth, l as getInDegree, m as getOutEdges, n as getChildren, o as getEdgesBetween, p as getOutDegree, r as getDegree, s as getEdgesByPort, t as getAncestors, u as getInEdges, v as getPredecessors, w as getSources, x as getRoots, y as getRelativeDistance } from "./queries-KirMDR7e.mjs";
 
-//#region src/queries.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]
-* ```
-*/
-function getEdgesOf(graph, nodeId) {
-	const idx = getIndex(graph);
-	const outIds = idx.outEdges.get(nodeId) ?? [];
-	const inIds = idx.inEdges.get(nodeId) ?? [];
-	const seen = /* @__PURE__ */ new Set();
-	const result = [];
-	for (const eid of outIds) {
-		seen.add(eid);
-		const ai = idx.edgeById.get(eid);
-		if (ai !== void 0) result.push(graph.edges[ai]);
-	}
-	for (const eid of inIds) if (!seen.has(eid)) {
-		const ai = idx.edgeById.get(eid);
-		if (ai !== void 0) result.push(graph.edges[ai]);
-	}
-	return result;
-}
-/**
-* 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');
-* // => []
-* ```
-*/
-function getInEdges(graph, nodeId) {
-	const idx = getIndex(graph);
-	return (idx.inEdges.get(nodeId) ?? []).map((eid) => graph.edges[idx.edgeById.get(eid)]);
-}
-/**
-* 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');
-* // => []
-* ```
-*/
-function getOutEdges(graph, nodeId) {
-	const idx = getIndex(graph);
-	return (idx.outEdges.get(nodeId) ?? []).map((eid) => graph.edges[idx.edgeById.get(eid)]);
-}
-/**
-* Returns all edges from `sourceId` to `targetId`.
-* For undirected graphs, checks both directions.
-*
-* @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 graph)
-* ```
-*/
-function getEdgesBetween(graph, sourceId, targetId) {
-	const idx = getIndex(graph);
-	const result = [];
-	const seen = /* @__PURE__ */ new Set();
-	const outIds = idx.outEdges.get(sourceId) ?? [];
-	for (const eid of outIds) {
-		const ai = idx.edgeById.get(eid);
-		const e = graph.edges[ai];
-		if (e.targetId === targetId) {
-			seen.add(eid);
-			result.push(e);
-		}
-	}
-	if (graph.type === "undirected") {
-		const outIds2 = idx.outEdges.get(targetId) ?? [];
-		for (const eid of outIds2) {
-			if (seen.has(eid)) continue;
-			const ai = idx.edgeById.get(eid);
-			const e = graph.edges[ai];
-			if (e.targetId === sourceId) result.push(e);
-		}
-	}
-	return result;
-}
-/**
-* 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]
-* ```
-*/
-function getSuccessors(graph, nodeId) {
-	const idx = getIndex(graph);
-	const edgeIds = idx.outEdges.get(nodeId) ?? [];
-	const seen = /* @__PURE__ */ new Set();
-	const result = [];
-	for (const eid of edgeIds) {
-		const e = graph.edges[idx.edgeById.get(eid)];
-		if (!seen.has(e.targetId)) {
-			seen.add(e.targetId);
-			const ni = idx.nodeById.get(e.targetId);
-			if (ni !== void 0) result.push(graph.nodes[ni]);
-		}
-	}
-	return result;
-}
-/**
-* 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]
-* ```
-*/
-function getPredecessors(graph, nodeId) {
-	const idx = getIndex(graph);
-	const edgeIds = idx.inEdges.get(nodeId) ?? [];
-	const seen = /* @__PURE__ */ new Set();
-	const result = [];
-	for (const eid of edgeIds) {
-		const e = graph.edges[idx.edgeById.get(eid)];
-		if (!seen.has(e.sourceId)) {
-			seen.add(e.sourceId);
-			const ni = idx.nodeById.get(e.sourceId);
-			if (ni !== void 0) result.push(graph.nodes[ni]);
-		}
-	}
-	return result;
-}
-/**
-* 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]
-* ```
-*/
-function getNeighbors(graph, nodeId) {
-	const idx = getIndex(graph);
-	const ids = /* @__PURE__ */ new Set();
-	for (const eid of idx.outEdges.get(nodeId) ?? []) ids.add(graph.edges[idx.edgeById.get(eid)].targetId);
-	for (const eid of idx.inEdges.get(nodeId) ?? []) ids.add(graph.edges[idx.edgeById.get(eid)].sourceId);
-	return [...ids].map((id) => graph.nodes[idx.nodeById.get(id)]).filter(Boolean);
-}
-/**
-* Returns the total degree of a node (inDegree + outDegree).
-* For undirected graphs, each 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
-* ```
-*/
-function getDegree(graph, nodeId) {
-	const idx = getIndex(graph);
-	if (graph.type === "undirected") {
-		const out = idx.outEdges.get(nodeId) ?? [];
-		const inE = idx.inEdges.get(nodeId) ?? [];
-		return new Set([...out, ...inE]).size;
-	}
-	return (idx.inEdges.get(nodeId)?.length ?? 0) + (idx.outEdges.get(nodeId)?.length ?? 0);
-}
-/**
-* 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
-* ```
-*/
-function getInDegree(graph, nodeId) {
-	return getIndex(graph).inEdges.get(nodeId)?.length ?? 0;
-}
-/**
-* 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
-* ```
-*/
-function getOutDegree(graph, nodeId) {
-	return getIndex(graph).outEdges.get(nodeId)?.length ?? 0;
-}
-/**
-* 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]
-* ```
-*/
-function getChildren(graph, nodeId) {
-	const idx = getIndex(graph);
-	return (idx.childNodes.get(nodeId) ?? []).map((id) => graph.nodes[idx.nodeById.get(id)]).filter(Boolean);
-}
-/**
-* 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
-* ```
-*/
-function getParent(graph, nodeId) {
-	const idx = getIndex(graph);
-	const ni = idx.nodeById.get(nodeId);
-	if (ni === void 0) return void 0;
-	const node = graph.nodes[ni];
-	if (!node.parentId) return void 0;
-	const pi = idx.nodeById.get(node.parentId);
-	return pi !== void 0 ? graph.nodes[pi] : void 0;
-}
-/**
-* 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]
-* ```
-*/
-function getAncestors(graph, nodeId) {
-	const idx = getIndex(graph);
-	const result = [];
-	let ni = idx.nodeById.get(nodeId);
-	if (ni === void 0) return result;
-	let current = graph.nodes[ni];
-	while (current && current.parentId) {
-		const pi = idx.nodeById.get(current.parentId);
-		if (pi === void 0) break;
-		const p = graph.nodes[pi];
-		result.push(p);
-		current = p;
-	}
-	return result;
-}
-/**
-* 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]
-* ```
-*/
-function getDescendants(graph, nodeId) {
-	const idx = getIndex(graph);
-	const result = [];
-	const collect = (id) => {
-		const childIds = idx.childNodes.get(id) ?? [];
-		for (const childId of childIds) {
-			const ci = idx.nodeById.get(childId);
-			if (ci !== void 0) {
-				result.push(graph.nodes[ci]);
-				collect(childId);
-			}
-		}
-	};
-	collect(nodeId);
-	return result;
-}
-/**
-* 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]
-* ```
-*/
-function getRoots(graph) {
-	const idx = getIndex(graph);
-	return idx.childNodes.get(null)?.map((id) => graph.nodes[idx.nodeById.get(id)]).filter(Boolean) ?? [];
-}
-/**
-* 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
-* ```
-*/
-function isCompound(graph, nodeId) {
-	return (getIndex(graph).childNodes.get(nodeId) ?? []).length > 0;
-}
-/**
-* 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
-* ```
-*/
-function isLeaf(graph, nodeId) {
-	return !isCompound(graph, nodeId);
-}
-/**
-* 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
-* ```
-*/
-function getDepth(graph, nodeId) {
-	const idx = getIndex(graph);
-	let d = 0;
-	let ni = idx.nodeById.get(nodeId);
-	if (ni === void 0) return -1;
-	let current = graph.nodes[ni];
-	while (current.parentId) {
-		d++;
-		const pi = idx.nodeById.get(current.parentId);
-		if (pi === void 0) break;
-		current = graph.nodes[pi];
-	}
-	return d;
-}
-/**
-* 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]
-* ```
-*/
-function getSiblings(graph, nodeId) {
-	const idx = getIndex(graph);
-	const ni = idx.nodeById.get(nodeId);
-	if (ni === void 0) return [];
-	const node = graph.nodes[ni];
-	return (idx.childNodes.get(node.parentId ?? null) ?? []).filter((id) => id !== nodeId).map((id) => graph.nodes[idx.nodeById.get(id)]).filter(Boolean);
-}
-/**
-* 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
-* ```
-*/
-function getLCA(graph, ...nodeIds) {
-	if (nodeIds.length === 0) return void 0;
-	const idx = getIndex(graph);
-	const getAncestorChain = (id) => {
-		const result = [id];
-		let ni$1 = idx.nodeById.get(id);
-		if (ni$1 === void 0) return result;
-		let current = graph.nodes[ni$1];
-		while (current.parentId) {
-			result.push(current.parentId);
-			const pi = idx.nodeById.get(current.parentId);
-			if (pi === void 0) break;
-			current = graph.nodes[pi];
-		}
-		return result;
-	};
-	let common = getAncestorChain(nodeIds[0]);
-	for (let i = 1; i < nodeIds.length; i++) {
-		const set = new Set(getAncestorChain(nodeIds[i]));
-		common = common.filter((id) => set.has(id));
-	}
-	const inputSet = new Set(nodeIds);
-	common = common.filter((id) => !inputSet.has(id));
-	if (common.length === 0) return void 0;
-	const lcaId = common[0];
-	const ni = idx.nodeById.get(lcaId);
-	return ni !== void 0 ? graph.nodes[ni] : void 0;
-}
-/**
-* 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 }
-* ```
-*/
-function getRelativeDistanceMap(graph, parentId) {
-	const idx = getIndex(graph);
-	let sourceId = null;
-	if (parentId !== null) {
-		const pi = idx.nodeById.get(parentId);
-		if (pi !== void 0) sourceId = graph.nodes[pi].initialNodeId ?? null;
-	} else sourceId = graph.initialNodeId ?? null;
-	if (!sourceId) return {};
-	const siblingSet = new Set(idx.childNodes.get(parentId) ?? []);
-	if (!siblingSet.has(sourceId)) return {};
-	const dist = /* @__PURE__ */ new Map();
-	dist.set(sourceId, 0);
-	const queue = [sourceId];
-	while (queue.length > 0) {
-		const id = queue.shift();
-		const d = dist.get(id);
-		for (const eid of idx.outEdges.get(id) ?? []) {
-			const ai = idx.edgeById.get(eid);
-			if (ai === void 0) continue;
-			const neighborId = graph.edges[ai].targetId;
-			if (siblingSet.has(neighborId) && !dist.has(neighborId)) {
-				dist.set(neighborId, d + 1);
-				queue.push(neighborId);
-			}
-		}
-		if (graph.type === "undirected") for (const eid of idx.inEdges.get(id) ?? []) {
-			const ai = idx.edgeById.get(eid);
-			if (ai === void 0) continue;
-			const neighborId = graph.edges[ai].sourceId;
-			if (siblingSet.has(neighborId) && !dist.has(neighborId)) {
-				dist.set(neighborId, d + 1);
-				queue.push(neighborId);
-			}
-		}
-	}
-	const result = {};
-	for (const [id, d] of dist) result[id] = d;
-	return result;
-}
-/**
-* 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
-* ```
-*/
-function getRelativeDistance(graph, nodeId) {
-	const ni = getIndex(graph).nodeById.get(nodeId);
-	if (ni === void 0) return void 0;
-	const node = graph.nodes[ni];
-	return getRelativeDistanceMap(graph, node.parentId ?? null)[nodeId];
-}
-/**
-* 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]
-* ```
-*/
-function getSources(graph) {
-	const idx = getIndex(graph);
-	return graph.nodes.filter((n) => (idx.inEdges.get(n.id)?.length ?? 0) === 0);
-}
-/**
-* 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]
-* ```
-*/
-function getSinks(graph) {
-	const idx = getIndex(graph);
-	return graph.nodes.filter((n) => (idx.outEdges.get(n.id)?.length ?? 0) === 0);
-}
-/**
-* 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
-* ```
-*/
-function getPort(graph, nodeId, portName) {
-	const ni = getIndex(graph).nodeById.get(nodeId);
-	if (ni === void 0) return void 0;
-	return graph.nodes[ni].ports?.find((p) => p.name === portName);
-}
-/**
-* 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]
-* ```
-*/
-function getPorts(graph, nodeId) {
-	const ni = getIndex(graph).nodeById.get(nodeId);
-	if (ni === void 0) return [];
-	return graph.nodes[ni].ports ?? [];
-}
-/**
-* 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]
-* ```
-*/
-function getEdgesByPort(graph, nodeId, portName) {
-	const idx = getIndex(graph);
-	const result = [];
-	for (const eid of idx.outEdges.get(nodeId) ?? []) {
-		const ai = idx.edgeById.get(eid);
-		if (ai !== void 0 && graph.edges[ai].sourcePort === portName) result.push(graph.edges[ai]);
-	}
-	for (const eid of idx.inEdges.get(nodeId) ?? []) {
-		const ai = idx.edgeById.get(eid);
-		if (ai !== void 0 && graph.edges[ai].targetPort === portName) result.push(graph.edges[ai]);
-	}
-	return result;
-}
-
-//#endregion
 export { 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 };