@neta-art/cohub 8.23.0 → 9.0.0

package/dist/protocol/dist/board-constants.d.ts

@@ -1,34 +1,6 @@
 //#region ../protocol/dist/board-constants.d.ts
-type BoardCoordinateSpace = "world" | "frame-local" | "world-offset" | "screen" | "screen-offset" | "normalized";
-type BoardRenderCost = {
-  particles: number;
-  vertices: number;
-  dynamicVertices: number;
-  drawCalls: number;
-  filterPasses: number;
-  renderTexturePixels: number;
-  textureBytes: number;
-  bufferBytes: number;
-  simulationSteps: number;
-};
-type BoardCapability = {
-  kind: "preset" | "clip" | "effect" | "shader";
-  id: string;
-  version: number;
-  digest?: string;
-  renderers?: Array<"webgpu" | "webgl">;
-  fallbackId?: string;
-  schema?: Record<string, unknown>;
-};
-/**
- * Stroke width bounds, shared by every stroked board entity.
- *
- * Defined here (not beside the editor) because the persisted schemas clamp with
- * them: a single range is what keeps a width authored by the editor, an agent or
- * the CLI from being silently re-clamped to something else on read.
- */
 declare const BOARD_STROKE_MIN_SIZE = 1;
 declare const BOARD_STROKE_MAX_SIZE = 64;
 declare function clampBoardStrokeSize(size: number): number;
 //#endregion
-export { BOARD_STROKE_MAX_SIZE, BOARD_STROKE_MIN_SIZE, BoardCapability, BoardCoordinateSpace, BoardRenderCost, clampBoardStrokeSize };
+export { BOARD_STROKE_MAX_SIZE, BOARD_STROKE_MIN_SIZE, clampBoardStrokeSize };

package/dist/protocol/dist/board-constants.js

@@ -1,126 +1,13 @@
 //#region ../protocol/dist/board-constants.js
-const DEFAULT_BOARD_RENDER_LIMITS = {
-	particles: 2e4,
-	vertices: 5e5,
-	dynamicVertices: 15e4,
-	drawCalls: 400,
-	filterPasses: 24,
-	renderTexturePixels: 16777216,
-	textureBytes: 536870912,
-	bufferBytes: 268435456,
-	simulationSteps: 1e5
-};
-const BOARD_BUILTIN_CLIP_KINDS = [
-	"motion.path",
-	"draw.reveal",
-	"text.reveal",
-	"effects.particles",
-	"effects.trail",
-	"effects.impact",
-	"effects.flash",
-	"camera.focus",
-	"camera.shake"
-];
-const BOARD_BUILTIN_EFFECT_KINDS = [
-	"effects.pulse",
-	"effects.float",
-	"effects.deal"
-];
-/**
-* World-space typography for board text.
-*
-* These live here rather than beside the renderer because the document schema
-* constrains persisted font sizes with them, and the schema must not depend on
-* anything that draws.
-*/
 const BOARD_TEXT_FONT_FAMILY = "Geist";
 const BOARD_ARROW_STROKE_SIZE = 2.5;
-const BOARD_CONNECTION_STROKE_SIZE = 2.5;
-/**
-* Stroke width bounds, shared by every stroked board entity.
-*
-* Defined here (not beside the editor) because the persisted schemas clamp with
-* them: a single range is what keeps a width authored by the editor, an agent or
-* the CLI from being silently re-clamped to something else on read.
-*/
 const BOARD_STROKE_MIN_SIZE = 1;
 const BOARD_STROKE_MAX_SIZE = 64;
 function clampBoardStrokeSize(size) {
-	if (!Number.isFinite(size)) return BOARD_CONNECTION_STROKE_SIZE;
+	if (!Number.isFinite(size)) return BOARD_ARROW_STROKE_SIZE;
 	return Math.min(64, Math.max(1, size));
 }
-/**
-* Font stacks used by every board renderer.
-*
-* A bare "Geist" would render CJK (and anything else outside the Latin subset)
-* as missing-glyph boxes, because the shipped webfont is Latin-only. The stack
-* mirrors the web `--font-sans` / `--font-mono` tokens and adds the common CJK
-* families, so both the browser and a headless export fall back to a real face
-* instead of tofu.
-*/
 const BOARD_FONT_STACK = "\"Geist\", system-ui, -apple-system, \"Noto Sans CJK SC\", \"Noto Sans SC\", \"PingFang SC\", \"Microsoft YaHei\", sans-serif";
 const BOARD_MONO_FONT_STACK = "\"Geist Mono\", \"Fira Code\", ui-monospace, \"Noto Sans Mono CJK SC\", monospace";
