@neta-art/cohub 9.0.1 → 10.0.0

package/dist/board/model/items/builtin.js

@@ -0,0 +1,119 @@
+import { degToRad, frameContainsPoint, itemBounds, rectCenter, rectContainsPoint, rotatePointAround, worldPoint } from "../geometry.js";
+import { computeDrawBounds, distanceToStroke } from "../draw-geometry.js";
+import { defineBoardItem } from "./definition.js";
+//#region src/board/model/items/builtin.ts
+function frameLocalPoint(item, point) {
+	const center = rectCenter(item.frame);
+	const rotated = item.frame.rotation ? rotatePointAround(point, center, -degToRad(item.frame.rotation)) : point;
+	return worldPoint(rotated.x - item.frame.x, rotated.y - item.frame.y);
+}
+const textItem = defineBoardItem({
+	type: "text",
+	capabilities: {
+		canEdit: true,
+		aspectLocked: true
+	}
+});
+const imageItem = defineBoardItem({
+	type: "image",
+	capabilities: { aspectLocked: true }
+});
+const videoItem = defineBoardItem({
+	type: "video",
+	capabilities: {
+		canRotate: false,
+		aspectLocked: true
+	}
+});
+const audioItem = defineBoardItem({
+	type: "audio",
+	capabilities: { canRotate: false }
+});
+const fileItem = defineBoardItem({
+	type: "file",
+	capabilities: { canRotate: false }
+});
+const taskItem = defineBoardItem({
+	type: "task",
+	capabilities: {
+		canRotate: false,
+		aspectLocked: true
+	}
+});
+const effectItem = defineBoardItem({
+	type: "effect",
+	capabilities: {
+		canConnect: false,
+		canSnap: false
+	}
+});
+const sketchItem = defineBoardItem({ type: "sketch" });
+const frameItem = defineBoardItem({
+	type: "frame",
+	capabilities: {
+		canEdit: true,
+		canRotate: false,
+		canConnect: false
+	}
+});
+const arrowItem = defineBoardItem({
+	type: "arrow",
+	capabilities: {
+		canResize: false,
+		canRotate: false,
+		canEdit: true,
+		canConnect: false,
+		canSnap: false
+	}
+});
+function shapeContainsLocal(item, local) {
+	const w = item.frame.width;
+	const h = item.frame.height;
+	const nx = local.x / w * 2 - 1;
+	const ny = local.y / h * 2 - 1;
+	switch (item.props.geometry) {
+		case "ellipse": return nx * nx + ny * ny <= 1;
+		case "diamond": return Math.abs(nx) + Math.abs(ny) <= 1;
+		case "triangle": return ny >= -1 && ny <= 1 && Math.abs(nx) <= (ny + 1) / 2;
+		default: return local.x >= 0 && local.x <= w && local.y >= 0 && local.y <= h;
+	}
+}
+const builtinBoardItems = [
+	frameItem,
+	textItem,
+	defineBoardItem({
+		type: "shape",
+		capabilities: { canEdit: true },
+		hitTest: (item, point) => {
+			if (item.type !== "shape" || !frameContainsPoint(item.frame, point)) return false;
+			return shapeContainsLocal(item, frameLocalPoint(item, point));
+		}
+	}),
+	defineBoardItem({
+		type: "draw",
+		capabilities: {
+			aspectLocked: true,
+			canConnect: false
+		},
+		hitTest: (item, point) => {
+			if (item.type !== "draw" || !rectContainsPoint(itemBounds(item.frame), point, 8)) return false;
+			const draw = item;
+			const width = draw.style.strokeWidth ?? 4;
+			const box = computeDrawBounds(draw.props.points, width);
+			const scale = item.frame.width / Math.max(1e-4, box.width);
+			const local = frameLocalPoint(item, point);
+			const inPoints = worldPoint(box.x + local.x / scale, box.y + local.y / scale);
+			return distanceToStroke(draw.props.points, inPoints) <= Math.max(6, width) / Math.min(1, scale);
+		}
+	}),
+	arrowItem,
+	imageItem,
+	videoItem,
+	audioItem,
+	fileItem,
+	taskItem,
+	effectItem,
+	sketchItem
+];
+//#endregion
+export { builtinBoardItems };

