@statelyai/graph 1.0.0 → 2.1.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 { S as GraphPort, f as Graph, h as GraphEdge, y as GraphNode } from "./types-BAEQTwK_.mjs";
 import * as z from "zod";
 
 //#region src/schemas.d.ts
@@ -61,6 +61,15 @@ declare const EdgeSchema: z.ZodObject<{
     undirected: "undirected";
     bidirectional: "bidirectional";
   }>>;
+  points: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+  }, z.core.$strip>>>;
+  routing: z.ZodOptional<z.ZodEnum<{
+    polyline: "polyline";
+    orthogonal: "orthogonal";
+    splines: "splines";
+  }>>;
   data: z.ZodAny;
   x: z.ZodOptional<z.ZodNumber>;
   y: z.ZodOptional<z.ZodNumber>;
@@ -121,6 +130,15 @@ declare const GraphSchema: z.ZodObject<{
       undirected: "undirected";
       bidirectional: "bidirectional";
     }>>;
+    points: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      x: z.ZodNumber;
+      y: z.ZodNumber;
+    }, z.core.$strip>>>;
+    routing: z.ZodOptional<z.ZodEnum<{
+      polyline: "polyline";
+      orthogonal: "orthogonal";
+      splines: "splines";
+    }>>;
     data: z.ZodAny;
     x: z.ZodOptional<z.ZodNumber>;
     y: z.ZodOptional<z.ZodNumber>;

package/dist/schemas.mjs

@@ -1,3 +1,4 @@
+import { t as getGraphIssues$1 } from "./validate-BsfSOv0S.mjs";
 import * as z from "zod";
 
 //#region src/schemas.ts
@@ -53,6 +54,15 @@ const EdgeSchema = z.object({
 	sourcePort: z.string().optional(),
 	targetPort: z.string().optional(),
 	mode: ModeSchema.optional(),
+	points: z.array(z.object({
+		x: z.number(),
+		y: z.number()
+	})).optional(),
+	routing: z.enum([
+		"polyline",
+		"orthogonal",
+		"splines"
+	]).optional(),
 	data: z.any(),
 	x: z.number().optional(),
 	y: z.number().optional(),
@@ -116,37 +126,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 +161,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-BAEQTwK_.d.mts}

@@ -16,6 +16,20 @@ interface EntityRect {
   width: number;
   height: number;
 }
+/** A 2D point, used for edge routing waypoints. */
+interface Point {
+  x: number;
+  y: number;
+}
+/**
+ * How an edge's {@link GraphEdge.points} should be interpreted by renderers:
+ *
+ * - `'polyline'` — straight segments through the points.
+ * - `'orthogonal'` — axis-aligned segments (ELK layered routing).
+ * - `'splines'` — bezier control points (Graphviz convention: 3n+1 chained
+ *   cubic curves, tail → head).
+ */
+type EdgeRouting = 'polyline' | 'orthogonal' | 'splines';
 /** Shared optional visual/style props for nodes, edges, ports. */
 interface GraphEntity {
   x?: number;
@@ -55,7 +69,7 @@ interface GraphConfig<TNodeData = any, TEdgeData = any, TGraphData = any, TPortD
   id?: string;
   /** Default directedness for all edges. Defaults to `'directed'`. */
   mode?: GraphMode;
-  initialNodeId?: string;
+  initialNodeId?: string | null;
   nodes?: NodeConfig<TNodeData, TPortData>[];
   edges?: EdgeConfig<TEdgeData>[];
   data?: TGraphData;
@@ -65,13 +79,20 @@ interface GraphConfig<TNodeData = any, TEdgeData = any, TGraphData = any, TPortD
 interface NodeConfig<TNodeData = any, TPortData = any> extends GraphEntity {
   id: string;
   parentId?: string | null;
-  initialNodeId?: string;
+  initialNodeId?: string | null;
   label?: string | null;
   data?: TNodeData;
   ports?: PortConfig<TPortData>[];
   shape?: string;
   color?: string;
 }
+/**
+ * Note on edge geometry: an edge's `x`/`y`/`width`/`height` are canonically
+ * the **label rect** (top-left + size). Layout adapters write computed edge
+ * label positions here, and engines that need label dimensions as input
+ * (dagre, ELK) read `width`/`height`. The edge's *route* lives in
+ * {@link EdgeConfig.points}.
+ */
 interface EdgeConfig<TEdgeData = any> extends GraphEntity {
   /**
    * The id of the edge.
@@ -104,6 +125,13 @@ interface EdgeConfig<TEdgeData = any> extends GraphEntity {
    * {@link GraphConfig.mode}.
    */
   mode?: GraphMode;
+  /**
+   * Edge route waypoints (including endpoints, tail → head), as computed by a
+   * layout engine. Interpretation is governed by {@link EdgeConfig.routing}.
+   */
+  points?: Point[];
+  /** How {@link EdgeConfig.points} should be interpreted. Default: polyline. */
+  routing?: EdgeRouting;
   data?: TEdgeData;
   color?: string;
 }
@@ -129,6 +157,11 @@ interface GraphNode<TNodeData = any, TPortData = any> extends GraphEntity {
   shape?: string;
   color?: string;
 }
+/**
+ * Note on edge geometry: an edge's `x`/`y`/`width`/`height` are canonically
+ * the **label rect** (top-left + size); the edge's *route* lives in
+ * {@link GraphEdge.points}. See {@link EdgeConfig} for details.
+ */
 interface GraphEdge<TEdgeData = any> extends GraphEntity {
   type: 'edge';
   id: string;
@@ -150,6 +183,13 @@ interface GraphEdge<TEdgeData = any> extends GraphEntity {
    * {@link Graph.mode}.
    */
   mode?: GraphMode;
+  /**
+   * Edge route waypoints (including endpoints, tail → head), as computed by a
+   * layout engine. Interpretation is governed by {@link GraphEdge.routing}.
+   */
+  points?: Point[];
+  /** How {@link GraphEdge.points} should be interpreted. Default: polyline. */
+  routing?: EdgeRouting;
   data: TEdgeData;
   color?: string;
 }
@@ -177,15 +217,67 @@ 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;
+  /** Edge route waypoints, or `null` to clear the route. */
+  points?: Point[] | null;
+  routing?: EdgeRouting | 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 +373,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 +386,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 +467,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 { PortConfig as A, VisualNode as B, GraphStep as C, NodeUpdate as D, NodeConfig as E, VisualEdge as F, WalkContext as H, VisualGraph as I, VisualGraphConfig as L, SinglePathOptions as M, TransitionOptions as N, PathOptions as O, TraversalOptions as P, VisualGraphEntity as R, GraphPort as S, NodeChange as T, WalkOptions as U, VisualPort as V, WeightedWalkOptions as W, GraphFormatConverter as _, EdgeChange as a, GraphPatch as b, EdgeUpdate as c, EntityRect as d, Graph as f, GraphEntity as g, GraphEdge as h, DeleteNodeOptions as i, PortDirection as j, Point as k, EntitiesConfig as l, GraphDiff as m, AllPairsShortestPathsOptions as n, EdgeConfig as o, GraphConfig as p, CoverageStats as r, EdgeRouting as s, AStarOptions as t, EntitiesUpdate as u, GraphMode as v, MSTOptions as w, GraphPath as x, GraphNode as y, VisualGraphFormatConverter as z };

package/dist/validate-BsfSOv0S.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 };