-function clipSchema(id) {
-	switch (id) {
-		case "motion.path": return { params: { points: {
-			coordinateSpace: "world-offset",
-			unit: "board"
-		} } };
-		case "effects.particles": return { params: { bounds: {
-			coordinateSpace: "world",
-			unit: "board"
-		} } };
-		case "camera.focus": return { params: {
-			focus: {
-				coordinateSpace: "world",
-				unit: "board"
-			},
-			padding: {
-				coordinateSpace: "screen",
-				unit: "css-px"
-			},
-			minZoom: { unit: "ratio" },
-			maxZoom: { unit: "ratio" }
-		} };
-		case "camera.shake": return { params: { amount: {
-			coordinateSpace: "screen-offset",
-			unit: "css-px"
-		} } };
-		default: return;
-	}
-}
-function effectSchema(id) {
-	switch (id) {
-		case "effects.deal": return { params: {
-			lift: { unit: "board" },
-			swing: { unit: "board" },
-			curve: { unit: "board" },
-			tilt: { unit: "degree" },
-			scale: { unit: "ratio" },
-			duration: { unit: "ms" },
-			landing: { unit: "ms" }
-		} };
-		default: return;
-	}
-}
-const BOARD_BUILTIN_CAPABILITIES = [...BOARD_BUILTIN_CLIP_KINDS.map((id) => {
-	const schema = clipSchema(id);
-	return {
-		kind: "clip",
-		id,
-		version: 1,
-		renderers: ["webgpu", "webgl"],
-		...schema ? { schema } : {}
-	};
-}), ...BOARD_BUILTIN_EFFECT_KINDS.map((id) => {
-	const schema = effectSchema(id);
-	return {
-		kind: "effect",
-		id,
-		version: 1,
-		renderers: ["webgpu", "webgl"],
-		...schema ? { schema } : {}
-	};
-})];
 //#endregion
-export { BOARD_ARROW_STROKE_SIZE, BOARD_BUILTIN_CAPABILITIES, BOARD_BUILTIN_CLIP_KINDS, BOARD_BUILTIN_EFFECT_KINDS, BOARD_CONNECTION_STROKE_SIZE, BOARD_FONT_STACK, BOARD_MONO_FONT_STACK, BOARD_STROKE_MAX_SIZE, BOARD_STROKE_MIN_SIZE, BOARD_TEXT_FONT_FAMILY, DEFAULT_BOARD_RENDER_LIMITS, clampBoardStrokeSize };
+export { BOARD_ARROW_STROKE_SIZE, BOARD_FONT_STACK, BOARD_MONO_FONT_STACK, BOARD_STROKE_MAX_SIZE, BOARD_STROKE_MIN_SIZE, BOARD_TEXT_FONT_FAMILY, clampBoardStrokeSize };

package/dist/protocol/dist/board-layout.d.ts