package/dist/board/model/items/create.d.ts

@@ -0,0 +1,59 @@
+import { BoardItem, BoardMediaSnapshot, BoardTaskSnapshot } from "../../../protocol/dist/board-model.js";
+import "../../../protocol/dist/index.js";
+import { BoardFileSnapshotFacts } from "../file-snapshot.js";
+import { ShapeKind } from "../shape-types.js";
+//#region src/board/model/items/create.d.ts
+type BoardItemEntry = {
+  id: string;
+  item: BoardItem;
+};
+declare function mediaFrameSize(naturalWidth?: number | null, naturalHeight?: number | null, maxEdge?: number, fallback?: {
+  width: number;
+  height: number;
+}): {
+  width: number;
+  height: number;
+};
+declare function createFileNodeForPath(path: string, x: number, y: number, snapshot?: BoardMediaSnapshot & BoardFileSnapshotFacts, id?: string): BoardItemEntry;
+declare function createTaskBoardItem(taskRunId: string, snapshot: BoardTaskSnapshot, x: number, y: number, metadata?: Record<string, unknown>, id?: string): BoardItemEntry;
+declare function createTextBoardItem(text: string, x: number, y: number, color?: string, id?: string): BoardItemEntry;
+declare function createShapeBoardItem(geometry: ShapeKind, x: number, y: number, color?: string, id?: string, box?: {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}): BoardItemEntry;
+declare function createFrameBoardItem(x: number, y: number, color?: string, label?: string, id?: string, box?: {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}): BoardItemEntry;
+type BoardAppMetadata = {
+  appId: string;
+  ref: string;
+  url: string;
+  name: string;
+  icon?: string;
+};
+declare function createAppBoardItem(app: BoardAppMetadata, x: number, y: number, id?: string): BoardItemEntry;
+declare function createDrawBoardItem(worldPoints: Array<{
+  x: number;
+  y: number;
+  p: number;
+}>, color: string, size?: number, id?: string): BoardItemEntry;
+declare function createArrowBoardItem(start: {
+  x: number;
+  y: number;
+}, end: {
+  x: number;
+  y: number;
+} | {
+  item: string;
+}, color: string, id?: string, size?: number, startEnd?: {
+  item: string;
+  anchor?: unknown;
+}): BoardItemEntry;
+declare function titleForBoardItem(value: BoardItem): string;
+//#endregion
+export { BoardAppMetadata, BoardItemEntry, createAppBoardItem, createArrowBoardItem, createDrawBoardItem, createFileNodeForPath, createFrameBoardItem, createShapeBoardItem, createTaskBoardItem, createTextBoardItem, mediaFrameSize, titleForBoardItem };

package/dist/board/model/items/create.js

