@neta-art/cohub 5.3.2 → 5.4.0

package/dist/board/codec.d.ts

@@ -1,3 +1,4 @@
+import { BoardConnectionRecord } from "../protocol/dist/board-connection.js";
 import { BoardManifest, BoardNodeInput, BoardNodeRecord, BoardRecord, InvalidBoardFileError, isBoardPath, parseBoardManifest, serializeBoardManifest } from "../protocol/dist/board.js";
 import "../protocol/dist/index.js";
 import { BoardAppearance, BoardDocument, BoardItem } from "../protocol/dist/board-document.js";
@@ -20,6 +21,7 @@ declare function boardNodeToItem(node: BoardNodeRecord): BoardItem;
 declare function boardBootstrapToDocument(input: {
   board: BoardRecord;
   nodes: BoardNodeRecord[];
+  connections?: BoardConnectionRecord[];
 }): BoardDocument;
 //#endregion
 export { BOARD_NODE_SOURCE, type BoardManifest, type BoardNodeRecord, type BoardRecord, DEFAULT_BOARD_APPEARANCE, ITEM_BASE_KEYS, InvalidBoardFileError, WireBackedBoardItem, boardBootstrapToDocument, boardNodeToItem, isBoardPath, isRecord, nodeInputFromRecord, parseBoardManifest, serializeBoardManifest, sourceForItem };

package/dist/board/codec.js

@@ -1,5 +1,5 @@
 import { BOARD_DOCUMENT_KIND, InvalidBoardFileError, isBoardPath, parseBoardManifest, serializeBoardManifest } from "../protocol/dist/board.js";
-import { BoardAppearanceSchema, BoardDocumentSchema, BoardFileSnapshotSchema, UNKNOWN_BOARD_ITEM_TYPE } from "../protocol/dist/board-document.js";
+import { BoardAppearanceSchema, BoardFileSnapshotSchema, UNKNOWN_BOARD_ITEM_TYPE, parseBoardDocument } from "../protocol/dist/board-document.js";
 import { TEXT_FONT_SIZE, clampBoardTextFontSize } from "./core/text-metrics.js";
 import "../protocol/dist/index.js";
 //#region src/board/codec.ts
@@ -72,6 +72,17 @@ function spaceFilePathFromNode(node) {
 	if (typeof node.refPath === "string" && node.refPath) return node.refPath;
 	return null;
 }
