@neta-art/cohub 5.3.3 → 5.4.1

package/dist/board/core/connections.js

@@ -0,0 +1,414 @@
+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";
+}
+/**
+* World point of an anchor on a frame, ignoring the gap and the facing node.
+*
+* For a live drag the other end is the pointer, not a node, so `auto` has no
+* frame to face: it resolves to the node's centre, which is the only honest
+* answer while the relation has nowhere to point yet.
+*/
+function anchorPointOnFrame(anchor, frame) {
+	if (anchor.kind === "fixed") return anchorToWorld(frame, anchor.nx, anchor.ny);
+	if (anchor.kind === "side") {
+		const point = sideAnchorPoint(anchor.side, anchor.offset);
+		return anchorToWorld(frame, point.nx, point.ny);
+	}
+	return anchorToWorld(frame, .5, .5);
+}
+/** 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, anchorPointOnFrame, anchorToWorld, autoConnectionSide, connectionArrowheads, connectionBounds, connectionHitTest, createConnectionIndex, distanceToConnection, pathMidpoint, resolveConnection, worldToAnchor };

package/dist/board/core/export-plan.d.ts

@@ -1,6 +1,7 @@
+import { BoardConnection } from "../../protocol/dist/board-connection.js";
 import { BoardDocument, BoardItem } from "../../protocol/dist/board-document.js";
 import { Rect } from "../geometry.js";
-import { FrameLookup } from "./bindings.js";
+import { FrameLookup } from "./connections.js";
 //#region src/board/core/export-plan.d.ts
 /** What part of the board to capture. */
 type BoardExportRegion =
@@ -45,6 +46,14 @@ type BoardExportPlan = {
   height: number;
   /** Items to draw, in document order. */
   items: BoardItem[];
+  /**
+   * Connections to draw.
+   *
+   * A relation is only included when both of its nodes are in `items`: half a
+   * connection would render as a line into empty space, which reads as a defect
+   * rather than as a clipped edge.
+   */
+  connections: BoardConnection[];
   /** True when `scale` had to be reduced to fit the size budget. */
   clamped: boolean;
 };
@@ -73,12 +82,14 @@ declare const BOARD_EXPORT_DEFAULT_PADDING = 32;
 /** Above this, an export is still produced but the caller is warned. */
 declare const BOARD_EXPORT_ITEM_WARN_THRESHOLD = 2000;
 declare function boardFrameLookup(document: BoardDocument): FrameLookup;
-/** Bounds of a single item, resolving arrow endpoints through their bindings. */
-declare function exportItemBounds(item: BoardItem, getFrame: FrameLookup): Rect;
+/** Bounds of a single item. Arrows resolve through their own curve geometry. */
+declare function exportItemBounds(item: BoardItem, _getFrame?: FrameLookup): Rect;
+/** Bounds of a connection, resolved against the document's node frames. */
+declare function exportConnectionBounds(connection: BoardConnection, getFrame: FrameLookup): Rect | null;
 /**
  * Resolve a region into a concrete capture plan, or null when there is nothing
  * to draw. Callers treat null as "empty selection", not as an error.
  */
 declare function planBoardExport(input: BoardExportPlanInput): BoardExportPlan | null;
 //#endregion
-export { BOARD_EXPORT_DEFAULT_PADDING, BOARD_EXPORT_DEFAULT_SCALE, BOARD_EXPORT_ITEM_WARN_THRESHOLD, BOARD_EXPORT_MAX_EDGE, BOARD_EXPORT_MAX_PIXELS, BoardExportPlan, BoardExportPlanInput, BoardExportRegion, boardFrameLookup, exportItemBounds, normalizeBoardDocument, planBoardExport };
+export { BOARD_EXPORT_DEFAULT_PADDING, BOARD_EXPORT_DEFAULT_SCALE, BOARD_EXPORT_ITEM_WARN_THRESHOLD, BOARD_EXPORT_MAX_EDGE, BOARD_EXPORT_MAX_PIXELS, BoardExportPlan, BoardExportPlanInput, BoardExportRegion, boardFrameLookup, exportConnectionBounds, exportItemBounds, normalizeBoardDocument, planBoardExport };

package/dist/board/core/export-plan.js

@@ -1,6 +1,7 @@
-import { BoardDocumentSchema } from "../../protocol/dist/board-document.js";
+import { parseBoardDocument } from "../../protocol/dist/board-document.js";
 import { itemBounds, rectsIntersect, unionRects } from "../geometry.js";