@@ -0,0 +1,271 @@
+import { parseBoardItem } from "../../../protocol/dist/board-model.js";
+import { pointsRect } from "../../../protocol/dist/board-layout.js";
+import { quantizeDrawCoordinate } from "../draw-input.js";
+import { fileStem } from "../file-snapshot.js";
+import { filePreviewKind } from "../file-preview.js";
+import { DEFAULT_BOARD_TOOL_STYLES } from "../tool-styles.js";
+import { featuredTaskArtifact } from "../task.js";
+import { getMediaResourceTitle, inferBoardMediaKind } from "../media.js";
+import { createBoardItemId } from "./id.js";
+//#region src/board/model/items/create.ts
+const DEFAULT_MEDIA_SIZE = {
+	width: 320,
+	height: 200
+};
+const DEFAULT_TASK_SIZE = {
+	width: 300,
+	height: 188
+};
+const DEFAULT_TASK_MEDIA_SIZE = {
+	width: 320,
+	height: 180
+};
+const DEFAULT_VIDEO_SIZE = {
+	width: 320,
+	height: 180
+};
+const DEFAULT_AUDIO_SIZE = {
+	width: 320,
+	height: 112
+};
+const DEFAULT_FILE_SIZE = {
+	width: 260,
+	height: 132
+};
+const DEFAULT_FILE_COVER_SIZE = {
+	width: 260,
+	height: 208
+};
+const DEFAULT_SHAPE_SIZE = {
+	width: 200,
+	height: 140
+};
+const DEFAULT_FRAME_SIZE = {
+	width: 480,
+	height: 320
+};
+function item(value) {
+	const parsed = parseBoardItem(value);
+	if (!parsed.ok) throw new Error(`Invalid Board item: ${parsed.diagnostics[0]?.path}: ${parsed.diagnostics[0]?.message}`);
+	return parsed.item;
+}
+function centered(x, y, size) {
+	return {
+		position: {
+			x: x - size.width / 2,
+			y: y - size.height / 2
+		},
+		size: { ...size }
+	};
+}
+function mediaFrameSize(naturalWidth, naturalHeight, maxEdge = 480, fallback = DEFAULT_MEDIA_SIZE) {
+	if (!naturalWidth || !naturalHeight || !Number.isFinite(naturalWidth) || !Number.isFinite(naturalHeight) || naturalWidth <= 0 || naturalHeight <= 0) return { ...fallback };
+	const scale = Math.min(1, maxEdge / Math.max(naturalWidth, naturalHeight));
+	return {
+		width: Math.max(24, naturalWidth * scale),
+		height: Math.max(24, naturalHeight * scale)
+	};
+}
+function cleanSnapshot(snapshot) {
+	return Object.fromEntries(Object.entries(snapshot).filter(([, value]) => value !== void 0));
+}
+function createFileNodeForPath(path, x, y, snapshot = {}, id = createBoardItemId()) {
+	const kind = inferBoardMediaKind(path, snapshot.mimeType);
+	const title = snapshot.title ?? (kind === "file" || kind === "text" ? fileStem(path) : getMediaResourceTitle(path));
+	if (kind === "image" || kind === "video") {
+		const size = mediaFrameSize(snapshot.naturalWidth, snapshot.naturalHeight, 480, kind === "video" ? DEFAULT_VIDEO_SIZE : DEFAULT_MEDIA_SIZE);
+		const mimeType = snapshot.mimeType ?? (kind === "video" ? "video/*" : void 0);
+		return {
+			id,
+			item: item({
+				type: kind,
+				...centered(x, y, size),
+				props: {
+					src: path,
+					snapshot: cleanSnapshot({
+						...snapshot,
+						title,
+						mimeType
+					})
+				}
+			})
+		};
+	}
+	if (kind === "audio") return {
+		id,
+		item: item({
+			type: "audio",
+			...centered(x, y, DEFAULT_AUDIO_SIZE),
+			props: {
+				src: path,
+				snapshot: cleanSnapshot({
+					...snapshot,
+					title,
+					mimeType: snapshot.mimeType ?? "audio/*"
+				})
+			}
+		})
+	};
+	return {
+		id,
+		item: item({
+			type: "file",
+			...centered(x, y, filePreviewKind(snapshot) === "cover" ? DEFAULT_FILE_COVER_SIZE : DEFAULT_FILE_SIZE),
+			props: {
+				src: path,
+				snapshot: cleanSnapshot({
+					...snapshot,
+					title
+				})
+			}
+		})
+	};
+}
+function createTaskBoardItem(taskRunId, snapshot, x, y, metadata, id = createBoardItemId()) {
+	const artifact = featuredTaskArtifact(snapshot.artifacts);
+	const visual = artifact?.type === "image" || artifact?.type === "video" ? artifact : null;
+	return {
+		id,
+		item: item({
+			type: "task",
+			...centered(x, y, visual ? mediaFrameSize(visual.naturalWidth, visual.naturalHeight, 480, DEFAULT_TASK_MEDIA_SIZE) : artifact?.type === "audio" ? DEFAULT_TASK_MEDIA_SIZE : DEFAULT_TASK_SIZE),
+			...metadata ? { metadata } : {},
+			props: {
+				taskRunId,
+				snapshot
+			}
+		})
+	};
+}
+function createTextBoardItem(text, x, y, color = DEFAULT_BOARD_TOOL_STYLES.text.color, id = createBoardItemId()) {
+	return {
+		id,
+		item: item({
+			type: "text",
+			position: {
+				x,
+				y
+			},
+			...color === "neutral" ? {} : { style: { fill: color } },
+			props: { text }
+		})
+	};
+}
+function createShapeBoardItem(geometry, x, y, color = DEFAULT_BOARD_TOOL_STYLES.shape.color, id = createBoardItemId(), box) {
+	return {
+		id,
+		item: item({
+			type: "shape",
+			...box ? {
+				position: {
+					x: box.x,
+					y: box.y
+				},
+				size: {
+					width: box.width,
+					height: box.height
+				}
+			} : centered(x, y, DEFAULT_SHAPE_SIZE),
+			style: { stroke: color },
+			props: { geometry }
+		})
+	};
+}
+function createFrameBoardItem(x, y, color = DEFAULT_BOARD_TOOL_STYLES.frame.color, label = "Frame", id = createBoardItemId(), box) {
+	return {
+		id,
+		item: item({
+			type: "frame",
+			...box ? {
+				position: {
+					x: box.x,
+					y: box.y
+				},
+				size: {
+					width: box.width,
+					height: box.height
+				}
+			} : centered(x, y, DEFAULT_FRAME_SIZE),
+			...color === "neutral" ? {} : { style: { stroke: color } },
+			props: { label }
+		})
+	};
+}
+function createAppBoardItem(app, x, y, id = createBoardItemId()) {
+	return {
+		id,
+		item: {
+			...createFrameBoardItem(x, y, "brand", app.name, id).item,
+			metadata: { cohubApp: app }
+		}
+	};
+}
+function createDrawBoardItem(worldPoints, color, size = 4, id = createBoardItemId()) {
+	const origin = pointsRect(worldPoints);
+	const points = worldPoints.map((point) => ({
+		x: quantizeDrawCoordinate(point.x - origin.x),
+		y: quantizeDrawCoordinate(point.y - origin.y),
+		p: point.p
+	}));
+	return {
+		id,
+		item: item({
+			type: "draw",
+			position: {
+				x: origin.x,
+				y: origin.y
+			},
+			style: {
+				stroke: color,
+				strokeWidth: size
+			},
+			props: { points }
+		})
+	};
+}
+function createArrowBoardItem(start, end, color, id = createBoardItemId(), size = DEFAULT_BOARD_TOOL_STYLES.arrow.size, startEnd) {
+	const local = (point) => ({
+		x: point.x - start.x,
+		y: point.y - start.y
+	});
+	return {
+		id,
+		item: item({
+			type: "arrow",
+			position: {
+				x: start.x,
+				y: start.y
+			},
+			style: {
+				stroke: color,
+				strokeWidth: size
+			},
+			props: {
+				start: startEnd ?? {
+					x: 0,
+					y: 0
+				},
+				end: "item" in end ? end : local(end)
+			}
+		})
+	};
+}
+function titleForBoardItem(value) {
+	switch (value.type) {
+		case "text": return value.props.text.split("\n")[0] || "Text";
+		case "shape": return value.props.text.split("\n")[0] || value.props.geometry;
+		case "draw": return "Drawing";
+		case "arrow": return value.props.label || "Arrow";
+		case "frame": return value.props.label || "Frame";
+		case "image":
+		case "video":
+		case "audio": return value.props.snapshot?.title ?? getMediaResourceTitle(value.props.src);
+		case "file": return value.props.snapshot?.title ?? fileStem(value.props.src);
+		case "task": return value.props.snapshot.title;
+		case "effect": return value.props.kind;
+		case "sketch": return value.props.src.split("/").pop() ?? "Sketch";
+		default: return value.type;
+	}
+}
+//#endregion
+export { createAppBoardItem, createArrowBoardItem, createDrawBoardItem, createFileNodeForPath, createFrameBoardItem, createShapeBoardItem, createTaskBoardItem, createTextBoardItem, mediaFrameSize, titleForBoardItem };

