@neta-art/cohub 8.24.0 → 9.0.1

package/dist/board/core/palette.js

@@ -1,10 +1,4 @@
 //#region src/board/core/palette.ts
-/**
-* Label color fallbacks mirror `--board-color-*-label`, which every theme maps
-* to `--text-primary`: labels sit on a *translucent* fill over the page, not on
-* a saturated swatch, so a tinted label would be dark-on-dark. Keeping these in
-* step with `theme.css` is what makes a headless export match the screen.
-*/
 const LABEL_DARK = 16053492;
 const LABEL_LIGHT = 1579035;
 const BOARD_COLORS = [
@@ -143,24 +137,25 @@ function isBoardColorId(value) {
 function boardColorCssVar(id, part) {
 	return `--board-color-${id}-${part}`;
 }
-/** Resolve a color id to concrete values for a color mode. Unknown → brand. */
 function resolveBoardColor(id, mode) {
 	return ((isBoardColorId(id) ? COLOR_INDEX.get(id) : void 0) ?? COLOR_INDEX.get("brand"))[mode];
 }
-/** Build a full shape-color table from hard-coded fallbacks (export / SSR). */
 function buildFallbackShapeColors(mode) {
 	const out = {};
 	for (const entry of BOARD_COLORS) out[entry.id] = entry[mode];
 	return out;
 }
-/**
-* Pick a concrete color from a live shape-color table, falling back to the
-* default brand entry when the id is unknown.
-*/
 function pickBoardColor(colors, id, mode = "dark") {
 	if (colors && isBoardColorId(id) && colors[id]) return colors[id];
 	if (colors) return colors[DEFAULT_BOARD_COLOR];
 	return resolveBoardColor(id, mode);
 }
+function resolveItemColor(color, fallback, colors, mode, parseCss, part = "stroke") {
+	const value = typeof color === "object" && color ? color[mode] : color;
+	if (value === void 0) return pickBoardColor(colors, fallback, mode)[part];
+	const token = value.trim().toLowerCase();
+	if (isBoardColorId(token)) return pickBoardColor(colors, token, mode)[part];
+	return parseCss(value) ?? pickBoardColor(colors, fallback, mode)[part];
+}
 //#endregion
-export { BOARD_COLORS, DEFAULT_BOARD_COLOR, boardColorCssVar, buildFallbackShapeColors, isBoardColorId, pickBoardColor, resolveBoardColor };
+export { BOARD_COLORS, DEFAULT_BOARD_COLOR, boardColorCssVar, buildFallbackShapeColors, isBoardColorId, pickBoardColor, resolveBoardColor, resolveItemColor };

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

@@ -0,0 +1,33 @@
+import { BoardDocument, BoardItem } from "../../protocol/dist/board-model.js";
+import { BoardFrame, BoardItemLookup, BoardLayout, BoardMatrix, BoardRect } from "../../protocol/dist/board-layout.js";
+import "../../protocol/dist/index.js";
+//#region src/board/core/scene.d.ts
+type SceneItem<T extends BoardItem = BoardItem> = T & {
+  readonly id: string;
+  readonly frame: BoardFrame;
+};
+type BoardSceneItem = SceneItem;
+type BoardScene = {
+  readonly items: readonly BoardSceneItem[];
+  get(id: string): BoardSceneItem | undefined;
+  indexOf(id: string): number;
+  readonly layout: BoardLayout;
+  children(id: string | undefined): readonly string[];
+  descendants(id: string): string[];
+  binders(id: string): readonly string[];
+  opacity(id: string): number;
+};
+declare function orderBoardItems(items: Readonly<Record<string, BoardItem>>): string[];
+declare function buildBoardScene(document: BoardDocument, previous?: BoardScene | null): BoardScene;
+declare function refreshBoardScene(previous: BoardScene, lookup: BoardItemLookup, ids: Iterable<string>): BoardScene;
+declare function toSceneItem(id: string, item: BoardItem, layout: BoardLayout): BoardSceneItem;
+declare function sceneItemToItem(scene: BoardSceneItem | (BoardItem & {
+  id: string;
+  frame?: BoardFrame;
+}), layout: BoardLayout): BoardItem;
+declare function placeItem(item: BoardItem, frame: BoardFrame, parent: BoardMatrix, box: BoardRect): BoardItem;
+declare function sceneItemsToRecord(items: readonly (BoardSceneItem | (BoardItem & {
+  id: string;
+}))[], layout: BoardLayout): Record<string, BoardItem>;
+//#endregion
+export { BoardScene, BoardSceneItem, SceneItem, buildBoardScene, orderBoardItems, placeItem, refreshBoardScene, sceneItemToItem, sceneItemsToRecord, toSceneItem };

package/dist/board/core/scene.js

@@ -0,0 +1,302 @@
+import { IDENTITY_MATRIX, applyMatrix, arrowBindings, clampBoardFontSize, createBoardLayout, drawPointsBounds, invertMatrix, layoutBoardText, scaleVector } from "../../protocol/dist/board-layout.js";
+//#region src/board/core/scene.ts
+const EPSILON = 1e-6;
+function stripScene(item) {
+	if (!("frame" in item) && !("id" in item)) return item;
+	const { id: _id, frame: _frame, ...rest } = item;
+	return rest;
+}
+function orderBoardItems(items) {
+	const children = /* @__PURE__ */ new Map();
+	for (const [id, item] of Object.entries(items)) {
+		const parent = item.parent && items[item.parent] && item.parent !== id ? item.parent : "";
+		const list = children.get(parent) ?? [];
+		list.push(id);
+		children.set(parent, list);
+	}
+	const compare = (a, b) => (items[a]?.z ?? 0) - (items[b]?.z ?? 0) || (a < b ? -1 : a > b ? 1 : 0);
+	for (const list of children.values()) list.sort(compare);
+	const order = [];
+	const seen = /* @__PURE__ */ new Set();
+	const visit = (id) => {
+		if (seen.has(id)) return;
+		seen.add(id);
+		order.push(id);
+		for (const child of children.get(id) ?? []) visit(child);
+	};
+	for (const id of children.get("") ?? []) visit(id);
+	for (const id of Object.keys(items)) visit(id);
+	return order;
+}
+function buildBoardScene(document, previous) {
+	const items = document.items;
+	const children = /* @__PURE__ */ new Map();
+	const binders = /* @__PURE__ */ new Map();
+	for (const [id, item] of Object.entries(items)) {
+		const parent = item.parent && items[item.parent] ? item.parent : "";
+		const list = children.get(parent) ?? [];
+		list.push(id);
+		children.set(parent, list);
+		for (const bound of arrowBindings(item)) binders.set(bound, [...binders.get(bound) ?? [], id]);
+	}
+	const layout = createBoardLayout((id) => items[id], (id) => [...children.get(id) ?? [], ...binders.get(id) ?? []]);
+	const stable = /* @__PURE__ */ new Map();
+	const isStable = (id, depth = 0) => {
+		const known = stable.get(id);
+		if (known !== void 0) return known;
+		const item = items[id];
+		const before = previous?.get(id);
+		let result = Boolean(item && before && stripSceneSource(before) === item) && depth < 64;
+		if (result && item?.parent && items[item.parent]) result = isStable(item.parent, depth + 1);
+		if (result && item) {
+			for (const bound of arrowBindings(item)) if (items[bound] && !isStable(bound, depth + 1)) result = false;
+		}
+		stable.set(id, result);
+		return result;
+	};
+	const ordered = orderBoardItems(items);
+	const sceneItems = [];
+	const byId = /* @__PURE__ */ new Map();
+	const indexById = /* @__PURE__ */ new Map();
+	for (const id of ordered) {
+		const item = items[id];
+		const scene = (isStable(id) ? previous?.get(id) : void 0) ?? toSceneItem(id, item, layout);
+		indexById.set(id, sceneItems.length);
+		sceneItems.push(scene);
+		byId.set(id, scene);
+	}
+	return {
+		items: sceneItems,
+		get: (id) => byId.get(id),
+		indexOf: (id) => indexById.get(id) ?? -1,
+		layout,
+		children: (id) => children.get(id ?? "") ?? [],
+		descendants: (id) => {
+			const result = [];
+			const seen = /* @__PURE__ */ new Set([id]);
+			const stack = [...children.get(id) ?? []];
+			while (stack.length) {
+				const next = stack.pop();
+				if (seen.has(next)) continue;
+				seen.add(next);
+				result.push(next);
+				stack.push(...children.get(next) ?? []);
+			}
+			return result;
+		},
+		binders: (id) => binders.get(id) ?? [],
+		opacity: (id) => cumulativeOpacity((key) => items[key], id)
+	};
+}
+function cumulativeOpacity(lookup, id) {
+	let value = 1;
+	let cursor = id;
+	for (let depth = 0; cursor && depth < 64; depth += 1) {
+		const item = lookup(cursor);
+		if (!item) break;
+		value *= item.opacity;
+		cursor = item.parent;
+	}
+	return value;
+}
+function refreshBoardScene(previous, lookup, ids) {
+	const changedIds = [...ids];
+	if (changedIds.length === 0) return previous;
+	const dependents = (id) => [...previous.children(id), ...previous.binders(id)];
+	const layout = previous.layout;
+	layout.setLookup(lookup);
+	layout.invalidate(changedIds);
+	const affected = /* @__PURE__ */ new Set();
+	const stack = [...changedIds];
+	while (stack.length) {
+		const id = stack.pop();
+		if (affected.has(id) || !lookup(id)) continue;
+		affected.add(id);
+		stack.push(...dependents(id));
+	}
+	if (affected.size === 0) return previous;
+	const sceneItems = previous.items.slice();
+	const chain = refreshed.get(previous);
+	const base = chain?.base ?? previous;
+	const overrides = new Map(chain?.overrides);
+	for (const id of affected) {
+		const index = previous.indexOf(id);
+		const scene = toSceneItem(id, lookup(id), layout);
+		overrides.set(id, scene);
+		if (index >= 0) sceneItems[index] = scene;
+	}
+	const scene = {
+		...base,
+		items: sceneItems,
+		get: (id) => overrides.get(id) ?? base.get(id),
+		layout,
+		opacity: (id) => cumulativeOpacity(lookup, id)
+	};
+	refreshed.set(scene, {
+		base,
+		overrides
+	});
+	return scene;
+}
+const refreshed = /* @__PURE__ */ new WeakMap();
+const sources = /* @__PURE__ */ new WeakMap();
+function stripSceneSource(scene) {
+	return sources.get(scene);
+}
+function toSceneItem(id, item, layout) {
+	const scene = {
+		...item,
+		id,
+		frame: layout.frame(id)
+	};
+	sources.set(scene, item);
+	return scene;
+}
+function sameFrame(a, b) {
+	return Math.abs(a.x - b.x) < EPSILON && Math.abs(a.y - b.y) < EPSILON && Math.abs(a.width - b.width) < EPSILON && Math.abs(a.height - b.height) < EPSILON && Math.abs(a.rotation - b.rotation) < EPSILON;
+}
+function sceneItemToItem(scene, layout) {
+	const source = sources.get(scene);
+	if (source) return source;
+	const item = stripScene(scene);
+	const frame = scene.frame;
+	if (!frame) return item;
+	if (layout.has(scene.id) && sameFrame(frame, layout.frame(scene.id))) return item;
+	return placeItem(item, frame, item.parent && layout.has(item.parent) ? layout.matrix(item.parent) : IDENTITY_MATRIX, itemBox(item, layout, scene.id));
+}
+function itemBox(item, layout, id) {
+	if ("size" in item && item.size) return {
+		x: 0,
+		y: 0,
+		width: item.size.width,
+		height: item.size.height
+	};
+	if (item.type === "text") {
+		const text = layoutBoardText(item.props);
+		return {
+			x: 0,
+			y: 0,
+			width: text.width,
+			height: text.height
+		};
+	}
+	if (item.type === "draw") return drawPointsBounds(item.props.points, item.style.strokeWidth ?? 4);
+	return layout.box(id);
+}
+function placeItem(item, frame, parent, box) {
+	const [a, b] = parent;
+	const parentScale = Math.hypot(a, b) || 1;
+	const parentRotation = Math.atan2(b, a) * 180 / Math.PI;
+	const center = applyMatrix(invertMatrix(parent), {
+		x: frame.x + frame.width / 2,
+		y: frame.y + frame.height / 2
+	});
+	const scale = scaleVector(item.scale);
+	const width = frame.width / parentScale / (Math.abs(scale.x) || 1);
+	const height = frame.height / parentScale / (Math.abs(scale.y) || 1);
+	if (item.type === "arrow") {
+		const currentCenter = {
+			x: item.position.x + box.x + box.width / 2,
+			y: item.position.y + box.y + box.height / 2
+		};
+		const dx = center.x - currentCenter.x;
+		const dy = center.y - currentCenter.y;
+		if (Math.abs(dx) < EPSILON && Math.abs(dy) < EPSILON) return item;
+		return {
+			...item,
+			position: {
+				x: item.position.x + dx,
+				y: item.position.y + dy
+			}
+		};
+	}
+	let next = item;
+	let nextBox = box;
+	if (Math.abs(width - box.width) > EPSILON || Math.abs(height - box.height) > EPSILON) {
+		if (item.type === "text") {
+			const factor = Math.abs(width - box.width) > EPSILON ? width / box.width : height / box.height;
+			const props = {
+				...item.props,
+				fontSize: clampBoardFontSize(item.props.fontSize * factor),
+				...item.props.width ? { width: item.props.width * factor } : {}
+			};
+			next = {
+				...item,
+				props
+			};
+			const text = layoutBoardText(props);
+			nextBox = {
+				x: 0,
+				y: 0,
+				width: text.width,
+				height: text.height
+			};
+		} else if (item.type === "draw") {
+			const sx = width / box.width;
+			const sy = height / box.height;
+			const points = item.props.points.map((point) => ({
+				...point,
+				x: box.x + (point.x - box.x) * sx,
+				y: box.y + (point.y - box.y) * sy
+			}));
+			next = {
+				...item,
+				props: {
+					...item.props,
+					points
+				}
+			};
+			nextBox = drawPointsBounds(points, item.style.strokeWidth ?? 4);
+		} else if ("size" in item && item.size) {
+			next = {
+				...item,
+				size: {
+					width,
+					height
+				}
+			};
+			nextBox = {
+				x: 0,
+				y: 0,
+				width,
+				height
+			};
+		}
+	}
+	const rotation = frame.rotation - parentRotation;
+	const radians = rotation * Math.PI / 180;
+	const origin = {
+		x: nextBox.x + item.origin.x * nextBox.width,
+		y: nextBox.y + item.origin.y * nextBox.height
+	};
+	const boxCenter = {
+		x: nextBox.x + nextBox.width / 2,
+		y: nextBox.y + nextBox.height / 2
+	};
+	const dx = (boxCenter.x - origin.x) * scale.x;
+	const dy = (boxCenter.y - origin.y) * scale.y;
+	const rotated = {
+		x: dx * Math.cos(radians) - dy * Math.sin(radians),
+		y: dx * Math.sin(radians) + dy * Math.cos(radians)
+	};
+	const position = {
+		x: center.x - origin.x - rotated.x,
+		y: center.y - origin.y - rotated.y
+	};
+	return {
+		...next,
+		position,
+		rotation: normalizeDegrees(rotation)
+	};
+}
+function normalizeDegrees(value) {
+	const normalized = (value % 360 + 540) % 360 - 180;
+	return Math.abs(normalized) < EPSILON ? 0 : Number(normalized.toFixed(6));
+}
+function sceneItemsToRecord(items, layout) {
+	const record = {};
+	for (const scene of items) record[scene.id] = sceneItemToItem(scene, layout);
+	return record;
+}
+//#endregion
+export { buildBoardScene, orderBoardItems, placeItem, refreshBoardScene, sceneItemToItem, sceneItemsToRecord, toSceneItem };

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

@@ -1,35 +1,23 @@
-import { BoardFrame, BoardItem } from "../../protocol/dist/board-document.js";
 import { Rect, WorldPoint } from "../geometry.js";
+import { BoardSceneItem } from "./scene.js";
 import { ShapeCapabilities, ShapeGeometry, ShapeHandle, ShapeResizeMode } from "./shape-types.js";
 //#region src/board/core/shape-definition.d.ts
 type ShapeDefinition = {
-  /** The item type this definition handles. */
   type: string;
   capabilities: ShapeCapabilities;
-  /** Rotation-aware world bounds (culling, marquee). Defaults to itemBounds. */
-  getBounds?: (item: BoardItem) => Rect;
-  /** Exact world-space containment (hit testing). Defaults to rotated rect. */
-  hitTest?: (item: BoardItem, point: WorldPoint) => boolean;
-  /** Interaction handles in the shape's local space. Defaults to none. */
-  getHandles?: (item: BoardItem) => ShapeHandle[];
-  /**
-   * Local-space geometry outline, used for precise hit tests and snapping.
-   * Optional; box shapes rely on the frame directly.
-   */
-  getGeometry?: (item: BoardItem) => ShapeGeometry;
+  getBounds?: (item: BoardSceneItem) => Rect;
+  hitTest?: (item: BoardSceneItem, point: WorldPoint) => boolean;
+  getHandles?: (item: BoardSceneItem) => ShapeHandle[];
+  getGeometry?: (item: BoardSceneItem) => ShapeGeometry;
 };
 declare function registerShapeDefinition(definition: ShapeDefinition): void;
 declare function getShapeDefinition(type: string): ShapeDefinition | undefined;
-/**
- * The generic fallback for unknown shape types: a plain movable/resizable box.
- * This guarantees a shape authored by a newer client is still interactive here.
- */
 declare const unknownShapeDefinition: ShapeDefinition;
-declare function definitionForItem(item: BoardItem): ShapeDefinition;
-declare function shapeBounds(item: BoardItem): Rect;
-declare function shapeHitTest(item: BoardItem, point: WorldPoint): boolean;
-declare function shapeHandles(item: BoardItem): ShapeHandle[];
-declare function shapeCapabilities(item: BoardItem): ShapeCapabilities;
-declare function shapeResizeMode(item: BoardItem): ShapeResizeMode;
+declare function definitionForItem(item: BoardSceneItem): ShapeDefinition;
+declare function shapeBounds(item: BoardSceneItem): Rect;
+declare function shapeHitTest(item: BoardSceneItem, point: WorldPoint): boolean;
+declare function shapeHandles(item: BoardSceneItem): ShapeHandle[];
+declare function shapeCapabilities(item: BoardSceneItem): ShapeCapabilities;
+declare function shapeResizeMode(item: BoardSceneItem): ShapeResizeMode;
 //#endregion
-export { type BoardFrame, ShapeDefinition, definitionForItem, getShapeDefinition, registerShapeDefinition, shapeBounds, shapeCapabilities, shapeHandles, shapeHitTest, shapeResizeMode, unknownShapeDefinition };
+export { ShapeDefinition, definitionForItem, getShapeDefinition, registerShapeDefinition, shapeBounds, shapeCapabilities, shapeHandles, shapeHitTest, shapeResizeMode, unknownShapeDefinition };

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

@@ -1,20 +1,6 @@
-import { isUnknownItem } from "../../protocol/dist/board-document.js";
 import { frameContainsPoint, itemBounds } from "../geometry.js";
 import { resizeModeForCapabilities } from "./shape-types.js";
 //#region src/board/core/shape-definition.ts
-/**
-* ShapeDefinition protocol + registry.
-*
-* A ShapeDefinition describes everything the editor needs to *behave* correctly
-* around a shape — bounds, hit testing, handles, capabilities, snap targets —
-* with no knowledge of how the shape is drawn. The Pixi renderers are a separate
-* concern (board-renderer-registry). This separation is what lets us add a shape
-* by writing one definition + one renderer, and keeps geometry fully unit-testable
-* without a GPU.
-*
-* Definitions are looked up by `item.type`. Unknown types fall back to a generic
-* box definition so unrecognised shapes still select, move and resize.
-*/
 const definitions = /* @__PURE__ */ new Map();
 function registerShapeDefinition(definition) {
 	definitions.set(definition.type, definition);
@@ -22,10 +8,6 @@ function registerShapeDefinition(definition) {
 function getShapeDefinition(type) {
 	return definitions.get(type);
 }
-/**
-* The generic fallback for unknown shape types: a plain movable/resizable box.
-* This guarantees a shape authored by a newer client is still interactive here.
-*/
 const unknownShapeDefinition = {
 	type: "__unknown__",
 	capabilities: {
@@ -40,7 +22,6 @@ const unknownShapeDefinition = {
 	}
 };
 function definitionForItem(item) {
-	if (isUnknownItem(item)) return unknownShapeDefinition;
 	return definitions.get(item.type) ?? unknownShapeDefinition;
 }
 function shapeBounds(item) {

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

@@ -1,152 +1,38 @@
-import { BoardGeoKind } from "../../protocol/dist/board-node.js";
-import { BoardFrame } from "../../protocol/dist/board-document.js";
+import { BoardShapeGeometry } from "../../protocol/dist/board-model.js";
+import { BoardFrame } from "../../protocol/dist/board-layout.js";
 import "../../protocol/dist/index.js";
 import { Rect, WorldPoint } from "../geometry.js";
 //#region src/board/core/shape-types.d.ts
-/**
- * A shape's geometry, expressed in the shape's local space (origin at the
- * frame's top-left, unrotated). Hit testing and handles are derived from this,
- * so a shape only declares its outline once.
- */
 type ShapeGeometry = {
-  /** Axis-aligned bounds in local space (usually the full frame). */
   bounds: Rect;
-  /**
-   * Exact point containment test in *world* space. Receives the shape frame so
-   * it can account for rotation. Defaults to the rotated-rect test when absent.
-   */
   containsWorldPoint?: (frame: BoardFrame, point: WorldPoint) => boolean;
 };
 type ShapeHandleId = string;
 type ShapeHandle = {
   id: ShapeHandleId;
-  /** Position in the shape's local (unrotated, frame-origin) space. */
   x: number;
   y: number;
-  /** Visual + hit radius hint in screen px; the stage scales by zoom. */
   radius?: number;
 };
-/** Result of dragging a handle: a patched frame and/or shape props. */
 type HandleDragResult = {
   frame?: BoardFrame;
   props?: Record<string, unknown>;
 };
-/**
- * What a shape supports. The editor, selection toolbar and tools read these so
- * behaviour is data-driven: adding a shape never requires editing the editor.
- */
 type ShapeCapabilities = {
-  /** Can be moved by dragging. */
   canMove: boolean;
-  /** Shows resize handles. */
   canResize: boolean;
-  /**
-   * Resize always preserves the shape's aspect ratio, regardless of Shift.
-   * True for shapes whose content has a single intrinsic scale (text font size,
-   * media pixels, stroke geometry) — distorting the frame would either letterbox
-   * the content or have no representation in the data model.
-   */
   aspectLocked: boolean;
-  /** Shows the rotation handle. */
   canRotate: boolean;
-  /** Supports double-click inline editing. */
   canEdit: 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. */
   canLock: boolean;
 };
-/**
- * Effective resize behaviour derived from the backwards-compatible capability
- * flags. Consumers should use this mode instead of repeating the flag matrix.
- */
 type ShapeResizeMode = "none" | "uniform" | "free";
 declare function resizeModeForCapabilities(capabilities: ShapeCapabilities): ShapeResizeMode;
 declare const FULL_CAPABILITIES: ShapeCapabilities;
-/**
- * A single raw input sample of a freehand stroke. We persist the *raw* samples
- * (not just a simplified path) so strokes can be re-smoothed, re-simplified or
- * re-rendered at any LOD later without losing information — data first.
- */
-type DrawPoint = {
-  x: number;
-  y: number;
-  /** Pen pressure 0..1; 0.5 when unavailable (mouse). */
-  p: number;
-};
-type DrawShapeProps = {
-  /** Raw samples in the shape's local space. */
-  points: DrawPoint[];
-  color: string;
-  /** Stroke width in world units. */
-  size: number;
-};
-type GeoKind = BoardGeoKind;
-declare const GEO_KINDS: readonly GeoKind[];
-declare function isGeoKind(value: unknown): value is GeoKind;
-type GeoShapeProps = {
-  geo: GeoKind;
-  /** Optional label rendered centered inside the shape. */
-  text: string;
-  color: string;
-  /** Fill opacity 0..1 (0 = outline only). */
-  fillOpacity: number;
-};
-/**
- * An arrow endpoint: either a free point (local space) or a binding to another
- * shape. Bindings use a normalized anchor (0..1 of the target's frame) so the
- * arrow tracks the target through move/resize without storing absolute coords.
- */
-type ArrowEndpoint = {
-  kind: "point";
-  x: number;
-  y: number;
-} | {
-  kind: "binding";
-  /** Target shape id. */
-  target: string;
-  /** Normalized anchor on the target frame (0..1). */
-  nx: number;
-  ny: number;
-  /** Whether the binding snaps to the nearest edge/center. */
-  precise: boolean;
-};
-type ArrowShapeProps = {
-  start: ArrowEndpoint;
-  end: ArrowEndpoint;
-  /** Bend of a curved arrow, as a fraction of the length (-0.5..0.5). */
-  bend: number;
-  color: string;
-  size: number;
-  /** Arrowhead placement. */
-  arrowStart: boolean;
-  arrowEnd: boolean;
-  label: string;
-};
-type TextShapeProps = {
-  text: string;
-  color: string;
-  fontSize: number;
-};
-type ImageShapeProps = {
-  path: string;
-  mimeType?: string;
-};
-type VideoShapeProps = {
-  path: string;
-  mimeType?: string;
-};
-type AudioShapeProps = {
-  path: string;
-  mimeType?: string;
-};
+type ShapeKind = Exclude<BoardShapeGeometry, "path">;
+declare const SHAPE_KINDS: ShapeKind[];
+declare function isShapeKind(value: unknown): value is ShapeKind;
 //#endregion
-export { ArrowEndpoint, ArrowShapeProps, AudioShapeProps, DrawPoint, DrawShapeProps, FULL_CAPABILITIES, GEO_KINDS, GeoKind, GeoShapeProps, HandleDragResult, ImageShapeProps, ShapeCapabilities, ShapeGeometry, ShapeHandle, ShapeHandleId, ShapeResizeMode, TextShapeProps, VideoShapeProps, isGeoKind, resizeModeForCapabilities };
+export { FULL_CAPABILITIES, HandleDragResult, SHAPE_KINDS, ShapeCapabilities, ShapeGeometry, ShapeHandle, ShapeHandleId, ShapeKind, ShapeResizeMode, isShapeKind, resizeModeForCapabilities };

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

@@ -1,4 +1,4 @@
-import { BOARD_GEO_KINDS } from "../../protocol/dist/board-node.js";
+import { BOARD_SHAPE_GEOMETRIES } from "../../protocol/dist/board-model.js";
 //#region src/board/core/shape-types.ts
 function resizeModeForCapabilities(capabilities) {
 	if (!capabilities.canResize) return "none";
@@ -14,9 +14,9 @@ const FULL_CAPABILITIES = {
 	canSnap: true,
 	canLock: true
 };
-const GEO_KINDS = BOARD_GEO_KINDS;
-function isGeoKind(value) {
-	return typeof value === "string" && GEO_KINDS.includes(value);
+const SHAPE_KINDS = BOARD_SHAPE_GEOMETRIES.filter((kind) => kind !== "path");
+function isShapeKind(value) {
+	return typeof value === "string" && SHAPE_KINDS.includes(value);
 }
 //#endregion
-export { FULL_CAPABILITIES, GEO_KINDS, isGeoKind, resizeModeForCapabilities };
+export { FULL_CAPABILITIES, SHAPE_KINDS, isShapeKind, resizeModeForCapabilities };

package/dist/board/core/text-metrics.d.ts

@@ -1,18 +1,15 @@
+import { clampBoardFontSize } from "../../protocol/dist/board-layout.js";
+import "../../protocol/dist/index.js";
 //#region src/board/core/text-metrics.d.ts
 declare const TEXT_FONT_FAMILY = "Geist";
 declare const TEXT_FONT_SIZE = 24;
 declare const TEXT_LINE_HEIGHT = 32;
 declare const TEXT_MIN_FONT_SIZE = 2;
 declare const TEXT_MAX_FONT_SIZE = 512;
-type BoardTextMeasurer = (text: string, fontSize: number) => number | null;
-/** Install the renderer's text measurer, or clear it for environment-free fallback metrics. */
-declare function setBoardTextMeasurer(measurer?: BoardTextMeasurer): void;
-declare function clampBoardTextFontSize(fontSize: number): number;
-declare function boardTextLineHeight(fontSize: number): number;
-/** Measure unwrapped plain text into scalable world-space bounds. */
-declare function measureBoardText(text: string, fontSize?: number): {
-  width: number;
-  height: number;
-};
+declare function boardFontFamily(font: string, stacks: {
+  sans: string;
+  serif: string;
+  mono: string;
+}): string;
 //#endregion
-export { TEXT_FONT_FAMILY, TEXT_FONT_SIZE, TEXT_LINE_HEIGHT, TEXT_MAX_FONT_SIZE, TEXT_MIN_FONT_SIZE, boardTextLineHeight, clampBoardTextFontSize, measureBoardText, setBoardTextMeasurer };
+export { TEXT_FONT_FAMILY, TEXT_FONT_SIZE, TEXT_LINE_HEIGHT, TEXT_MAX_FONT_SIZE, TEXT_MIN_FONT_SIZE, boardFontFamily, clampBoardFontSize as clampBoardTextFontSize };