@@ -0,0 +1,59 @@
+import { BoardArrowAnchor, BoardArrowBinding, BoardArrowEnd, BoardDrawPoint, BoardItem, BoardTextItem, BoardVec2 } from "./board-model.js";
+//#region ../protocol/dist/board-layout.d.ts
+type BoardRect = {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+};
+type BoardFrame = BoardRect & {
+  rotation: number;
+};
+type BoardMatrix = readonly [number, number, number, number, number, number];
+declare const IDENTITY_MATRIX: BoardMatrix;
+declare function multiplyMatrix(parent: BoardMatrix, child: BoardMatrix): BoardMatrix;
+declare function invertMatrix(matrix: BoardMatrix): BoardMatrix;
+declare function applyMatrix(matrix: BoardMatrix, point: BoardVec2): BoardVec2;
+declare function scaleVector(scale: BoardItem["scale"]): BoardVec2;
+type BoardTextMeasurer = (text: string, fontSize: number, fontWeight: number, font: string) => number | null;
+declare function setBoardTextMeasurer(measurer?: BoardTextMeasurer): void;
+declare function estimateTextWidth(text: string, fontSize: number): number;
+type BoardTextLayout = {
+  width: number;
+  height: number;
+  lines: string[];
+  lineHeight: number;
+};
+declare function clampBoardFontSize(fontSize: number): number;
+declare function layoutBoardText(props: Pick<BoardTextItem["props"], "text" | "fontSize" | "fontWeight" | "font" | "lineHeight" | "width">): BoardTextLayout;
+declare function drawSampleRadius(strokeWidth: number, pressure: number): number;
+declare function drawPointsBounds(points: readonly BoardDrawPoint[], strokeWidth: number): BoardRect;
+declare function pointsRect(points: readonly BoardVec2[]): BoardRect;
+declare function isArrowBinding(end: BoardArrowEnd): end is BoardArrowBinding;
+declare function arrowBindings(item: BoardItem): string[];
+declare function bendControl(start: BoardVec2, end: BoardVec2, bend: number): BoardVec2;
+type BoardItemLookup = (id: string) => BoardItem | undefined;
+type BoardLayout = {
+  has(id: string): boolean;
+  box(id: string): BoardRect;
+  matrix(id: string): BoardMatrix;
+  localMatrix(id: string): BoardMatrix;
+  parentMatrix(id: string): BoardMatrix;
+  bounds(id: string): BoardRect;
+  frame(id: string): BoardFrame;
+  arrowEnd(id: string, which: "start" | "end"): BoardVec2;
+  setLookup(lookup: BoardItemLookup): void;
+  invalidate(ids?: Iterable<string>): void;
+};
+declare function createBoardLayout(initialLookup: BoardItemLookup, dependents?: (id: string) => Iterable<string>): BoardLayout;
+declare function rotateAround(point: BoardVec2, pivot: BoardVec2, degrees: number): BoardVec2;
+declare function framePoint(frame: BoardFrame, nx: number, ny: number): BoardVec2;
+declare function autoAnchorSide(frame: BoardFrame, toward: BoardVec2): "top" | "right" | "bottom" | "left";
+declare function sideAnchor(side: "top" | "right" | "bottom" | "left", offset: number): {
+  x: number;
+  y: number;
+};
+declare function anchorPoint(frame: BoardFrame, anchor: BoardArrowAnchor, toward: BoardVec2): BoardVec2;
+declare function createDocumentLayout(items: Readonly<Record<string, BoardItem>>): BoardLayout;
+//#endregion
+export { BoardFrame, BoardItemLookup, BoardLayout, BoardMatrix, BoardRect, BoardTextLayout, BoardTextMeasurer, IDENTITY_MATRIX, anchorPoint, applyMatrix, arrowBindings, autoAnchorSide, bendControl, clampBoardFontSize, createBoardLayout, createDocumentLayout, drawPointsBounds, drawSampleRadius, estimateTextWidth, framePoint, invertMatrix, isArrowBinding, layoutBoardText, multiplyMatrix, pointsRect, rotateAround, scaleVector, setBoardTextMeasurer, sideAnchor };

package/dist/protocol/dist/board-layout.js