package/dist/board/model/items/definition.d.ts

@@ -0,0 +1,35 @@
+import { BoardExtensionItem, BoardItemType } from "../../../protocol/dist/board-model.js";
+import "../../../protocol/dist/index.js";
+import { Rect, WorldPoint } from "../geometry.js";
+import { BoardSceneItem } from "../scene.js";
+import { z } from "zod";
+//#region src/board/model/items/definition.d.ts
+type BoardItemCapabilities = {
+  canMove: boolean;
+  canResize: boolean;
+  aspectLocked: boolean;
+  canRotate: boolean;
+  canEdit: boolean;
+  canConnect: boolean;
+  canSnap: boolean;
+  canLock: boolean;
+};
+type BoardItemResizeMode = "none" | "uniform" | "free";
+declare const FULL_CAPABILITIES: BoardItemCapabilities;
+type BoardItemDefinition<Props extends Record<string, unknown> = Record<string, unknown>> = {
+  type: BoardItemType;
+  capabilities?: Partial<BoardItemCapabilities>;
+  size?: {
+    width: number;
+    height: number;
+  };
+  props?: z.ZodType<Props>;
+  bounds?: (item: BoardSceneItem) => Rect;
+  hitTest?: (item: BoardSceneItem, point: WorldPoint) => boolean;
+};
+type BoardItemOf<Definition> = Definition extends BoardItemDefinition<infer Props> ? BoardExtensionItem & {
+  props: Props;
+} : never;
+declare function defineBoardItem<Props extends Record<string, unknown>>(definition: BoardItemDefinition<Props>): BoardItemDefinition<Props>;
+//#endregion
+export { BoardItemCapabilities, BoardItemDefinition, BoardItemOf, BoardItemResizeMode, FULL_CAPABILITIES, defineBoardItem };

