@neta-art/cohub 9.0.1 → 11.0.0

package/dist/board/model/index.js

@@ -0,0 +1,39 @@
+import { BOARD_STROKE_MAX_SIZE, BOARD_STROKE_MIN_SIZE, clampBoardStrokeSize } from "../../protocol/dist/board-constants.js";
+import { isPublicBoardRemoteAddress, normalizeBoardRemoteUrl } from "../../protocol/dist/board-url.js";
+import { BOARD_ANCHOR_SIDES, BOARD_ARROW_ROUTES, BOARD_CAMERA_TARGET, BOARD_COLOR_TOKENS, BOARD_DASHES, BOARD_DERIVED_SIZE_TYPES, BOARD_EFFECT_KINDS, BOARD_EFFECT_KIND_INFO, BOARD_ENTER_PRESETS, BOARD_EXTENSION_TYPE_PATTERN, BOARD_GRID_DEFAULT_SIZE, BOARD_GRID_MAX_SIZE, BOARD_GRID_MIN_SIZE, BOARD_ID_MAX_LENGTH, BOARD_ITEM_SCHEMAS, BOARD_ITEM_TYPES, BOARD_PLAY_MODES, BOARD_SHAPE_GEOMETRIES, BOARD_TASK_ARTIFACT_LIMIT, BOARD_TEXT_ALIGNS, BoardAnimationHeaderSchema, BoardAnimationSchema, BoardArrowAnchorSchema, BoardArrowBindingSchema, BoardArrowEndSchema, BoardArrowItemSchema, BoardAudioItemSchema, BoardBackgroundSchema, BoardColorSchema, BoardCropSchema, BoardCustomItemSchema, BoardDrawItemSchema, BoardDrawPointSchema, BoardEaseSchema, BoardEffectItemSchema, BoardExtensionItemSchema, BoardFileItemSchema, BoardFrameItemSchema, BoardIdSchema, BoardImageItemSchema, BoardKeySchema, BoardKeyframeSchema, BoardMarkerSchema, BoardMediaSnapshotSchema, BoardMediaSourceSchema, BoardPatchSchema, BoardScriptSchema, BoardSettingsSchema, BoardShapeItemSchema, BoardSizeSchema, BoardStyleSchema, BoardTaskArtifactSchema, BoardTaskItemSchema, BoardTaskSnapshotSchema, BoardTextItemSchema, BoardTrackSchema, BoardVec2Schema, BoardVideoItemSchema, boardItemSchema, emptyBoardDocument, hasAuthoredSize, isBoardColorString, isBoardEase, isBuiltinItem, isBuiltinItemType, isEmptyBoardDelta, isFileBackedItem, isMediaItem, isSafeBoardSourcePath, parseBoardItem, parseBoardMediaSource } from "../../protocol/dist/board-model.js";
+import { IDENTITY_MATRIX, anchorPoint, applyMatrix, arrowBindings, autoAnchorSide, bendControl, clampBoardFontSize, createBoardLayout, createDocumentLayout, drawPointsBounds, drawSampleRadius, estimateTextWidth, framePoint, invertMatrix, isArrowBinding, layoutBoardText, multiplyMatrix, pointsRect, rotateAround, scaleVector, setBoardTextMeasurer, sideAnchor } from "../../protocol/dist/board-layout.js";
+import { applyBoardDelta, applyBoardPatch, applyBoardPatchToDocument, boardPatchTouches, createDocumentState, diffBoardDocuments, diffMergePatch, isEmptyBoardPatch, listBoardProperties, mergePatch, parseBoardDocument, pruneBoardTrack, resolveBoardProperty, trackReferences } from "../../protocol/dist/board-patch.js";
+import { isBoardPath, parseBoardManifest, serializeBoardManifest } from "../../protocol/dist/board.js";
+import { BOARD_SCHEMA_TARGETS, boardJsonSchema, boardSchemaOverview } from "../../protocol/dist/board-schema.js";
+import { boardScriptItems, hasBoardScripts } from "./script-index.js";
+import { CORNER_RESIZE_HANDLES, CORNER_ROTATION_ZONE_WIDTH, EDGE_RESIZE_HANDLES, FIT_PADDING, HANDLE_DIRECTION, HANDLE_HIT_RADIUS, MAX_BOARD_ZOOM, MIN_BOARD_ZOOM, MIN_ITEM_SIZE, RESIZE_HANDLES, ROTATION_HANDLE_OFFSET, VIEWPORT_MARGIN_RATIO, angleFromCenter, cameraForFocus, cameraForRect, cameraForState, clamp, clampZoom, degToRad, expandRect, fitToContent, frameContainsPoint, frameCornerRotationHandleAt, frameCorners, frameEdgeHandleAt, frameHandlePosition, frameRayIntersection, frameRect, handlePosition, itemBounds, normalizeRotation, normalizeViewport, normalizedPoint, panBy, pointToWorld, pointsBounds, radToDeg, rectCenter, rectContainsPoint, rectForCameraFocus, rectsIntersect, resizeFrame, resizeFrameToSize, rotateFrames, rotatePointAround, rotationHandleAnchor, rotationHandlePosition, scaleFrames, screenOffset, screenPoint, screenToWorld, selectionBounds, stableCullRect, unionRects, visibleWorldRect, worldOffset, worldPoint, worldRect, worldToScreen, zoomAround } from "./geometry.js";
+import { boardScriptScope, composeBoardScriptItems, prepareBoardScriptOutput, scriptTemporaryPrefix, validateBoardScriptCommit, validateBoardScriptOutput } from "./script-scene.js";
+import { boardScriptTarget } from "./script-hit.js";
+import { BOARD_SCRIPT_DRAWING_EXAMPLE } from "./script-example.js";
+import { applyBoardEvaluation, boardAnimationTime, boardDocumentAt, boardEase, compileBoardAnimations, evaluateBoardAnimations, parseHexColor, sampleBoardTrack } from "./animation.js";
+import { buildBoardScene, orderBoardItems, placeItem, refreshBoardScene, sceneItemToItem, sceneItemsToRecord, toSceneItem } from "./scene.js";
+import { createBoardAnimationSampler, resolveBoardAnimationCamera } from "./sampling.js";
+import { boardPathTrack, boardSequence, boardSequencePatch } from "./authoring.js";
+import { BOARD_PRESET_NAMES, boardNestedAnimation, boardNestedAnimationTrack, boardPresetTracks, isBoardPresetName, listBoardPresets } from "./presets.js";
+import { ARROW_BINDING_GAP, arrowHitRadius, arrowPathBounds, distanceToArrow, pathMidpoint, pathPointAt, resolveAnchor, resolveArrow, resolveSceneArrow } from "./arrow-geometry.js";
+import { buildStrokeOutline, buildStrokeRibbonGeometry, computeDrawBounds, createStrokeRibbonBuilder, distanceToStroke, isStrokeCorner, sampleRadius, simplifyDrawIndices, trimDrawPoints } from "./draw-geometry.js";
+import { appendBoardDrawSamples, quantizeDrawCoordinate } from "./draw-input.js";
+import { BOARD_EXPORT_MAX_TEXTURES, selectBoardExportAssets } from "./export-assets.js";
+import { BOARD_EXPORT_DEFAULT_PADDING, BOARD_EXPORT_DEFAULT_SCALE, BOARD_EXPORT_ITEM_WARN_THRESHOLD, BOARD_EXPORT_MAX_EDGE, BOARD_EXPORT_MAX_PIXELS, exportItemBounds, normalizeBoardDocument, planBoardExport } from "./export-plan.js";
+import { getMediaExtension, getMediaResourceTitle, inferBoardMediaKind } from "./media.js";
+import { FILE_EXCERPT_MAX_BYTES, FILE_EXCERPT_MAX_CHARS, buildCodeExcerpt, buildFileExcerpt, buildFileSnapshot, fileBaseName, fileCategory, fileStem, readCoverFromFrontmatter, readFrontmatterScalars, readTitleFromFrontmatter, resolveCoverRef, resolveFileTitle, resolveSpacePath, shouldFetchFileExcerpt, splitFrontmatter } from "./file-snapshot.js";
+import { availabilityFromError, fileCategoryAccent, fileMetaLine, filePreviewKind, filePreviewMemoKey, filePreviewScope, fileTypeLabel, formatFileSize, isFileSnapshotFresh, mergeFileSnapshot } from "./file-preview.js";
+import { BOARD_COLORS, DEFAULT_BOARD_COLOR, boardColorCssVar, buildFallbackShapeColors, isBoardColorId, pickBoardColor, resolveBoardColor, resolveItemColor } from "./palette.js";
+import { SHAPE_KINDS, isShapeKind } from "./shape-types.js";
+import { TEXT_FONT_FAMILY, TEXT_FONT_SIZE, TEXT_LINE_HEIGHT, TEXT_MAX_FONT_SIZE, TEXT_MIN_FONT_SIZE, boardFontFamily } from "./text-metrics.js";
+import { DEFAULT_BOARD_TOOL_STYLES, createBoardToolStyles } from "./tool-styles.js";
+import { featuredTaskArtifact, rankedTaskArtifacts, taskArtifactPreviewUrl, taskArtifacts, taskRunToBoardTaskSnapshot } from "./task.js";
+import { boardImageKeySource, imageAssetKey } from "./image-key.js";
+import { FULL_CAPABILITIES, defineBoardItem } from "./items/definition.js";
+import { builtinBoardItems } from "./items/builtin.js";
+import { createBoardEntityId, createBoardItemId } from "./items/id.js";
+import { createAppBoardItem, createArrowBoardItem, createDrawBoardItem, createFileNodeForPath, createFrameBoardItem, createMediaBoardItem, createShapeBoardItem, createTaskBoardItem, createTextBoardItem, mediaFrameSize, titleForBoardItem } from "./items/create.js";
+import { createBoardRegistry, defaultBoardRegistry } from "./items/registry.js";
+import { playableBoardMedia, playableBoardMediaList, resetBoardPlaybackUrlCache, resolveBoardMediaUrl } from "./media-playback.js";
+import { boardReplayActorKind, createBoardReplayPlayer } from "./replay.js";
+export { ARROW_BINDING_GAP, BOARD_ANCHOR_SIDES, BOARD_ARROW_ROUTES, BOARD_CAMERA_TARGET, BOARD_COLORS, BOARD_COLOR_TOKENS, BOARD_DASHES, BOARD_DERIVED_SIZE_TYPES, BOARD_EFFECT_KINDS, BOARD_EFFECT_KIND_INFO, BOARD_ENTER_PRESETS, BOARD_EXPORT_DEFAULT_PADDING, BOARD_EXPORT_DEFAULT_SCALE, BOARD_EXPORT_ITEM_WARN_THRESHOLD, BOARD_EXPORT_MAX_EDGE, BOARD_EXPORT_MAX_PIXELS, BOARD_EXPORT_MAX_TEXTURES, BOARD_EXTENSION_TYPE_PATTERN, BOARD_GRID_DEFAULT_SIZE, BOARD_GRID_MAX_SIZE, BOARD_GRID_MIN_SIZE, BOARD_ID_MAX_LENGTH, BOARD_ITEM_SCHEMAS, BOARD_ITEM_TYPES, BOARD_PLAY_MODES, BOARD_PRESET_NAMES, BOARD_SCHEMA_TARGETS, BOARD_SCRIPT_DRAWING_EXAMPLE, BOARD_SHAPE_GEOMETRIES, BOARD_STROKE_MAX_SIZE, BOARD_STROKE_MIN_SIZE, BOARD_TASK_ARTIFACT_LIMIT, BOARD_TEXT_ALIGNS, BoardAnimationHeaderSchema, BoardAnimationSchema, BoardArrowAnchorSchema, BoardArrowBindingSchema, BoardArrowEndSchema, BoardArrowItemSchema, BoardAudioItemSchema, BoardBackgroundSchema, BoardColorSchema, BoardCropSchema, BoardCustomItemSchema, BoardDrawItemSchema, BoardDrawPointSchema, BoardEaseSchema, BoardEffectItemSchema, BoardExtensionItemSchema, BoardFileItemSchema, BoardFrameItemSchema, BoardIdSchema, BoardImageItemSchema, BoardKeySchema, BoardKeyframeSchema, BoardMarkerSchema, BoardMediaSnapshotSchema, BoardMediaSourceSchema, BoardPatchSchema, BoardScriptSchema, BoardSettingsSchema, BoardShapeItemSchema, BoardSizeSchema, BoardStyleSchema, BoardTaskArtifactSchema, BoardTaskItemSchema, BoardTaskSnapshotSchema, BoardTextItemSchema, BoardTrackSchema, BoardVec2Schema, BoardVideoItemSchema, CORNER_RESIZE_HANDLES, CORNER_ROTATION_ZONE_WIDTH, DEFAULT_BOARD_COLOR, DEFAULT_BOARD_TOOL_STYLES, EDGE_RESIZE_HANDLES, FILE_EXCERPT_MAX_BYTES, FILE_EXCERPT_MAX_CHARS, FIT_PADDING, FULL_CAPABILITIES, HANDLE_DIRECTION, HANDLE_HIT_RADIUS, IDENTITY_MATRIX, MAX_BOARD_ZOOM, MIN_BOARD_ZOOM, MIN_ITEM_SIZE, RESIZE_HANDLES, ROTATION_HANDLE_OFFSET, SHAPE_KINDS, TEXT_FONT_FAMILY, TEXT_FONT_SIZE, TEXT_LINE_HEIGHT, TEXT_MAX_FONT_SIZE, TEXT_MIN_FONT_SIZE, VIEWPORT_MARGIN_RATIO, anchorPoint, angleFromCenter, appendBoardDrawSamples, applyBoardDelta, applyBoardEvaluation, applyBoardPatch, applyBoardPatchToDocument, applyMatrix, arrowBindings, arrowHitRadius, arrowPathBounds, autoAnchorSide, availabilityFromError, bendControl, boardAnimationTime, boardColorCssVar, boardDocumentAt, boardEase, boardFontFamily, boardImageKeySource, boardItemSchema, boardJsonSchema, boardNestedAnimation, boardNestedAnimationTrack, boardPatchTouches, boardPathTrack, boardPresetTracks, boardReplayActorKind, boardSchemaOverview, boardScriptItems, boardScriptScope, boardScriptTarget, boardSequence, boardSequencePatch, buildBoardScene, buildCodeExcerpt, buildFallbackShapeColors, buildFileExcerpt, buildFileSnapshot, buildStrokeOutline, buildStrokeRibbonGeometry, builtinBoardItems, cameraForFocus, cameraForRect, cameraForState, clamp, clampBoardFontSize, clampBoardStrokeSize, clampBoardFontSize as clampBoardTextFontSize, clampZoom, compileBoardAnimations, composeBoardScriptItems, computeDrawBounds, createAppBoardItem, createArrowBoardItem, createBoardAnimationSampler, createBoardEntityId, createBoardItemId, createBoardLayout, createBoardRegistry, createBoardReplayPlayer, createBoardToolStyles, createDocumentLayout, createDocumentState, createDrawBoardItem, createFileNodeForPath, createFrameBoardItem, createMediaBoardItem, createShapeBoardItem, createStrokeRibbonBuilder, createTaskBoardItem, createTextBoardItem, defaultBoardRegistry, defineBoardItem, degToRad, diffBoardDocuments, diffMergePatch, distanceToArrow, distanceToStroke, drawPointsBounds, drawSampleRadius, emptyBoardDocument, estimateTextWidth, evaluateBoardAnimations, expandRect, exportItemBounds, featuredTaskArtifact, fileBaseName, fileCategory, fileCategoryAccent, fileMetaLine, filePreviewKind, filePreviewMemoKey, filePreviewScope, fileStem, fileTypeLabel, fitToContent, formatFileSize, frameContainsPoint, frameCornerRotationHandleAt, frameCorners, frameEdgeHandleAt, frameHandlePosition, framePoint, frameRayIntersection, frameRect, getMediaExtension, getMediaResourceTitle, handlePosition, hasAuthoredSize, hasBoardScripts, imageAssetKey, inferBoardMediaKind, invertMatrix, isArrowBinding, isBoardColorId, isBoardColorString, isBoardEase, isBoardPath, isBoardPresetName, isBuiltinItem, isBuiltinItemType, isEmptyBoardDelta, isEmptyBoardPatch, isFileBackedItem, isFileSnapshotFresh, isMediaItem, isPublicBoardRemoteAddress, isSafeBoardSourcePath, isShapeKind, isStrokeCorner, itemBounds, layoutBoardText, listBoardPresets, listBoardProperties, mediaFrameSize, mergeFileSnapshot, mergePatch, multiplyMatrix, normalizeBoardDocument, normalizeBoardRemoteUrl, normalizeRotation, normalizeViewport, normalizedPoint, orderBoardItems, panBy, parseBoardDocument, parseBoardItem, parseBoardManifest, parseBoardMediaSource, parseHexColor, pathMidpoint, pathPointAt, pickBoardColor, placeItem, planBoardExport, playableBoardMedia, playableBoardMediaList, pointToWorld, pointsBounds, pointsRect, prepareBoardScriptOutput, pruneBoardTrack, quantizeDrawCoordinate, radToDeg, rankedTaskArtifacts, readCoverFromFrontmatter, readFrontmatterScalars, readTitleFromFrontmatter, rectCenter, rectContainsPoint, rectForCameraFocus, rectsIntersect, refreshBoardScene, resetBoardPlaybackUrlCache, resizeFrame, resizeFrameToSize, resolveAnchor, resolveArrow, resolveBoardAnimationCamera, resolveBoardColor, resolveBoardMediaUrl, resolveBoardProperty, resolveCoverRef, resolveFileTitle, resolveItemColor, resolveSceneArrow, resolveSpacePath, rotateAround, rotateFrames, rotatePointAround, rotationHandleAnchor, rotationHandlePosition, sampleBoardTrack, sampleRadius, scaleFrames, scaleVector, sceneItemToItem, sceneItemsToRecord, screenOffset, screenPoint, screenToWorld, scriptTemporaryPrefix, selectBoardExportAssets, selectionBounds, serializeBoardManifest, setBoardTextMeasurer, shouldFetchFileExcerpt, sideAnchor, simplifyDrawIndices, splitFrontmatter, stableCullRect, taskArtifactPreviewUrl, taskArtifacts, taskRunToBoardTaskSnapshot, titleForBoardItem, toSceneItem, trackReferences, trimDrawPoints, unionRects, validateBoardScriptCommit, validateBoardScriptOutput, visibleWorldRect, worldOffset, worldPoint, worldRect, worldToScreen, zoomAround };

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