@@ -0,0 +1,482 @@
+import "./board-constants.js";
+//#region ../protocol/dist/board-layout.js
+const IDENTITY_MATRIX = [
+	1,
+	0,
+	0,
+	1,
+	0,
+	0
+];
+function multiplyMatrix(parent, child) {
+	const [a1, b1, c1, d1, tx1, ty1] = parent;
+	const [a2, b2, c2, d2, tx2, ty2] = child;
+	return [
+		a1 * a2 + c1 * b2,
+		b1 * a2 + d1 * b2,
+		a1 * c2 + c1 * d2,
+		b1 * c2 + d1 * d2,
+		a1 * tx2 + c1 * ty2 + tx1,
+		b1 * tx2 + d1 * ty2 + ty1
+	];
+}
+function invertMatrix(matrix) {
+	const [a, b, c, d, tx, ty] = matrix;
+	const det = a * d - b * c || 1e-12;
+	return [
+		d / det,
+		-b / det,
+		-c / det,
+		a / det,
+		(c * ty - d * tx) / det,
+		(b * tx - a * ty) / det
+	];
+}
+function applyMatrix(matrix, point) {
+	const [a, b, c, d, tx, ty] = matrix;
+	return {
+		x: a * point.x + c * point.y + tx,
+		y: b * point.x + d * point.y + ty
+	};
+}
+function scaleVector(scale) {
+	return typeof scale === "number" ? {
+		x: scale,
+		y: scale
+	} : scale;
+}
+let textMeasurer;
+function setBoardTextMeasurer(measurer) {
+	textMeasurer = measurer;
+	textSizeCache.clear();
+}
+function isWideCharacter(code) {
+	return code >= 4352 && code <= 4447 || code >= 11904 && code <= 42191 || code >= 44032 && code <= 55203 || code >= 63744 && code <= 64255 || code >= 65072 && code <= 65103 || code >= 65280 && code <= 65376 || code >= 65504 && code <= 65510 || code >= 127744 && code <= 129791 || code >= 131072 && code <= 262141;
+}
+function estimateTextWidth(text, fontSize) {
+	let ems = 0;
+	for (const character of text) {
+		const code = character.codePointAt(0) ?? 0;
+		if (character === " ") ems += .28;
+		else if (isWideCharacter(code)) ems += 1;
+		else if (/[il.,:;'|!]/.test(character)) ems += .3;
+		else if (/[mwMW@]/.test(character)) ems += .85;
+		else if (/[A-Z0-9]/.test(character)) ems += .64;
+		else ems += .55;
+	}
+	return ems * fontSize;
+}
+function measureLine(text, fontSize, fontWeight, font) {
+	return textMeasurer?.(text, fontSize, fontWeight, font) ?? estimateTextWidth(text, fontSize);
+}
+function wrapParagraph(paragraph, width, measure) {
+	if (!paragraph) return [""];
+	const tokens = paragraph.match(/[\u1100-\u115f\u2e80-\ua4cf\uac00-\ud7a3\uf900-\ufaff\uff00-\uff60]|[^\s\u1100-\u115f\u2e80-\ua4cf\uac00-\ud7a3\uf900-\ufaff\uff00-\uff60]+|\s+/g) ?? [paragraph];
+	const lines = [];
+	let line = "";
+	for (const token of tokens) {
+		const candidate = line + token;
+		if (!line || measure(candidate.trimEnd()) <= width) {
+			line = candidate;
+			continue;
+		}
+		lines.push(line.trimEnd());
+		line = /^\s+$/.test(token) ? "" : token;
+	}
+	lines.push(line.trimEnd());
+	return lines;
+}
+const textSizeCache = /* @__PURE__ */ new Map();
+const TEXT_CACHE_LIMIT = 4096;
+function clampBoardFontSize(fontSize) {
+	return Math.min(512, Math.max(2, fontSize));
+}
+function layoutBoardText(props) {
+	const fontSize = clampBoardFontSize(props.fontSize ?? 24);
+	const key = `${fontSize}|${props.fontWeight}|${props.font}|${props.lineHeight}|${props.width ?? ""}|${props.text}`;
+	const cached = textSizeCache.get(key);
+	if (cached) return cached;
+	const measure = (text) => measureLine(text, fontSize, props.fontWeight ?? 500, props.font ?? "sans");
+	const paragraphs = (props.text || "").split("\n");
+	const lines = props.width ? paragraphs.flatMap((paragraph) => wrapParagraph(paragraph, props.width, measure)) : paragraphs;
+	const lineHeight = fontSize * (props.lineHeight ?? 4 / 3);
+	const widest = lines.reduce((max, line) => Math.max(max, measure(line)), 0);
+	const layout = {
+		width: Math.max(props.width ?? 0, widest, fontSize * .5),
+		height: Math.max(1, lines.length) * lineHeight,
+		lines,
+		lineHeight
+	};
+	if (textSizeCache.size >= TEXT_CACHE_LIMIT) textSizeCache.clear();
+	textSizeCache.set(key, layout);
+	return layout;
+}
+function drawSampleRadius(strokeWidth, pressure) {
+	const clamped = Math.min(1, Math.max(0, pressure));
+	return Math.max(.5, strokeWidth / 2 * (.5 + clamped));
+}
+function drawPointsBounds(points, strokeWidth) {
+	if (points.length === 0) return {
+		x: 0,
+		y: 0,
+		width: 1,
+		height: 1
+	};
+	let minX = Number.POSITIVE_INFINITY;
+	let minY = Number.POSITIVE_INFINITY;
+	let maxX = Number.NEGATIVE_INFINITY;
+	let maxY = Number.NEGATIVE_INFINITY;
+	for (const point of points) {
+		const radius = drawSampleRadius(strokeWidth, point.p);
+		minX = Math.min(minX, point.x - radius);
+		minY = Math.min(minY, point.y - radius);
+		maxX = Math.max(maxX, point.x + radius);
+		maxY = Math.max(maxY, point.y + radius);
+	}
+	return {
+		x: minX,
+		y: minY,
+		width: Math.max(1, maxX - minX),
+		height: Math.max(1, maxY - minY)
+	};
+}
+function pointsRect(points) {
+	let minX = Number.POSITIVE_INFINITY;
+	let minY = Number.POSITIVE_INFINITY;
+	let maxX = Number.NEGATIVE_INFINITY;
+	let maxY = Number.NEGATIVE_INFINITY;
+	for (const point of points) {
+		minX = Math.min(minX, point.x);
+		minY = Math.min(minY, point.y);
+		maxX = Math.max(maxX, point.x);
+		maxY = Math.max(maxY, point.y);
+	}
+	if (!Number.isFinite(minX)) return {
+		x: 0,
+		y: 0,
+		width: 1,
+		height: 1
+	};
+	return {
+		x: minX,
+		y: minY,
+		width: Math.max(1, maxX - minX),
+		height: Math.max(1, maxY - minY)
+	};
+}
+function isArrowBinding(end) {
+	return typeof end.item === "string";
+}
+function arrowBindings(item) {
+	if (item.type !== "arrow") return [];
+	const props = item.props;
+	const ids = [props.start, props.end].filter(isArrowBinding).map((end) => end.item);
+	return [...new Set(ids)];
+}
+function bendControl(start, end, bend) {
+	const mid = {
+		x: (start.x + end.x) / 2,
+		y: (start.y + end.y) / 2
+	};
+	if (!bend) return mid;
+	const dx = end.x - start.x;
+	const dy = end.y - start.y;
+	const length = Math.hypot(dx, dy) || 1;
+	const offset = bend * length;
+	return {
+		x: mid.x + -dy / length * offset,
+		y: mid.y + dx / length * offset
+	};
+}
+const MAX_DEPTH = 64;
+function createBoardLayout(initialLookup, dependents) {
+	let lookup = initialLookup;
+	const boxes = /* @__PURE__ */ new Map();
+	const matrices = /* @__PURE__ */ new Map();
+	const bounds = /* @__PURE__ */ new Map();
+	function matrixOf(id, depth = 0) {
+		const cached = matrices.get(id);
+		if (cached) return cached;
+		const item = lookup(id);
+		if (!item) return IDENTITY_MATRIX;
+		const matrix = multiplyMatrix(item.parent && depth < MAX_DEPTH && lookup(item.parent) ? matrixOf(item.parent, depth + 1) : IDENTITY_MATRIX, localMatrixOf(id));
+		matrices.set(id, matrix);
+		return matrix;
+	}
+	function localMatrixOf(id) {
+		const item = lookup(id);
+		if (!item) return IDENTITY_MATRIX;
+		if (item.type === "arrow") return translate(item.position);
+		const box = boxOf(id);
+		const scale = scaleVector(item.scale);
+		const radians = item.rotation * Math.PI / 180;
+		const cos = Math.cos(radians);
+		const sin = Math.sin(radians);
+		const ox = box.x + item.origin.x * box.width;
+		const oy = box.y + item.origin.y * box.height;
+		const a = cos * scale.x;
+		const b = sin * scale.x;
+		const c = -sin * scale.y;
+		const d = cos * scale.y;
+		return [
+			a,
+			b,
+			c,
+			d,
+			item.position.x + ox - (a * ox + c * oy),
+			item.position.y + oy - (b * ox + d * oy)
+		];
+	}
+	function boxOf(id, depth = 0) {
+		const cached = boxes.get(id);
+		if (cached) return cached;
+		const item = lookup(id);
+		let box;
+		if (!item) box = {
+			x: 0,
+			y: 0,
+			width: 1,
+			height: 1
+		};
+		else if ("size" in item && item.size) box = {
+			x: 0,
+			y: 0,
+			width: item.size.width,
+			height: item.size.height
+		};
+		else if (item.type === "text") {
+			const layout = layoutBoardText(item.props);
+			box = {
+				x: 0,
+				y: 0,
+				width: layout.width,
+				height: layout.height
+			};
+		} else if (item.type === "draw") box = drawPointsBounds(item.props.points, item.style.strokeWidth ?? 4);
+		else if (item.type === "arrow") {
+			const props = item.props;
+			const toLocal = invertMatrix(multiplyMatrix(parentOf(item, depth), translate(item.position)));
+			const start = isArrowBinding(props.start) ? applyMatrix(toLocal, resolveBoundEnd(item, props.start, props.end, depth)) : props.start;
+			const end = isArrowBinding(props.end) ? applyMatrix(toLocal, resolveBoundEnd(item, props.end, props.start, depth)) : props.end;
+			const points = [
+				start,
+				end,
+				...props.waypoints
+			];
+			if (props.bend) points.push(bendControl(start, end, props.bend));
+			const rect = pointsRect(points);
+			const pad = Math.max(8, (item.style.strokeWidth ?? 2.5) * 2);
+			box = {
+				x: rect.x - pad,
+				y: rect.y - pad,
+				width: rect.width + pad * 2,
+				height: rect.height + pad * 2
+			};
+		} else box = {
+			x: 0,
+			y: 0,
+			width: 240,
+			height: 160
+		};
+		boxes.set(id, box);
+		return box;
+	}
+	function parentOf(item, depth) {
+		return item.parent && depth < MAX_DEPTH && lookup(item.parent) ? matrixOf(item.parent, depth + 1) : IDENTITY_MATRIX;
+	}
+	function resolveBoundEnd(arrow, end, other, depth) {
+		const target = lookup(end.item);
+		const arrowSpace = multiplyMatrix(parentOf(arrow, depth), translate(arrow.position));
+		if (!target || target.type === "arrow" || depth >= MAX_DEPTH) return applyMatrix(arrowSpace, {
+			x: 0,
+			y: 0
+		});
+		const frame = frameOf(end.item, depth + 1);
+		const toward = isArrowBinding(other) ? lookup(other.item) && lookup(other.item)?.type !== "arrow" ? center(frameOf(other.item, depth + 1)) : center(frame) : applyMatrix(arrowSpace, other);
+		return anchorPoint(frame, end.anchor, toward);
+	}
+	function frameOf(id, depth = 0) {
+		boxOf(id, depth);
+		const box = boxes.get(id);
+		const matrix = matrixOf(id, depth);
+		const [a, b, c, d] = matrix;
+		const centerPoint = applyMatrix(matrix, {
+			x: box.x + box.width / 2,
+			y: box.y + box.height / 2
+		});
+		const width = box.width * Math.hypot(a, b);
+		const height = box.height * Math.hypot(c, d);
+		return {
+			x: centerPoint.x - width / 2,
+			y: centerPoint.y - height / 2,
+			width,
+			height,
+			rotation: Math.atan2(b, a) * 180 / Math.PI
+		};
+	}
+	function boundsOf(id) {
+		const cached = bounds.get(id);
+		if (cached) return cached;
+		const box = boxOf(id);
+		const matrix = matrixOf(id);
+		const rect = pointsRect([
+			applyMatrix(matrix, {
+				x: box.x,
+				y: box.y
+			}),
+			applyMatrix(matrix, {
+				x: box.x + box.width,
+				y: box.y
+			}),
+			applyMatrix(matrix, {
+				x: box.x + box.width,
+				y: box.y + box.height
+			}),
+			applyMatrix(matrix, {
+				x: box.x,
+				y: box.y + box.height
+			})
+		]);
+		bounds.set(id, rect);
+		return rect;
+	}
+	function setLookup(nextLookup) {
+		lookup = nextLookup;
+	}
+	function invalidate(ids) {
+		if (!ids) {
+			boxes.clear();
+			matrices.clear();
+			bounds.clear();
+			return;
+		}
+		const queue = [...ids];
+		const seen = /* @__PURE__ */ new Set();
+		while (queue.length) {
+			const id = queue.pop();
+			if (seen.has(id)) continue;
+			seen.add(id);
+			boxes.delete(id);
+			matrices.delete(id);
+			bounds.delete(id);
+			if (dependents) for (const next of dependents(id)) queue.push(next);
+		}
+	}
+	return {
+		has: (id) => lookup(id) !== void 0,
+		box: (id) => boxOf(id),
+		matrix: (id) => matrixOf(id),
+		localMatrix: (id) => localMatrixOf(id),
+		parentMatrix: (id) => {
+			const item = lookup(id);
+			return item ? parentOf(item, 0) : IDENTITY_MATRIX;
+		},
+		bounds: boundsOf,
+		frame: (id) => frameOf(id),
+		arrowEnd: (id, which) => {
+			const item = lookup(id);
+			if (item?.type !== "arrow") return {
+				x: 0,
+				y: 0
+			};
+			const arrow = item;
+			const [end, other] = which === "start" ? [arrow.props.start, arrow.props.end] : [arrow.props.end, arrow.props.start];
+			return isArrowBinding(end) ? resolveBoundEnd(arrow, end, other, 0) : applyMatrix(matrixOf(id), end);
+		},
+		invalidate,
+		setLookup
+	};
+}
+function translate(point) {
+	return [
+		1,
+		0,
+		0,
+		1,
+		point.x,
+		point.y
+	];
+}
+function center(frame) {
+	return {
+		x: frame.x + frame.width / 2,
+		y: frame.y + frame.height / 2
+	};
+}
+function rotateAround(point, pivot, degrees) {
+	if (!degrees) return point;
+	const radians = degrees * Math.PI / 180;
+	const cos = Math.cos(radians);
+	const sin = Math.sin(radians);
+	const dx = point.x - pivot.x;
+	const dy = point.y - pivot.y;
+	return {
+		x: pivot.x + dx * cos - dy * sin,
+		y: pivot.y + dx * sin + dy * cos
+	};
+}
+function framePoint(frame, nx, ny) {
+	return rotateAround({
+		x: frame.x + nx * frame.width,
+		y: frame.y + ny * frame.height
+	}, center(frame), frame.rotation);
+}
+function autoAnchorSide(frame, toward) {
+	const local = rotateAround(toward, center(frame), -frame.rotation);
+	const c = center(frame);
+	const dx = (local.x - c.x) / Math.max(frame.width / 2, 1e-4);
+	const dy = (local.y - c.y) / Math.max(frame.height / 2, 1e-4);
+	if (Math.abs(dx) >= Math.abs(dy)) return dx >= 0 ? "right" : "left";
+	return dy >= 0 ? "bottom" : "top";
+}
+function sideAnchor(side, offset) {
+	switch (side) {
+		case "top": return {
+			x: offset,
+			y: 0
+		};
+		case "bottom": return {
+			x: offset,
+			y: 1
+		};
+		case "left": return {
+			x: 0,
+			y: offset
+		};
+		default: return {
+			x: 1,
+			y: offset
+		};
+	}
+}
+function anchorPoint(frame, anchor, toward) {
+	if (anchor === "auto") {
+		const normalized = sideAnchor(autoAnchorSide(frame, toward), .5);
+		return framePoint(frame, normalized.x, normalized.y);
+	}
+	if ("side" in anchor) {
+		const normalized = sideAnchor(anchor.side, anchor.offset);
+		return framePoint(frame, normalized.x, normalized.y);
+	}
+	return framePoint(frame, anchor.x, anchor.y);
+}
+function createDocumentLayout(items) {
+	let index = null;
+	const dependents = (id) => {
+		if (!index) {
+			index = /* @__PURE__ */ new Map();
+			for (const [itemId, item] of Object.entries(items)) {
+				const refs = [...item.parent ? [item.parent] : [], ...arrowBindings(item)];
+				for (const ref of refs) {
+					const list = index.get(ref) ?? [];
+					list.push(itemId);
+					index.set(ref, list);
+				}
+			}
+		}
+		return index.get(id) ?? [];
+	};
+	return createBoardLayout((id) => items[id], dependents);
+}
+//#endregion
+export { IDENTITY_MATRIX, anchorPoint, applyMatrix, arrowBindings, autoAnchorSide, bendControl, clampBoardFontSize, createBoardLayout, createDocumentLayout, drawPointsBounds, drawSampleRadius, estimateTextWidth, framePoint, invertMatrix, isArrowBinding, layoutBoardText, multiplyMatrix, pointsRect, rotateAround, scaleVector, setBoardTextMeasurer, sideAnchor };