package/dist/board/model/items/definition.js

@@ -0,0 +1,18 @@
+import { BOARD_EXTENSION_TYPE_PATTERN, isBuiltinItemType } from "../../../protocol/dist/board-model.js";
+//#region src/board/model/items/definition.ts
+const FULL_CAPABILITIES = {
+	canMove: true,
+	canResize: true,
+	aspectLocked: false,
+	canRotate: true,
+	canEdit: false,
+	canConnect: true,
+	canSnap: true,
+	canLock: true
+};
+function defineBoardItem(definition) {
+	if (!isBuiltinItemType(definition.type) && !BOARD_EXTENSION_TYPE_PATTERN.test(definition.type)) throw new Error(`Board item type "${definition.type}" must be namespaced, like "acme.order".`);
+	return definition;
+}
+//#endregion
+export { FULL_CAPABILITIES, defineBoardItem };

package/dist/board/model/items/id.d.ts

@@ -0,0 +1,5 @@
+//#region src/board/model/items/id.d.ts
+declare function createBoardEntityId(): string;
+declare function createBoardItemId(): string;
+//#endregion
+export { createBoardEntityId, createBoardItemId };

package/dist/board/model/items/id.js

@@ -0,0 +1,11 @@
+//#region src/board/model/items/id.ts
+function createBoardEntityId() {
+	const cryptoRef = globalThis.crypto;
+	if (cryptoRef && typeof cryptoRef.randomUUID === "function") return cryptoRef.randomUUID();
+	return `c-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function createBoardItemId() {
+	return `item_${createBoardEntityId()}`;
+}
+//#endregion
+export { createBoardEntityId, createBoardItemId };

package/dist/board/model/items/index.d.ts

@@ -0,0 +1,6 @@
+import { BoardItemCapabilities, BoardItemDefinition, BoardItemOf, BoardItemResizeMode, FULL_CAPABILITIES, defineBoardItem } from "./definition.js";
+import { builtinBoardItems } from "./builtin.js";
+import { BoardAppMetadata, BoardItemEntry, createAppBoardItem, createArrowBoardItem, createDrawBoardItem, createFileNodeForPath, createFrameBoardItem, createShapeBoardItem, createTaskBoardItem, createTextBoardItem, mediaFrameSize, titleForBoardItem } from "./create.js";
+import { createBoardEntityId, createBoardItemId } from "./id.js";
+import { BoardItemInput, BoardRegistry, createBoardRegistry, defaultBoardRegistry } from "./registry.js";
+export { BoardAppMetadata, BoardItemCapabilities, BoardItemDefinition, BoardItemEntry, BoardItemInput, BoardItemOf, BoardItemResizeMode, BoardRegistry, FULL_CAPABILITIES, builtinBoardItems, createAppBoardItem, createArrowBoardItem, createBoardEntityId, createBoardItemId, createBoardRegistry, createDrawBoardItem, createFileNodeForPath, createFrameBoardItem, createShapeBoardItem, createTaskBoardItem, createTextBoardItem, defaultBoardRegistry, defineBoardItem, mediaFrameSize, titleForBoardItem };

package/dist/board/model/items/index.js

@@ -0,0 +1,6 @@
+import { FULL_CAPABILITIES, defineBoardItem } from "./definition.js";
+import { builtinBoardItems } from "./builtin.js";
+import { createBoardEntityId, createBoardItemId } from "./id.js";
+import { createAppBoardItem, createArrowBoardItem, createDrawBoardItem, createFileNodeForPath, createFrameBoardItem, createShapeBoardItem, createTaskBoardItem, createTextBoardItem, mediaFrameSize, titleForBoardItem } from "./create.js";
+import { createBoardRegistry, defaultBoardRegistry } from "./registry.js";
+export { FULL_CAPABILITIES, builtinBoardItems, createAppBoardItem, createArrowBoardItem, createBoardEntityId, createBoardItemId, createBoardRegistry, createDrawBoardItem, createFileNodeForPath, createFrameBoardItem, createShapeBoardItem, createTaskBoardItem, createTextBoardItem, defaultBoardRegistry, defineBoardItem, mediaFrameSize, titleForBoardItem };

package/dist/board/model/items/registry.d.ts

@@ -0,0 +1,35 @@
+import { BoardItem } from "../../../protocol/dist/board-model.js";
+import "../../../protocol/dist/index.js";
+import { Rect, WorldPoint } from "../geometry.js";
+import { BoardSceneItem } from "../scene.js";
+import { BoardItemCapabilities, BoardItemDefinition, BoardItemResizeMode } from "./definition.js";
+import { BoardItemEntry } from "./create.js";
+//#region src/board/model/items/registry.d.ts
+type BoardItemInput = {
+  props?: Record<string, unknown>;
+  at: WorldPoint;
+  size?: {
+    width: number;
+    height: number;
+  };
+  id?: string;
+};
+type BoardRegistry = {
+  readonly definitions: readonly BoardItemDefinition[];
+  get(type: string): BoardItemDefinition | undefined;
+  capabilities(item: Pick<BoardItem, "type">): BoardItemCapabilities;
+  resizeMode(item: Pick<BoardItem, "type">): BoardItemResizeMode;
+  bounds(item: BoardSceneItem): Rect;
+  hitTest(item: BoardSceneItem, point: WorldPoint): boolean;
+  validateProps(type: string, props: unknown): {
+    ok: true;
+  } | {
+    ok: false;
+    message: string;
+  };
+  create(type: string, input: BoardItemInput): BoardItemEntry;
+};
+declare function createBoardRegistry(definitions?: Iterable<BoardItemDefinition>): BoardRegistry;
+declare const defaultBoardRegistry: BoardRegistry;
+//#endregion
+export { BoardItemInput, BoardRegistry, createBoardRegistry, defaultBoardRegistry };

package/dist/board/model/items/registry.js

@@ -0,0 +1,84 @@
+import { hasAuthoredSize, parseBoardItem } from "../../../protocol/dist/board-model.js";
+import { frameContainsPoint, itemBounds } from "../geometry.js";
+import { FULL_CAPABILITIES } from "./definition.js";
+import { builtinBoardItems } from "./builtin.js";
+import { createBoardItemId } from "./id.js";
+//#region src/board/model/items/registry.ts
+const DEFAULT_ITEM_SIZE = {
+	width: 240,
+	height: 160
+};
+function createBoardRegistry(definitions = []) {
+	const byType = /* @__PURE__ */ new Map();
+	for (const definition of [...builtinBoardItems, ...definitions]) byType.set(definition.type, definition);
+	const capabilities = /* @__PURE__ */ new Map();
+	function capabilitiesOf(type) {
+		let value = capabilities.get(type);
+		if (!value) {
+			value = {
+				...FULL_CAPABILITIES,
+				...byType.get(type)?.capabilities
+			};
+			capabilities.set(type, value);
+		}
+		return value;
+	}
+	function validateProps(type, props) {
+		const schema = byType.get(type)?.props;
+		if (!schema) return { ok: true };
+		const parsed = schema.safeParse(props);
+		if (parsed.success) return { ok: true };
+		const issue = parsed.error.issues[0];
+		return {
+			ok: false,
+			message: `${type} props${issue?.path.length ? `.${issue.path.join(".")}` : ""}: ${issue?.message ?? "invalid"}`
+		};
+	}
+	return {
+		definitions: [...byType.values()],
+		get: (type) => byType.get(type),
+		capabilities: (item) => capabilitiesOf(item.type),
+		resizeMode(item) {
+			const value = capabilitiesOf(item.type);
+			if (!value.canResize) return "none";
+			return value.aspectLocked ? "uniform" : "free";
+		},
+		bounds: (item) => byType.get(item.type)?.bounds?.(item) ?? itemBounds(item.frame),
+		hitTest(item, point) {
+			const hitTest = byType.get(item.type)?.hitTest;
+			return hitTest ? hitTest(item, point) : frameContainsPoint(item.frame, point);
+		},
+		validateProps,
+		create(type, { props = {}, at, size, id = createBoardItemId() }) {
+			const valid = validateProps(type, props);
+			if (!valid.ok) throw new Error(valid.message);
+			const box = size ?? byType.get(type)?.size ?? DEFAULT_ITEM_SIZE;
+			const placement = hasAuthoredSize(type) ? {
+				position: {
+					x: at.x - box.width / 2,
+					y: at.y - box.height / 2
+				},
+				size: { ...box }
+			} : { position: {
+				x: at.x,
+				y: at.y
+			} };
+			const parsed = parseBoardItem({
+				type,
+				...placement,
+				props
+			});
+			if (!parsed.ok) {
+				const diagnostic = parsed.diagnostics[0];
+				throw new Error(`Invalid ${type} item: ${diagnostic?.path}: ${diagnostic?.message}`);
+			}
+			return {
+				id,
+				item: parsed.item
+			};
+		}
+	};
+}
+const defaultBoardRegistry = createBoardRegistry();
+//#endregion
+export { createBoardRegistry, defaultBoardRegistry };

package/dist/board/{media-playback.d.ts → model/media-playback.d.ts}

@@ -1,5 +1,5 @@
-import { BoardSceneItem } from "./core/scene.js";
-//#region src/board/media-playback.d.ts
+import { BoardSceneItem } from "./scene.js";
+//#region src/board/model/media-playback.d.ts
 type BoardAssetSource = {
   resolveFileUrl: (path: string) => Promise<string | null>;
   resolvePlaybackUrl?: (path: string) => Promise<string | null>;

package/dist/board/{media-playback.js → model/media-playback.js}

@@ -1,5 +1,5 @@
 import { rankedTaskArtifacts } from "./task.js";
-//#region src/board/media-playback.ts
+//#region src/board/model/media-playback.ts
 const resolvedUrls = /* @__PURE__ */ new Map();
 const sourceIds = /* @__PURE__ */ new WeakMap();
 const URL_CACHE_LIMIT = 64;

package/dist/board/{media.d.ts → model/media.d.ts}

@@ -1,4 +1,4 @@
-//#region src/board/media.d.ts
+//#region src/board/model/media.d.ts
 type BoardMediaKind = "image" | "video" | "audio" | "text" | "file";
 declare function getMediaExtension(value: string): string;
 declare function inferBoardMediaKind(value: string, mimeType?: string | null): BoardMediaKind;