@neta-art/cohub 3.1.0 → 3.2.0

package/README.md

@@ -118,18 +118,49 @@ const stop = board.subscribe({
 stop();
 ```
 
-Import timeline compilation and extension registry helpers from the lightweight
-Board entry point:
+Board is split by dependency: the model runs anywhere, drawing needs PixiJS.
+`@neta-art/cohub/board` carries the document schema, geometry, the shape layer,
+timeline compilation and export planning, with no renderer and no PixiJS — so
+agents, servers and edge workers can read, write and measure boards without a
+graphics stack:
 
 ```ts
 import {
+  BoardDocumentSchema,
   clip,
   compileSequence,
   createBoardExtensionRegistry,
+  itemBounds,
+  planBoardExport,
   timeline,
 } from "@neta-art/cohub/board";
 ```
 
+Drawing pixels is where PixiJS enters. The card renderers and themes the editor
+uses live behind `@neta-art/cohub/board/render`, and turning a plan into an
+image has dedicated browser and Node.js entries:
+
+```ts
+import { getBoardCardRenderer } from "@neta-art/cohub/board/render";
+import { renderBoardExport } from "@neta-art/cohub/board/export";
+import {
+  createBoardHeadlessRenderer,
+  exportBoardImageBytes,
+} from "@neta-art/cohub/board/headless";
+```
+
+Install `pixi.js` to use `board/render` or `board/export`, and add
+`@napi-rs/canvas` as well for `board/headless`. Both are optional peers, and
+`@neta-art/cohub/board` never reaches for either, so HTTP-only installations
+stay lightweight.
+
+Text metrics follow the same split. The renderers measure through a real canvas
+and set that up themselves, so nothing extra is needed to draw or export. Called
+straight off `@neta-art/cohub/board` with no renderer in play,
+`measureBoardText` returns a per-character estimate instead — fine for laying
+out a board on a server, but call `installBoardTextMeasurement` from
+`board/render` first if the numbers have to match what the editor draws.
+
 ## Session subscriptions
 
 ```ts

package/dist/{board.d.ts → board/animation.d.ts}

@@ -1,5 +1,7 @@
-import { F as BoardCapability, I as BoardRenderCost, c as BoardEffect, i as BoardClip, s as BoardDiagnostic, t as BoardAssetRef, v as BoardSequence, x as BoardValidationResult, y as BoardTarget } from "./chunks/board.js";
-//#region src/board.d.ts
+import { BoardCapability, BoardRenderCost } from "../protocol/dist/board-constants.js";
+import { BoardAssetRef, BoardClip, BoardDiagnostic, BoardEffect, BoardSequence, BoardTarget, BoardValidationResult } from "../protocol/dist/board.js";
+import "../protocol/dist/index.js";
+//#region src/board/animation.d.ts
 type TimelineClipInput = Omit<BoardClip, "id" | "sequenceId" | "start" | "seed"> & {
   id?: string;
   seed?: string;

package/dist/{chunks/board.js → board/animation.js}

@@ -1,44 +1,5 @@
-//#region ../protocol/dist/board-constants.js
-const DEFAULT_BOARD_RENDER_LIMITS = {
-	particles: 2e4,
-	vertices: 5e5,
-	dynamicVertices: 15e4,
-	drawCalls: 400,
-	filterPasses: 24,
-	renderTexturePixels: 16777216,
-	textureBytes: 512 * 1024 * 1024,
-	bufferBytes: 256 * 1024 * 1024,
-	simulationSteps: 1e5
-};
-const BOARD_BUILTIN_CLIP_KINDS = [
-	"motion.keyframes",
-	"motion.path",
-	"draw.reveal",
-	"draw.handwrite",
-	"text.reveal",
-	"effects.particles",
-	"effects.trail",
-	"effects.impact",
-	"effects.flash",
-	"effects.color",
-	"camera.pan",
-	"camera.zoom",
-	"camera.shake"
-];
-const BOARD_BUILTIN_EFFECT_KINDS = ["effects.pulse", "effects.float"];
-const BOARD_BUILTIN_CAPABILITIES = [...BOARD_BUILTIN_CLIP_KINDS.map((id) => ({
-	kind: "clip",
-	id,
-	version: 1,
-	renderers: ["webgpu", "webgl"]
-})), ...BOARD_BUILTIN_EFFECT_KINDS.map((id) => ({
-	kind: "effect",
-	id,
-	version: 1,
-	renderers: ["webgpu", "webgl"]
-}))];
-//#endregion
-//#region src/board.ts
+import { BOARD_BUILTIN_CAPABILITIES, DEFAULT_BOARD_RENDER_LIMITS } from "../protocol/dist/board-constants.js";
+//#region src/board/animation.ts
 const ZERO_COST = {
 	particles: 0,
 	vertices: 0,
@@ -266,9 +227,9 @@ function flatten(input, offset, sequenceSeed, path) {
 	}
 	const clips = [];
 	let duration = 0;
-	for (let index = 0; index < input.children.length; index += 1) {
+	for (const [index, child] of input.children.entries()) {
 		const childOffset = input.type === "sequence" ? duration : input.type === "stagger" ? input.each * index : 0;
-		const nested = flatten(input.children[index], offset + childOffset, sequenceSeed, `${path}.${index}`);
+		const nested = flatten(child, offset + childOffset, sequenceSeed, `${path}.${index}`);
 		clips.push(...nested.clips);
 		duration = input.type === "sequence" ? duration + nested.duration : Math.max(duration, childOffset + nested.duration);
 	}
@@ -389,4 +350,4 @@ function createBoardExtensionRegistry(input = {}) {
 	return registry;
 }
 //#endregion
-export { createBoardExtensionRegistry as a, compileSequence as i, DEFAULT_BOARD_LIMITS as n, timeline as o, clip as r, BoardExtensionRegistry as t };
+export { BoardExtensionRegistry, DEFAULT_BOARD_LIMITS, clip, compileSequence, createBoardExtensionRegistry, timeline };

package/dist/board/codec.d.ts

@@ -0,0 +1,25 @@
+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";
+//#region src/board/codec.d.ts
+declare const DEFAULT_BOARD_APPEARANCE: BoardAppearance;
+declare const ITEM_BASE_KEYS: readonly ["id", "type", "frame", "locked", "style", "metadata"];
+/**
+ * Original wire data follows an item through immutable object spreads while
+ * remaining invisible to JSON serialization. Codecs can then patch only the
+ * fields this client understands instead of rebuilding and truncating a node.
+ */
+declare const BOARD_NODE_SOURCE: unique symbol;
+type WireBackedBoardItem = BoardItem & {
+  [BOARD_NODE_SOURCE]?: BoardNodeInput;
+};
+declare function nodeInputFromRecord(node: BoardNodeRecord): BoardNodeInput;
+declare function sourceForItem(item: BoardItem): BoardNodeInput | undefined;
+declare function isRecord(value: unknown): value is Record<string, unknown>;
+declare function boardNodeToItem(node: BoardNodeRecord): BoardItem;
+declare function boardBootstrapToDocument(input: {
+  board: BoardRecord;
+  nodes: BoardNodeRecord[];
+}): 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

@@ -0,0 +1,252 @@
+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 { TEXT_FONT_SIZE, clampBoardTextFontSize } from "./core/text-metrics.js";
+import "../protocol/dist/index.js";
+//#region src/board/codec.ts
+const DEFAULT_BOARD_APPEARANCE = BoardAppearanceSchema.parse({
+	theme: "clean",
+	background: { kind: "solid" },
+	grid: {
+		visible: false,
+		size: 24,
+		opacity: .12
+	},
+	mood: "clean"
+});
+const ITEM_BASE_KEYS = [
+	"id",
+	"type",
+	"frame",
+	"locked",
+	"style",
+	"metadata"
+];
+/**
+* Original wire data follows an item through immutable object spreads while
+* remaining invisible to JSON serialization. Codecs can then patch only the
+* fields this client understands instead of rebuilding and truncating a node.
+*/
+const BOARD_NODE_SOURCE = Symbol("board-node-source");
+function nodeInputFromRecord(node) {
+	return {
+		nodeId: node.nodeId,
+		type: node.type,
+		parentId: node.parentId ?? null,
+		orderKey: node.orderKey ?? null,
+		x: node.x,
+		y: node.y,
+		width: node.width,
+		height: node.height,
+		rotation: node.rotation,
+		refKind: node.refKind ?? null,
+		refPath: node.refPath ?? null,
+		refUrl: node.refUrl ?? null,
+		view: node.view ?? {},
+		style: node.style ?? {},
+		data: node.data ?? {}
+	};
+}
+function sourceForItem(item) {
+	return item[BOARD_NODE_SOURCE];
+}
+function isRecord(value) {
+	return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function frameFromNode(node) {
+	return {
+		x: node.x,
+		y: node.y,
+		width: node.width,
+		height: node.height,
+		rotation: node.rotation
+	};
+}
+function lockedFromData(data) {
+	return data.locked === true ? true : void 0;
+}
+function styleFromNode(node) {
+	return Object.keys(node.style ?? {}).length ? node.style : void 0;
+}
+function spaceFilePathFromNode(node) {
+	if (node.refKind === "space_file" && node.refPath) return node.refPath;
+	if (typeof node.refPath === "string" && node.refPath) return node.refPath;
+	return null;
+}
+function boardNodeToItemValue(node) {
+	const frame = frameFromNode(node);
+	const style = styleFromNode(node);
+	const data = node.data ?? {};
+	const locked = lockedFromData(data);
+	switch (node.type) {
+		case "text": return {
+			id: node.nodeId,
+			type: "text",
+			text: typeof data.text === "string" ? data.text : "",
+			color: typeof data.color === "string" ? data.color : "neutral",
+			fontSize: clampBoardTextFontSize(typeof data.fontSize === "number" ? data.fontSize : TEXT_FONT_SIZE),
+			frame,
+			...locked ? { locked } : {},
+			style
+		};
+		case "note": return {
+			id: node.nodeId,
+			type: "note",
+			text: typeof data.text === "string" ? data.text : "",
+			color: typeof data.color === "string" ? data.color : "amber",
+			frame,
+			...locked ? { locked } : {},
+			style
+		};
+		case "geo": return {
+			id: node.nodeId,
+			type: "geo",
+			geo: typeof data.geo === "string" ? data.geo : "rectangle",
+			text: typeof data.text === "string" ? data.text : "",
+			color: typeof data.color === "string" ? data.color : "brand",
+			fillOpacity: typeof data.fillOpacity === "number" ? data.fillOpacity : 0,
+			frame,
+			...locked ? { locked } : {},
+			style
+		};
+		case "draw": return {
+			id: node.nodeId,
+			type: "draw",
+			points: Array.isArray(data.points) ? data.points : [],
+			color: typeof data.color === "string" ? data.color : "brand",
+			size: typeof data.size === "number" ? data.size : 4,
+			frame,
+			...locked ? { locked } : {},
+			style
+		};
+		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
+			},
+			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,
+			arrowStart: Boolean(data.arrowStart),
+			arrowEnd: data.arrowEnd === void 0 ? true : Boolean(data.arrowEnd),
+			label: typeof data.label === "string" ? data.label : "",
+			frame,
+			...locked ? { locked } : {},
+			style
+		};
+		case "frame": return {
+			id: node.nodeId,
+			type: "frame",
+			label: typeof data.label === "string" ? data.label : "Frame",
+			color: typeof data.color === "string" ? data.color : "neutral",
+			frame,
+			...locked ? { locked } : {},
+			style
+		};
+		case "image": {
+			const path = spaceFilePathFromNode(node) ?? "missing";
+			return {
+				id: node.nodeId,
+				type: "image",
+				ref: {
+					kind: "space-file",
+					path
+				},
+				snapshot: node.view,
+				...data.crop && typeof data.crop === "object" ? { crop: data.crop } : {},
+				frame,
+				...locked ? { locked } : {},
+				style
+			};
+		}
+		case "video": {
+			const path = spaceFilePathFromNode(node) ?? "missing";
+			return {
+				id: node.nodeId,
+				type: "video",
+				ref: {
+					kind: "space-file",
+					path
+				},
+				snapshot: node.view,
+				frame,
+				...locked ? { locked } : {},
+				style
+			};
+		}
+		case "file": {
+			const path = spaceFilePathFromNode(node) ?? "missing";
+			const parsed = BoardFileSnapshotSchema.safeParse(node.view ?? {});
+			return {
+				id: node.nodeId,
+				type: "file",
+				ref: {
+					kind: "space-file",
+					path
+				},
+				...parsed.success ? { snapshot: parsed.data } : {},
+				frame,
+				...locked ? { locked } : {},
+				style
+			};
+		}
+		default: {
+			const raw = {
+				...data,
+				id: node.nodeId,
+				type: node.type,
+				frame
+			};
+			if (style) raw.style = style;
+			if (locked) raw.locked = true;
+			return {
+				id: node.nodeId,
+				type: UNKNOWN_BOARD_ITEM_TYPE,
+				frame,
+				...locked ? { locked } : {},
+				style,
+				raw
+			};
+		}
+	}
+}
+function boardNodeToItem(node) {
+	const item = boardNodeToItemValue(node);
+	const metadata = isRecord(node.data?.metadata) ? node.data.metadata : void 0;
+	return {
+		...item,
+		...metadata ? { metadata } : {},
+		[BOARD_NODE_SOURCE]: nodeInputFromRecord(node)
+	};
+}
+function boardBootstrapToDocument(input) {
+	const appearance = BoardAppearanceSchema.safeParse(input.board.metadata.appearance);
+	const document = BoardDocumentSchema.parse({
+		kind: BOARD_DOCUMENT_KIND,
+		version: 1,
+		appearance: appearance.success ? appearance.data : DEFAULT_BOARD_APPEARANCE,
+		viewport: {
+			x: 0,
+			y: 0,
+			zoom: 1
+		},
+		items: input.nodes.map(boardNodeToItem)
+	});
+	const sources = new Map(input.nodes.map((node) => [node.nodeId, nodeInputFromRecord(node)]));
+	return {
+		...document,
+		items: document.items.map((item) => ({
+			...item,
+			[BOARD_NODE_SOURCE]: sources.get(item.id)
+		}))
+	};
+}
+//#endregion
+export { BOARD_NODE_SOURCE, DEFAULT_BOARD_APPEARANCE, ITEM_BASE_KEYS, InvalidBoardFileError, boardBootstrapToDocument, boardNodeToItem, isBoardPath, isRecord, nodeInputFromRecord, parseBoardManifest, serializeBoardManifest, sourceForItem };

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

@@ -0,0 +1,45 @@
+import { ArrowEndpoint, BoardArrowItem, BoardFrame } from "../../protocol/dist/board-document.js";
+import { Rect, WorldPoint } from "../geometry.js";
+//#region src/board/core/bindings.d.ts
+type FrameLookup = (id: string) => BoardFrame | undefined;
+/** Denormalize a binding anchor to a world point on the (rotated) frame. */
+declare function anchorToWorld(frame: BoardFrame, nx: number, ny: number): WorldPoint;
+/** Normalize a world point to a binding anchor on the (rotated) frame, clamped. */
+declare function worldToAnchor(frame: BoardFrame, point: WorldPoint): {
+  nx: number;
+  ny: number;
+};
+/** Resolve an endpoint to a world point, or null if a binding target is gone. */
+declare function resolveEndpoint(endpoint: ArrowEndpoint, getFrame: FrameLookup): WorldPoint | null;
+type ResolvedArrow = {
+  start: WorldPoint;
+  end: WorldPoint;
+  /** Quadratic control point (already bent); equals midpoint when bend is 0. */
+  control: WorldPoint;
+};
+/** Resolve both endpoints and compute the bent control point. */
+declare function resolveArrow(item: BoardArrowItem, getFrame: FrameLookup): ResolvedArrow | null;
+/** World-space bounds of an arrow, sampling the curve for accuracy. */
+declare function arrowBounds(item: BoardArrowItem, getFrame: FrameLookup): Rect | null;
+/** Sample the arrow's quadratic curve into world points (for render/hit-test). */
+declare function sampleQuadratic(resolved: ResolvedArrow, segments: number): WorldPoint[];
+/** Distance from a world point to the arrow curve (hit testing). */
+declare function distanceToArrow(item: BoardArrowItem, getFrame: FrameLookup, point: WorldPoint): number;
+/**
+ * Turn a free endpoint into a binding if a candidate target frame contains the
+ * point; otherwise keep it free. Used while dragging an arrow handle so the
+ * arrow "connects" to shapes it lands on.
+ */
+declare function bindEndpointAt(point: WorldPoint, target: {
+  id: string;
+  frame: BoardFrame;
+} | null): ArrowEndpoint;
+/**
+ * Translate an arrow by a delta: free endpoints move; bindings stay attached to
+ * their targets (so a bound end anchors while the rest of the arrow moves). The
+ * frame — a derived bounding box, not a transform — is recomputed from the new
+ * endpoint geometry.
+ */
+declare function translateArrow(item: BoardArrowItem, dx: number, dy: number, getFrame: FrameLookup): BoardArrowItem;
+//#endregion
+export { FrameLookup, ResolvedArrow, anchorToWorld, arrowBounds, bindEndpointAt, distanceToArrow, resolveArrow, resolveEndpoint, sampleQuadratic, translateArrow, worldToAnchor };

package/dist/board/core/bindings.js

@@ -0,0 +1,162 @@
+import { degToRad, rectCenter, rotatePointAround, worldPoint } from "../geometry.js";
+//#region src/board/core/bindings.ts
+/**
+* Arrow bindings — pure geometry for connecting arrows to shapes.
+*
+* An arrow endpoint is either a free world point or a *binding*: a normalized
+* anchor (0..1) on a target shape's frame. Because the anchor is relative, the
+* arrow tracks the target through move and resize with no stored absolute
+* coordinates — the binding never goes stale. Resolution to world space happens
+* here, given a frame lookup, so it is fully testable and renderer-independent.
+*/
+/** Denormalize a binding anchor to a world point on the (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(frame), degToRad(frame.rotation));
+}
+/** Normalize a world point to a binding anchor on the (rotated) frame, clamped. */
+function worldToAnchor(frame, point) {
+	let local = point;
+	if (frame.rotation) local = rotatePointAround(point, rectCenter(frame), -degToRad(frame.rotation));
+	return {
+		nx: clamp01((local.x - frame.x) / frame.width),
+		ny: clamp01((local.y - frame.y) / frame.height)
+	};
+}
+function clamp01(value) {
+	return Math.min(1, Math.max(0, value));
+}
+/** Resolve an endpoint to a world point, or null if a binding target is gone. */
+function resolveEndpoint(endpoint, getFrame) {
+	if (endpoint.kind === "point") return worldPoint(endpoint.x, endpoint.y);
+	const frame = getFrame(endpoint.target);
+	if (!frame) return null;
+	return anchorToWorld(frame, endpoint.nx, endpoint.ny);
+}
+/** Resolve both endpoints and compute the bent control point. */
+function resolveArrow(item, getFrame) {
+	const start = resolveEndpoint(item.start, getFrame);
+	const end = resolveEndpoint(item.end, getFrame);
+	if (!start || !end) return null;
+	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)
+	};
+}
+/** World-space bounds of an arrow, sampling the curve for accuracy. */
+function arrowBounds(item, getFrame) {
+	const resolved = resolveArrow(item, getFrame);
+	if (!resolved) return null;
+	const samples = sampleQuadratic(resolved, 12);
+	let minX = Number.POSITIVE_INFINITY;
+	let minY = Number.POSITIVE_INFINITY;
+	let maxX = Number.NEGATIVE_INFINITY;
+	let maxY = Number.NEGATIVE_INFINITY;
+	for (const p of samples) {
+		minX = Math.min(minX, p.x);
+		minY = Math.min(minY, p.y);
+		maxX = Math.max(maxX, p.x);
+		maxY = Math.max(maxY, p.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)
+	};
+}
+/** Sample the arrow's quadratic curve into world points (for render/hit-test). */
+function sampleQuadratic(resolved, segments) {
+	const { start, control, end } = resolved;
+	const out = [];
+	for (let i = 0; i <= segments; i += 1) {
+		const t = i / 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;
+}
+/** Distance from a world point to the arrow curve (hit testing). */
+function distanceToArrow(item, getFrame, point) {
+	const resolved = resolveArrow(item, getFrame);
+	if (!resolved) return Number.POSITIVE_INFINITY;
+	const samples = sampleQuadratic(resolved, 16);
+	let min = Number.POSITIVE_INFINITY;
+	for (let i = 0; i < samples.length - 1; i += 1) {
+		const from = samples[i];
+		const to = samples[i + 1];
+		if (!from || !to) continue;
+		const d = segmentDistance(point, from, to);
+		if (d < min) min = d;
+	}
+	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));
+}
+/**
+* Turn a free endpoint into a binding if a candidate target frame contains the
+* point; otherwise keep it free. Used while dragging an arrow handle so the
+* arrow "connects" to shapes it lands on.
+*/
+function bindEndpointAt(point, target) {
+	if (!target) return {
+		kind: "point",
+		x: point.x,
+		y: point.y
+	};
+	const { nx, ny } = worldToAnchor(target.frame, point);
+	return {
+		kind: "binding",
+		target: target.id,
+		nx,
+		ny,
+		precise: true
+	};
+}
+/**
+* Translate an arrow by a delta: free endpoints move; bindings stay attached to
+* their targets (so a bound end anchors while the rest of the arrow moves). The
+* frame — a derived bounding box, not a transform — is recomputed from the new
+* endpoint geometry.
+*/
+function translateArrow(item, dx, dy, getFrame) {
+	const move = (endpoint) => endpoint.kind === "point" ? {
+		kind: "point",
+		x: endpoint.x + dx,
+		y: endpoint.y + dy
+	} : endpoint;
+	const next = {
+		...item,
+		start: move(item.start),
+		end: move(item.end)
+	};
+	const bounds = arrowBounds(next, getFrame);
+	return bounds ? {
+		...next,
+		frame: {
+			...bounds,
+			rotation: 0
+		}
+	} : next;
+}
+//#endregion
+export { anchorToWorld, arrowBounds, bindEndpointAt, distanceToArrow, resolveArrow, resolveEndpoint, sampleQuadratic, translateArrow, worldToAnchor };

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

@@ -0,0 +1,31 @@
+import { DrawPoint } from "../../protocol/dist/board-document.js";
+import { Rect, WorldPoint } from "../geometry.js";
+//#region src/board/core/draw-geometry.d.ts
+/** Radius of a sample in world units given the stroke size and pressure. */
+declare function sampleRadius(size: number, pressure: number): number;
+/** Axis-aligned bounds of a stroke in its local space, padded by stroke width. */
+declare function computeDrawBounds(points: DrawPoint[], size: number): Rect;
+/**
+ * Ramer–Douglas–Peucker simplification. Reduces point count for low-zoom
+ * rendering without touching the persisted raw samples. Returns indices into
+ * the input so callers can keep pressure alongside the simplified path.
+ */
+declare function simplifyDrawIndices(points: DrawPoint[], tolerance: number): number[];
+/**
+ * Build a closed outline polygon for a variable-width stroke. The left side is
+ * offset outward along each segment normal by the sample radius, the right side
+ * mirrored, producing a smooth ribbon that widens with pressure. Suitable for a
+ * filled Pixi polygon. Returns an empty array for degenerate input.
+ */
+declare function buildStrokeOutline(points: DrawPoint[], size: number): Array<{
+  x: number;
+  y: number;
+}>;
+/**
+ * Distance from a world point to the stroke's polyline, in the shape's local
+ * space. Used for hit testing: a hit registers within half the stroke width plus
+ * a small tolerance. `local` is the point expressed in the draw item's frame.
+ */
+declare function distanceToStroke(points: DrawPoint[], local: WorldPoint): number;
+//#endregion
+export { buildStrokeOutline, computeDrawBounds, distanceToStroke, sampleRadius, simplifyDrawIndices };