+/** Read a stored world point, defaulting to the origin when absent. */
+function pointFromData(value) {
+	if (isRecord(value) && typeof value.x === "number" && typeof value.y === "number") return {
+		x: value.x,
+		y: value.y
+	};
+	return {
+		x: 0,
+		y: 0
+	};
+}
 function boardNodeToItemValue(node) {
 	const frame = frameFromNode(node);
 	const style = styleFromNode(node);
@@ -112,16 +123,8 @@ function boardNodeToItemValue(node) {
 		case "arrow": return {
 			id: node.nodeId,
 			type: "arrow",
-			start: data.start ?? {
-				kind: "point",
-				x: 0,
-				y: 0
-			},
-			end: data.end ?? {
-				kind: "point",
-				x: 0,
-				y: 0
-			},
+			start: pointFromData(data.start),
+			end: pointFromData(data.end),
 			bend: typeof data.bend === "number" ? data.bend : 0,
 			color: typeof data.color === "string" ? data.color : "brand",
 			size: typeof data.size === "number" ? data.size : 2.5,
@@ -219,7 +222,8 @@ function boardNodeToItem(node) {
 }
 function boardBootstrapToDocument(input) {
 	const appearance = BoardAppearanceSchema.safeParse(input.board.metadata.appearance);
-	const document = BoardDocumentSchema.parse({
+	const connections = (input.connections ?? []).map(({ boardId: _boardId, revision: _revision, createdAt: _createdAt, updatedAt: _updatedAt, ...connection }) => connection);
+	const document = parseBoardDocument({
 		kind: BOARD_DOCUMENT_KIND,
 		version: 1,
 		appearance: appearance.success ? appearance.data : DEFAULT_BOARD_APPEARANCE,
@@ -228,7 +232,8 @@ function boardBootstrapToDocument(input) {
 			y: 0,
 			zoom: 1
 		},
-		items: input.nodes.map(boardNodeToItem)
+		items: input.nodes.map(boardNodeToItem),
+		connections
 	});
 	const sources = new Map(input.nodes.map((node) => [node.nodeId, nodeInputFromRecord(node)]));
 	return {

package/dist/board/core/arrow-geometry.d.ts

@@ -0,0 +1,23 @@
+import { BoardArrowItem, BoardFrame } from "../../protocol/dist/board-document.js";
+import { Rect, WorldPoint } from "../geometry.js";
+//#region src/board/core/arrow-geometry.d.ts
+type ResolvedArrow = {
+  start: WorldPoint;
+  end: WorldPoint;
+  /** Quadratic control point (already bent); the midpoint when bend is 0. */
+  control: WorldPoint;
+};
+/** Resolve an arrow's endpoints and its bent control point. */
+declare function resolveArrow(item: BoardArrowItem): ResolvedArrow;
+/** Sample an arrow's quadratic curve into world points. */
+declare function sampleArrow(resolved: ResolvedArrow, segments: number): WorldPoint[];
+/** World bounds of an arrow, padded for its stroke. */
+declare function arrowBounds(item: BoardArrowItem): Rect;
+/** The frame an arrow should carry, derived from its endpoints. */
+declare function arrowFrame(item: BoardArrowItem): BoardFrame;
+/** Distance from a world point to an arrow's curve (hit testing). */
+declare function distanceToArrow(item: BoardArrowItem, point: WorldPoint): number;
+/** Translate an arrow by a delta, keeping its frame consistent. */
+declare function translateArrow(item: BoardArrowItem, dx: number, dy: number): BoardArrowItem;
+//#endregion
+export { ResolvedArrow, arrowBounds, arrowFrame, distanceToArrow, resolveArrow, sampleArrow, translateArrow };

package/dist/board/core/arrow-geometry.js

@@ -0,0 +1,109 @@
+import { worldPoint } from "../geometry.js";
+//#region src/board/core/arrow-geometry.ts
+/**
+* Free-arrow geometry.
+*
+* An arrow is a standalone annotation stroke between two world points — it does
+* not relate nodes. Node relations are `BoardConnection`s, which resolve their
+* geometry from the nodes they join (see ./connections). Keeping the two apart is
+* what makes each one simple: an arrow owns absolute coordinates and needs no
+* lookup, while a connection owns no coordinates at all.
+*/
+/** Resolve an arrow's endpoints and its bent control point. */
+function resolveArrow(item) {
+	const start = worldPoint(item.start.x, item.start.y);
+	const end = worldPoint(item.end.x, item.end.y);
+	const mid = worldPoint((start.x + end.x) / 2, (start.y + end.y) / 2);
+	if (!item.bend) return {
+		start,
+		end,
+		control: mid
+	};
+	const dx = end.x - start.x;
+	const dy = end.y - start.y;
+	const length = Math.hypot(dx, dy) || 1;
+	const offset = item.bend * length;
+	return {
+		start,
+		end,
+		control: worldPoint(mid.x + -dy / length * offset, mid.y + dx / length * offset)
+	};
+}
+/** Sample an arrow's quadratic curve into world points. */
+function sampleArrow(resolved, segments) {
+	const { start, control, end } = resolved;
+	const out = [];
+	for (let index = 0; index <= segments; index += 1) {
+		const t = index / segments;
+		const mt = 1 - t;
+		out.push(worldPoint(mt * mt * start.x + 2 * mt * t * control.x + t * t * end.x, mt * mt * start.y + 2 * mt * t * control.y + t * t * end.y));
+	}
+	return out;
+}
+/** World bounds of an arrow, padded for its stroke. */
+function arrowBounds(item) {
+	const samples = sampleArrow(resolveArrow(item), 12);
+	let minX = Number.POSITIVE_INFINITY;
+	let minY = Number.POSITIVE_INFINITY;
+	let maxX = Number.NEGATIVE_INFINITY;
+	let maxY = Number.NEGATIVE_INFINITY;
+	for (const point of samples) {
+		minX = Math.min(minX, point.x);
+		minY = Math.min(minY, point.y);
+		maxX = Math.max(maxX, point.x);
+		maxY = Math.max(maxY, point.y);
+	}
+	const pad = Math.max(8, item.size * 2);
+	return {
+		x: minX - pad,
+		y: minY - pad,
+		width: Math.max(1, maxX - minX + pad * 2),
+		height: Math.max(1, maxY - minY + pad * 2)
+	};
+}
+/** The frame an arrow should carry, derived from its endpoints. */
+function arrowFrame(item) {
+	return {
+		...arrowBounds(item),
+		rotation: 0
+	};
+}
+/** Distance from a world point to an arrow's curve (hit testing). */
+function distanceToArrow(item, point) {
+	const samples = sampleArrow(resolveArrow(item), 16);
+	let min = Number.POSITIVE_INFINITY;
+	for (let index = 0; index < samples.length - 1; index += 1) {
+		const from = samples[index];
+		const to = samples[index + 1];
+		if (!from || !to) continue;
+		const distance = segmentDistance(point, from, to);
+		if (distance < min) min = distance;
+	}
+	return min;
+}
+function segmentDistance(p, a, b) {
+	const dx = b.x - a.x;
+	const dy = b.y - a.y;
+	const lengthSq = dx * dx + dy * dy;
+	if (lengthSq === 0) return Math.hypot(p.x - a.x, p.y - a.y);
+	const t = Math.min(1, Math.max(0, ((p.x - a.x) * dx + (p.y - a.y) * dy) / lengthSq));
+	return Math.hypot(p.x - (a.x + t * dx), p.y - (a.y + t * dy));
+}
+/** Translate an arrow by a delta, keeping its frame consistent. */
+function translateArrow(item, dx, dy) {
+	const move = (point) => ({
+		x: point.x + dx,
+		y: point.y + dy
+	});
+	const next = {
+		...item,
+		start: move(item.start),
+		end: move(item.end)
+	};
+	return {
+		...next,
+		frame: arrowFrame(next)
+	};
+}
+//#endregion
+export { arrowBounds, arrowFrame, distanceToArrow, resolveArrow, sampleArrow, translateArrow };

package/dist/board/core/connections.d.ts

@@ -0,0 +1,83 @@
+import { BoardConnection, BoardConnectionSide } from "../../protocol/dist/board-connection.js";
+import { BoardFrame } from "../../protocol/dist/board-document.js";
+import { Rect, WorldPoint } from "../geometry.js";
+//#region src/board/core/connections.d.ts
+type FrameLookup = (id: string) => BoardFrame | undefined;
+/**
+ * Gap between a node's edge and the line's endpoint, in world units.
+ *
+ * A connection that touches the border reads as part of the node; a small gap
+ * makes the relation legible as its own object and keeps an arrowhead from being
+ * swallowed by the card it points at.
+ */
+declare const CONNECTION_ENDPOINT_GAP = 4;
+type ResolvedConnectionEndpoint = {
+  point: WorldPoint;
+  /** Outward normal at the attachment, used to aim arrowheads and elbows. */
+  normal: WorldPoint;
+  side: BoardConnectionSide;
+};
+type ResolvedConnection = {
+  source: ResolvedConnectionEndpoint;
+  target: ResolvedConnectionEndpoint;
+  /** Sampled world-space path, always at least two points. */
+  path: WorldPoint[];
+  /** Midpoint of the path, for labels and the drag handle. */
+  mid: WorldPoint;
+};
+/** Denormalize a (nx, ny) anchor to a world point on a possibly rotated frame. */
+declare function anchorToWorld(frame: BoardFrame, nx: number, ny: number): WorldPoint;
+/** Normalize a world point into a (nx, ny) anchor on a frame, clamped to it. */
+declare function worldToAnchor(frame: BoardFrame, point: WorldPoint): {
+  nx: number;
+  ny: number;
+};
+/**
+ * Choose the side an `auto` anchor should use.
+ *
+ * The dominant axis of the center-to-center vector wins, weighted by the frame's
+ * own proportions so a wide card prefers its long edges. Comparing raw dx/dy
+ * instead would make a wide node attach to its short side for most angles, which
+ * is the classic "line leaves from the corner" artifact.
+ */
+declare function autoConnectionSide(from: BoardFrame, to: BoardFrame): BoardConnectionSide;
+/**
+ * Resolve a connection into world-space geometry, or null if either node is gone.
+ *
+ * A null result means "not drawable right now", never "delete this": the caller
+ * may be looking at a viewport-culled read where an endpoint simply was not
+ * fetched.
+ */
+declare function resolveConnection(connection: BoardConnection, getFrame: FrameLookup, options?: {
+  gap?: number;
+}): ResolvedConnection | null;
+/** Midpoint by arc length, so a label sits visually centered on the line. */
+declare function pathMidpoint(path: WorldPoint[]): WorldPoint;
+/** World bounds of a resolved connection, padded for its stroke. */
+declare function connectionBounds(resolved: ResolvedConnection, strokeSize: number): Rect;
+/** Distance from a world point to a resolved connection's path. */
+declare function distanceToConnection(resolved: ResolvedConnection, point: WorldPoint): number;
+/** Hit test a connection with a zoom-independent screen-space tolerance. */
+declare function connectionHitTest(resolved: ResolvedConnection, point: WorldPoint, strokeSize: number): boolean;
+/** Whether the connection draws an arrowhead at its source / target. */
+declare function connectionArrowheads(connection: BoardConnection): {
+  atSource: boolean;
+  atTarget: boolean;
+};
+/**
+ * Index of connections by the nodes they touch.
+ *
+ * Built once per document revision and consulted per gesture frame: moving a node
+ * must cost its own degree, not a scan of every connection on the board. Without
+ * this, dragging one node in a densely connected board is O(connections) per
+ * frame, which is exactly the cost that shows up as drag lag.
+ */
+type ConnectionIndex = {
+  /** Connection ids touching a node (either endpoint). */
+  byNode: (nodeId: string) => readonly string[];
+  get: (connectionId: string) => BoardConnection | undefined;
+  readonly all: readonly BoardConnection[];
+};
+declare function createConnectionIndex(connections: readonly BoardConnection[]): ConnectionIndex;
+//#endregion
+export { CONNECTION_ENDPOINT_GAP, ConnectionIndex, FrameLookup, ResolvedConnection, ResolvedConnectionEndpoint, anchorToWorld, autoConnectionSide, connectionArrowheads, connectionBounds, connectionHitTest, createConnectionIndex, distanceToConnection, pathMidpoint, resolveConnection, worldToAnchor };

package/dist/board/core/connections.js

@@ -0,0 +1,399 @@
+import { degToRad, frameRect, rectCenter, rotatePointAround, worldPoint } from "../geometry.js";
+//#region src/board/core/connections.ts
+/**
+* Connection geometry — pure resolution of a relation into a drawable path.
+*
+* A `BoardConnection` stores no coordinates: it names two nodes, how it attaches
+* to each, and how the line should travel. Everything spatial is derived here from
+* the live node frames, which is what makes a connection incapable of going stale.
+* No PixiJS, no DOM, no editor state — so the editor, the far-LOD batch, the
+* headless exporter and the tests all resolve a connection the same way.
+*
+* The `auto` anchor is the interesting part: rather than storing a side, it picks
+* one per resolve from the relative position of the two frames, so a connection
+* keeps its shortest sensible route through any layout change. A stored side is
+* honoured exactly, because a user who pinned one is stating intent that geometry
+* must not override.
+*/
+/**
+* Gap between a node's edge and the line's endpoint, in world units.
+*
+* A connection that touches the border reads as part of the node; a small gap
+* makes the relation legible as its own object and keeps an arrowhead from being
+* swallowed by the card it points at.
+*/
+const CONNECTION_ENDPOINT_GAP = 4;
+/** Perpendicular fraction of the span used for an `orthogonal` elbow. */
+const ORTHOGONAL_SNAP = .5;
+const SIDE_NORMALS = {
+	top: {
+		x: 0,
+		y: -1
+	},
+	right: {
+		x: 1,
+		y: 0
+	},
+	bottom: {
+		x: 0,
+		y: 1
+	},
+	left: {
+		x: -1,
+		y: 0
+	}
+};
+/** Normalized position of a point on a frame side, as (nx, ny). */
+function sideAnchorPoint(side, offset) {
+	switch (side) {
+		case "top": return {
+			nx: offset,
+			ny: 0
+		};
+		case "bottom": return {
+			nx: offset,
+			ny: 1
+		};
+		case "left": return {
+			nx: 0,
+			ny: offset
+		};
+		default: return {
+			nx: 1,
+			ny: offset
+		};
+	}
+}
+/** Denormalize a (nx, ny) anchor to a world point on a possibly rotated frame. */
+function anchorToWorld(frame, nx, ny) {
+	const unrotated = worldPoint(frame.x + nx * frame.width, frame.y + ny * frame.height);
+	if (!frame.rotation) return unrotated;
+	return rotatePointAround(unrotated, rectCenter(frameRect(frame)), degToRad(frame.rotation));
+}
+/** Normalize a world point into a (nx, ny) anchor on a frame, clamped to it. */
+function worldToAnchor(frame, point) {
+	const local = frame.rotation ? rotatePointAround(point, rectCenter(frameRect(frame)), -degToRad(frame.rotation)) : point;
+	return {
+		nx: clamp01((local.x - frame.x) / Math.max(frame.width, 1e-4)),
+		ny: clamp01((local.y - frame.y) / Math.max(frame.height, 1e-4))
+	};
+}
+function clamp01(value) {
+	return Math.min(1, Math.max(0, value));
+}
+/**
+* Choose the side an `auto` anchor should use.
+*
+* The dominant axis of the center-to-center vector wins, weighted by the frame's
+* own proportions so a wide card prefers its long edges. Comparing raw dx/dy
+* instead would make a wide node attach to its short side for most angles, which
+* is the classic "line leaves from the corner" artifact.
+*/
+function autoConnectionSide(from, to) {
+	const a = rectCenter(frameRect(from));
+	const b = rectCenter(frameRect(to));
+	const dx = b.x - a.x;
+	const dy = b.y - a.y;
+	if (Math.abs(dx) / Math.max(from.width / 2, 1e-4) >= Math.abs(dy) / Math.max(from.height / 2, 1e-4)) return dx >= 0 ? "right" : "left";
+	return dy >= 0 ? "bottom" : "top";
+}
+/** Resolve one endpoint of a connection against its node frame. */
+function resolveEndpoint(anchor, frame, otherFrame, gap) {
+	let side;
+	let nx;
+	let ny;
+	if (anchor.kind === "fixed") {
+		nx = anchor.nx;
+		ny = anchor.ny;
+		side = nearestSide(nx, ny);
+	} else if (anchor.kind === "side") {
+		side = anchor.side;
+		const point = sideAnchorPoint(side, anchor.offset);
+		nx = point.nx;
+		ny = point.ny;
+	} else {
+		side = autoConnectionSide(frame, otherFrame);
+		const point = sideAnchorPoint(side, .5);
+		nx = point.nx;
+		ny = point.ny;
+	}
+	const base = anchorToWorld(frame, nx, ny);
+	const local = SIDE_NORMALS[side];
+	const normal = frame.rotation ? rotateVector(local, degToRad(frame.rotation)) : worldPoint(local.x, local.y);
+	return {
+		point: worldPoint(base.x + normal.x * gap, base.y + normal.y * gap),
+		normal,
+		side
+	};
+}
+function rotateVector(vector, angleRad) {
+	const cos = Math.cos(angleRad);
+	const sin = Math.sin(angleRad);
+	return worldPoint(vector.x * cos - vector.y * sin, vector.x * sin + vector.y * cos);
+}
+function nearestSide(nx, ny) {
+	const distances = [
+		["left", nx],
+		["right", 1 - nx],
+		["top", ny],
+		["bottom", 1 - ny]
+	];
+	distances.sort((a, b) => a[1] - b[1]);
+	return distances[0]?.[0] ?? "right";
+}
+/**
+* A self-loop's path: a lobe leaving and re-entering the same node.
+*
+* Handled separately because every straight/curve formula degenerates when both
+* endpoints coincide, and a self-relation is meaningful enough (a node that
+* depends on itself, a retry edge) that dropping it would lose real data.
+*/
+function selfLoopPath(frame, gap) {
+	const rect = frameRect(frame);
+	const size = Math.max(Math.min(rect.width, rect.height) * .45, 24);
+	const right = rect.x + rect.width + gap;
+	const top = rect.y - gap;
+	const midY = rect.y + rect.height * .3;
+	const midX = rect.x + rect.width * .7;
+	return [
+		worldPoint(midX, top),
+		worldPoint(midX, top - size),
+		worldPoint(right + size, top - size),
+		worldPoint(right + size, midY),
+		worldPoint(right, midY)
+	];
+}
+function quadraticPoint(start, control, end, t) {
+	const mt = 1 - t;
+	return worldPoint(mt * mt * start.x + 2 * mt * t * control.x + t * t * end.x, mt * mt * start.y + 2 * mt * t * control.y + t * t * end.y);
+}
+/** Sample a quadratic curve into a polyline. */
+function sampleQuadratic(start, control, end, segments) {
+	const out = [];
+	for (let index = 0; index <= segments; index += 1) out.push(quadraticPoint(start, control, end, index / segments));
+	return out;
+}
+/**
+* Build an orthogonal elbow between two endpoints, leaving each along its normal.
+*
+* The turn happens on the axis each endpoint exits by, so the line never starts
+* parallel to the edge it is attached to (which would read as touching the node
+* rather than leaving it).
+*/
+function orthogonalPath(source, target) {
+	const horizontalStart = Math.abs(source.normal.x) > Math.abs(source.normal.y);
+	const horizontalEnd = Math.abs(target.normal.x) > Math.abs(target.normal.y);
+	const a = source.point;
+	const b = target.point;
+	if (horizontalStart && horizontalEnd) {
+		const midX = a.x + (b.x - a.x) * ORTHOGONAL_SNAP;
+		return [
+			a,
+			worldPoint(midX, a.y),
+			worldPoint(midX, b.y),
+			b
+		];
+	}
+	if (!horizontalStart && !horizontalEnd) {
+		const midY = a.y + (b.y - a.y) * ORTHOGONAL_SNAP;
+		return [
+			a,
+			worldPoint(a.x, midY),
+			worldPoint(b.x, midY),
+			b
+		];
+	}
+	return horizontalStart ? [
+		a,
+		worldPoint(b.x, a.y),
+		b
+	] : [
+		a,
+		worldPoint(a.x, b.y),
+		b
+	];
+}
+/** Curve samples per connection. Enough to read as smooth at typical zoom. */
+const CURVE_SEGMENTS = 20;
+/**
+* Resolve a connection into world-space geometry, or null if either node is gone.
+*
+* A null result means "not drawable right now", never "delete this": the caller
+* may be looking at a viewport-culled read where an endpoint simply was not
+* fetched.
+*/
+function resolveConnection(connection, getFrame, options = {}) {
+	const sourceFrame = getFrame(connection.source.nodeId);
+	const targetFrame = getFrame(connection.target.nodeId);
+	if (!sourceFrame || !targetFrame) return null;
+	const gap = options.gap ?? 4;
+	if (connection.source.nodeId === connection.target.nodeId) {
+		const path = selfLoopPath(sourceFrame, gap);
+		const first = path[0];
+		const last = path[path.length - 1];
+		return {
+			source: {
+				point: first,
+				normal: worldPoint(0, -1),
+				side: "top"
+			},
+			target: {
+				point: last,
+				normal: worldPoint(1, 0),
+				side: "right"
+			},
+			path,
+			mid: path[Math.floor(path.length / 2)] ?? first
+		};
+	}
+	const source = resolveEndpoint(connection.source.anchor, sourceFrame, targetFrame, gap);
+	const target = resolveEndpoint(connection.target.anchor, targetFrame, sourceFrame, gap);
+	const waypoints = connection.routing.waypoints;
+	let path;
+	if (waypoints.length > 0) path = [
+		source.point,
+		...waypoints.map((point) => worldPoint(point.x, point.y)),
+		target.point
+	];
+	else if (connection.routing.kind === "orthogonal") path = orthogonalPath(source, target);
+	else if (connection.routing.kind === "straight" && !connection.routing.bend) path = [source.point, target.point];
+	else path = sampleQuadratic(source.point, curveControl(source, target, connection.routing.bend), target.point, CURVE_SEGMENTS);
+	return {
+		source,
+		target,
+		path,
+		mid: pathMidpoint(path)
+	};
+}
+/**
+* Control point for a curved connection.
+*
+* With no explicit bend the bow is derived from the endpoint normals, so the line
+* leaves each node perpendicular to its edge and reads as attached rather than
+* merely adjacent. An explicit bend is a user-set bow and takes over entirely.
+*/
+function curveControl(source, target, bend) {
+	const mid = worldPoint((source.point.x + target.point.x) / 2, (source.point.y + target.point.y) / 2);
+	const dx = target.point.x - source.point.x;
+	const dy = target.point.y - source.point.y;
+	const length = Math.hypot(dx, dy) || 1;
+	if (bend) {
+		const offset = bend * length;
+		return worldPoint(mid.x + -dy / length * offset, mid.y + dx / length * offset);
+	}
+	const nx = (source.normal.x + target.normal.x) / 2;
+	const ny = (source.normal.y + target.normal.y) / 2;
+	const magnitude = Math.hypot(nx, ny);
+	if (magnitude < 1e-4) return mid;
+	const strength = Math.min(length * .18, 96);
+	return worldPoint(mid.x + nx / magnitude * strength, mid.y + ny / magnitude * strength);
+}
+/** Midpoint by arc length, so a label sits visually centered on the line. */
+function pathMidpoint(path) {
+	if (path.length === 0) return worldPoint(0, 0);
+	if (path.length === 1) return path[0];
+	let total = 0;
+	for (let index = 0; index < path.length - 1; index += 1) {
+		const from = path[index];
+		const to = path[index + 1];
+		total += Math.hypot(to.x - from.x, to.y - from.y);
+	}
+	let travelled = 0;
+	const half = total / 2;
+	for (let index = 0; index < path.length - 1; index += 1) {
+		const from = path[index];
+		const to = path[index + 1];
+		const segment = Math.hypot(to.x - from.x, to.y - from.y);
+		if (travelled + segment >= half) {
+			const t = segment > 0 ? (half - travelled) / segment : 0;
+			return worldPoint(from.x + (to.x - from.x) * t, from.y + (to.y - from.y) * t);
+		}
+		travelled += segment;
+	}
+	return path[path.length - 1];
+}
+/** World bounds of a resolved connection, padded for its stroke. */
+function connectionBounds(resolved, strokeSize) {
+	let minX = Number.POSITIVE_INFINITY;
+	let minY = Number.POSITIVE_INFINITY;
+	let maxX = Number.NEGATIVE_INFINITY;
+	let maxY = Number.NEGATIVE_INFINITY;
+	for (const point of resolved.path) {
+		minX = Math.min(minX, point.x);
+		minY = Math.min(minY, point.y);
+		maxX = Math.max(maxX, point.x);
+		maxY = Math.max(maxY, point.y);
+	}
+	const pad = Math.max(8, strokeSize * 2);
+	return {
+		x: minX - pad,
+		y: minY - pad,
+		width: Math.max(1, maxX - minX + pad * 2),
+		height: Math.max(1, maxY - minY + pad * 2)
+	};
+}
+/** Distance from a world point to a resolved connection's path. */
+function distanceToConnection(resolved, point) {
+	let min = Number.POSITIVE_INFINITY;
+	for (let index = 0; index < resolved.path.length - 1; index += 1) {
+		const from = resolved.path[index];
+		const to = resolved.path[index + 1];
+		if (!from || !to) continue;
+		const distance = segmentDistance(point, from, to);
+		if (distance < min) min = distance;
+	}
+	return min;
+}
+function segmentDistance(p, a, b) {
+	const dx = b.x - a.x;
+	const dy = b.y - a.y;
+	const lengthSq = dx * dx + dy * dy;
+	if (lengthSq === 0) return Math.hypot(p.x - a.x, p.y - a.y);
+	const t = Math.min(1, Math.max(0, ((p.x - a.x) * dx + (p.y - a.y) * dy) / lengthSq));
+	return Math.hypot(p.x - (a.x + t * dx), p.y - (a.y + t * dy));
+}
+/** Hit test a connection with a zoom-independent screen-space tolerance. */
+function connectionHitTest(resolved, point, strokeSize) {
+	return distanceToConnection(resolved, point) <= Math.max(8, strokeSize * 2.5);
+}
+/** Whether the connection draws an arrowhead at its source / target. */
+function connectionArrowheads(connection) {
+	switch (connection.direction) {
+		case "forward": return {
+			atSource: false,
+			atTarget: true
+		};
+		case "backward": return {
+			atSource: true,
+			atTarget: false
+		};
+		case "both": return {
+			atSource: true,
+			atTarget: true
+		};
+		default: return {
+			atSource: false,
+			atTarget: false
+		};
+	}
+}
+const NO_CONNECTIONS = [];
+function createConnectionIndex(connections) {
+	const byNode = /* @__PURE__ */ new Map();
+	const byId = /* @__PURE__ */ new Map();
+	for (const connection of connections) {
+		byId.set(connection.id, connection);
+		for (const nodeId of /* @__PURE__ */ new Set([connection.source.nodeId, connection.target.nodeId])) {
+			const list = byNode.get(nodeId);
+			if (list) list.push(connection.id);
+			else byNode.set(nodeId, [connection.id]);
+		}
+	}
+	return {
+		byNode: (nodeId) => byNode.get(nodeId) ?? NO_CONNECTIONS,
+		get: (connectionId) => byId.get(connectionId),
+		all: connections
+	};
+}
+//#endregion
+export { CONNECTION_ENDPOINT_GAP, anchorToWorld, autoConnectionSide, connectionArrowheads, connectionBounds, connectionHitTest, createConnectionIndex, distanceToConnection, pathMidpoint, resolveConnection, worldToAnchor };