-import { arrowBounds } from "./bindings.js";
+import { arrowBounds } from "./arrow-geometry.js";
+import { connectionBounds, resolveConnection } from "./connections.js";
 //#region src/board/core/export-plan.ts
 /**
 * Export planning — pure geometry, no renderer.
@@ -20,7 +21,7 @@ import { arrowBounds } from "./bindings.js";
 * error instead of a render-time crash.
 */
 function normalizeBoardDocument(document) {
-	return BoardDocumentSchema.parse(document);
+	return parseBoardDocument(document);
 }
 /**
 * Hard ceilings.
@@ -40,24 +41,41 @@ function boardFrameLookup(document) {
 	const frames = new Map(document.items.map((item) => [item.id, item.frame]));
 	return (id) => frames.get(id);
 }
-/** Bounds of a single item, resolving arrow endpoints through their bindings. */
-function exportItemBounds(item, getFrame) {
-	if (item.type === "arrow") return arrowBounds(item, getFrame) ?? itemBounds(item.frame);
+/** Bounds of a single item. Arrows resolve through their own curve geometry. */
+function exportItemBounds(item, _getFrame) {
+	if (item.type === "arrow") return arrowBounds(item);
 	return itemBounds(item.frame);
 }
+/** Bounds of a connection, resolved against the document's node frames. */
+function exportConnectionBounds(connection, getFrame) {
+	const resolved = resolveConnection(connection, getFrame);
+	return resolved ? connectionBounds(resolved, connection.style.size) : null;
+}
+/** Connections whose endpoints are both inside the given item set. */
+function connectionsWithin(document, items) {
+	if (document.connections.length === 0) return [];
+	const present = new Set(items.map((item) => item.id));
+	return document.connections.filter((connection) => present.has(connection.source.nodeId) && present.has(connection.target.nodeId));
+}
 function resolveRegion(document, region, getFrame) {
 	switch (region.kind) {
-		case "all": return {
-			items: document.items,
-			rect: unionRects(document.items.map((item) => exportItemBounds(item, getFrame))),
-			padding: null
-		};
+		case "all": {
+			const connections = document.connections;
+			return {
+				items: document.items,
+				connections,
+				rect: unionRects([...document.items.map((item) => exportItemBounds(item)), ...connectionBoundsList(connections, getFrame)]),
+				padding: null
+			};
+		}
 		case "items": {
 			const wanted = new Set(region.ids);
 			const items = document.items.filter((item) => wanted.has(item.id));
+			const connections = connectionsWithin(document, items);
 			return {
 				items,
-				rect: unionRects(items.map((item) => exportItemBounds(item, getFrame))),
+				connections,
+				rect: unionRects([...items.map((item) => exportItemBounds(item)), ...connectionBoundsList(connections, getFrame)]),
 				padding: null
 			};
 		}
@@ -65,26 +83,39 @@ function resolveRegion(document, region, getFrame) {
 			const frame = document.items.find((item) => item.id === region.id);
 			if (!frame) return {
 				items: [],
+				connections: [],
 				rect: null,
 				padding: null
 			};
 			const rect = itemBounds(frame.frame);
+			const items = document.items.filter((item) => item.id !== region.id && rectsIntersect(exportItemBounds(item), rect));
 			return {
-				items: document.items.filter((item) => item.id !== region.id && rectsIntersect(exportItemBounds(item, getFrame), rect)),
+				items,
+				connections: connectionsWithin(document, items),
 				rect,
 				padding: 0
 			};
 		}
 		case "rect": {
 			const rect = region.rect;
+			const items = document.items.filter((item) => rectsIntersect(exportItemBounds(item), rect));
 			return {
-				items: document.items.filter((item) => rectsIntersect(exportItemBounds(item, getFrame), rect)),
+				items,
+				connections: connectionsWithin(document, items),
 				rect,
 				padding: 0
 			};
 		}
 	}
 }
+function connectionBoundsList(connections, getFrame) {
+	const rects = [];
+	for (const connection of connections) {
+		const bounds = exportConnectionBounds(connection, getFrame);
+		if (bounds) rects.push(bounds);
+	}
+	return rects;
+}
 /**
 * Largest scale that keeps the output inside both the edge and pixel budgets.
 *
@@ -102,7 +133,8 @@ function clampScale(requested, world, maxEdge, maxPixels) {
 * to draw. Callers treat null as "empty selection", not as an error.
 */
 function planBoardExport(input) {
-	const { document, region, scale: requestedScale = 2, maxEdge = BOARD_EXPORT_MAX_EDGE, maxPixels = BOARD_EXPORT_MAX_PIXELS } = input;
+	const { region, scale: requestedScale = 2, maxEdge = BOARD_EXPORT_MAX_EDGE, maxPixels = BOARD_EXPORT_MAX_PIXELS } = input;
+	const document = normalizeBoardDocument(input.document);
 	const resolved = resolveRegion(document, region, boardFrameLookup(document));
 	if (!resolved.rect) return null;
 	const padding = input.padding ?? resolved.padding ?? 32;
@@ -121,8 +153,9 @@ function planBoardExport(input) {
 		width: Math.max(1, Math.floor(world.width * scale)),
 		height: Math.max(1, Math.floor(world.height * scale)),
 		items: resolved.items,
+		connections: resolved.connections,
 		clamped: scale < safeRequest - 1e-6
 	};
 }
 //#endregion
-export { BOARD_EXPORT_DEFAULT_PADDING, BOARD_EXPORT_DEFAULT_SCALE, BOARD_EXPORT_ITEM_WARN_THRESHOLD, BOARD_EXPORT_MAX_EDGE, BOARD_EXPORT_MAX_PIXELS, boardFrameLookup, exportItemBounds, normalizeBoardDocument, planBoardExport };
+export { BOARD_EXPORT_DEFAULT_PADDING, BOARD_EXPORT_DEFAULT_SCALE, BOARD_EXPORT_ITEM_WARN_THRESHOLD, BOARD_EXPORT_MAX_EDGE, BOARD_EXPORT_MAX_PIXELS, boardFrameLookup, exportConnectionBounds, exportItemBounds, normalizeBoardDocument, planBoardExport };

package/dist/board/core/shape-definition.js

@@ -34,7 +34,7 @@ const unknownShapeDefinition = {
 		aspectLocked: false,
 		canRotate: true,
 		canEdit: false,
-		canBind: true,
+		canConnect: true,
 		canSnap: true,
 		canLock: true
 	}

package/dist/board/core/shape-types.d.ts

@@ -49,8 +49,14 @@ type ShapeCapabilities = {
   canRotate: boolean;
   /** Supports double-click inline editing. */
   canEdit: boolean;
-  /** Can be a binding target for arrows. */
-  canBind: boolean;
+  /**
+   * Can be an endpoint of a connection.
+   *
+   * False for shapes that are themselves annotation strokes (draw, arrow): a
+   * relation between two scribbles has no meaning the model could express, and
+   * allowing it would produce edges no reader could interpret.
+   */
+  canConnect: boolean;
   /** Participates in snapping as a target. */
   canSnap: boolean;
   /** Can be locked against accidental edits. */

package/dist/board/core/shape-types.js

@@ -9,7 +9,7 @@ const FULL_CAPABILITIES = {
 	aspectLocked: false,
 	canRotate: true,
 	canEdit: false,
-	canBind: true,
+	canConnect: true,
 	canSnap: true,
 	canLock: true
 };

package/dist/board/core/tool-styles.d.ts

@@ -1,8 +1,7 @@
+import { BOARD_STROKE_MAX_SIZE, BOARD_STROKE_MIN_SIZE, clampBoardStrokeSize } from "../../protocol/dist/board-constants.js";
 import { BoardColorId } from "./palette.js";
 import { GeoKind } from "./shape-types.js";
 //#region src/board/core/tool-styles.d.ts
-declare const BOARD_STROKE_MIN_SIZE = 1;
-declare const BOARD_STROKE_MAX_SIZE = 64;
 type BoardToolStyleMap = {
   text: {
     color: BoardColorId;
@@ -19,6 +18,10 @@ type BoardToolStyleMap = {
     color: BoardColorId;
     size: number;
   };
+  connection: {
+    color: BoardColorId;
+    size: number;
+  };
   frame: {
     color: BoardColorId;
   };
@@ -41,11 +44,14 @@ declare const DEFAULT_BOARD_TOOL_STYLES: {
     readonly color: "brand";
     readonly size: 2.5;
   };
+  readonly connection: {
+    readonly color: "neutral";
+    readonly size: 2.5;
+  };
   readonly frame: {
     readonly color: "neutral";
   };
 };
-declare function clampBoardStrokeSize(size: number): number;
 /** Return a mutable, validated style map for an editor or another Board client. */
 declare function createBoardToolStyles(patch?: BoardToolStylePatch): BoardToolStyleMap;
 //#endregion