@@ -0,0 +1,5 @@
+import { BoardItemDefinition } from "./definition.js";
+//#region src/board/model/items/builtin.d.ts
+declare const builtinBoardItems: readonly BoardItemDefinition[];
+//#endregion
+export { builtinBoardItems };

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 customItem = defineBoardItem({ type: "custom" });
+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,
+	customItem
+];
+//#endregion
+export { builtinBoardItems };

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

@@ -0,0 +1,61 @@
+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;
+};
+type BoardMediaItemKind = "image" | "video" | "audio" | "file";
+declare function createMediaBoardItem(path: string, x: number, y: number, snapshot?: BoardMediaSnapshot & BoardFileSnapshotFacts, id?: string, mediaKind?: BoardMediaItemKind): BoardItemEntry;
+declare const createFileNodeForPath: typeof createMediaBoardItem;
+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, BoardMediaItemKind, createAppBoardItem, createArrowBoardItem, createDrawBoardItem, createFileNodeForPath, createFrameBoardItem, createMediaBoardItem, createShapeBoardItem, createTaskBoardItem, createTextBoardItem, mediaFrameSize, titleForBoardItem };

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

@@ -0,0 +1,272 @@
+import { parseBoardItem } from "../../../protocol/dist/board-model.js";
+import { pointsRect } from "../../../protocol/dist/board-layout.js";
+import { quantizeDrawCoordinate } from "../draw-input.js";
+import { getMediaResourceTitle, inferBoardMediaKind } from "../media.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 { 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 createMediaBoardItem(path, x, y, snapshot = {}, id = createBoardItemId(), mediaKind) {
+	const kind = mediaKind ?? 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
+				})
+			}
+		})
+	};
+}
+const createFileNodeForPath = createMediaBoardItem;
+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 "custom": return value.script.src.split("/").pop() ?? "Custom";
+		default: return value.type;
+	}
+}
+//#endregion
+export { createAppBoardItem, createArrowBoardItem, createDrawBoardItem, createFileNodeForPath, createFrameBoardItem, createMediaBoardItem, 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, BoardMediaItemKind, createAppBoardItem, createArrowBoardItem, createDrawBoardItem, createFileNodeForPath, createFrameBoardItem, createMediaBoardItem, 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, BoardMediaItemKind, BoardRegistry, FULL_CAPABILITIES, builtinBoardItems, createAppBoardItem, createArrowBoardItem, createBoardEntityId, createBoardItemId, createBoardRegistry, createDrawBoardItem, createFileNodeForPath, createFrameBoardItem, createMediaBoardItem, 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, createMediaBoardItem, 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, createMediaBoardItem, 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 };