@neta-art/cohub 8.23.0 → 9.0.0

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

@@ -0,0 +1,592 @@
+import { z } from "zod";
+//#region ../protocol/dist/board-model.js
+const BOARD_ID_MAX_LENGTH = 160;
+const BOARD_CAMERA_TARGET = "camera";
+const BoardIdSchema = z.string().min(1).max(160).regex(/^[^\s/]+$/, "ids must not contain whitespace or '/'").refine((value) => value !== BOARD_CAMERA_TARGET, "\"camera\" is reserved");
+const finite = z.number().finite();
+const nonNegative = finite.nonnegative();
+const ratio = finite.min(0).max(1);
+const BoardVec2Schema = z.object({
+	x: finite,
+	y: finite
+}).strict();
+const BoardSizeSchema = z.object({
+	width: finite.positive(),
+	height: finite.positive()
+}).strict();
+const BOARD_COLOR_TOKENS = [
+	"brand",
+	"neutral",
+	"black",
+	"white",
+	"blue",
+	"green",
+	"amber",
+	"violet",
+	"rose"
+];
+const CSS_NAMED_COLORS = new Set("transparent aliceblue antiquewhite aqua aquamarine azure beige bisque blanchedalmond blueviolet brown burlywood cadetblue chartreuse chocolate coral cornflowerblue cornsilk crimson cyan darkblue darkcyan darkgoldenrod darkgray darkgreen darkgrey darkkhaki darkmagenta darkolivegreen darkorange darkorchid darkred darksalmon darkseagreen darkslateblue darkslategray darkslategrey darkturquoise darkviolet deeppink deepskyblue dimgray dimgrey dodgerblue firebrick floralwhite forestgreen fuchsia gainsboro ghostwhite gold goldenrod gray grey greenyellow honeydew hotpink indianred indigo ivory khaki lavender lavenderblush lawngreen lemonchiffon lightblue lightcoral lightcyan lightgoldenrodyellow lightgray lightgreen lightgrey lightpink lightsalmon lightseagreen lightskyblue lightslategray lightslategrey lightsteelblue lightyellow lime limegreen linen magenta maroon mediumaquamarine mediumblue mediumorchid mediumpurple mediumseagreen mediumslateblue mediumspringgreen mediumturquoise mediumvioletred midnightblue mintcream mistyrose moccasin navajowhite navy oldlace olive olivedrab orange orangered orchid palegoldenrod palegreen paleturquoise palevioletred papayawhip peachpuff peru pink plum powderblue purple rebeccapurple red rosybrown royalblue saddlebrown salmon sandybrown seagreen seashell sienna silver skyblue slateblue slategray slategrey snow springgreen steelblue tan teal thistle tomato turquoise violet wheat whitesmoke yellow yellowgreen".split(" "));
+function isBoardColorString(value) {
+	const color = value.trim().toLowerCase();
+	return BOARD_COLOR_TOKENS.includes(color) || CSS_NAMED_COLORS.has(color) || /^#(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/.test(color) || /^(?:rgba?|hsla?|hwb|lab|lch|oklab|oklch|color)\([^()]*\)$/.test(color);
+}
+const colorString = z.string().max(120).refine(isBoardColorString, "expected a palette token or a CSS color");
+const BoardColorSchema = z.union([colorString, z.object({
+	light: colorString,
+	dark: colorString
+}).strict()]);
+const BOARD_DASHES = [
+	"solid",
+	"dashed",
+	"dotted"
+];
+const BoardStyleSchema = z.object({
+	fill: BoardColorSchema.optional(),
+	fillOpacity: ratio.optional(),
+	stroke: BoardColorSchema.optional(),
+	strokeWidth: finite.min(0).max(64).optional(),
+	dash: z.enum(BOARD_DASHES).optional(),
+	radius: nonNegative.optional(),
+	trim: ratio.optional()
+}).strict();
+function isSafeBoardSourcePath(value) {
+	return value.length > 0 && value.length <= 4096 && !value.startsWith("/") && !value.includes("\\") && value.split("/").every((part) => part.length > 0 && part !== "." && part !== "..");
+}
+const srcSchema = z.string().refine(isSafeBoardSourcePath, "src must be a relative Space file path");
+const itemEnvelope = {
+	parent: BoardIdSchema.optional(),
+	z: finite.optional(),
+	position: BoardVec2Schema.default({
+		x: 0,
+		y: 0
+	}),
+	rotation: finite.default(0),
+	scale: z.union([finite, BoardVec2Schema]).default(1),
+	origin: BoardVec2Schema.default({
+		x: .5,
+		y: .5
+	}),
+	opacity: ratio.default(1),
+	style: BoardStyleSchema.default({}),
+	locked: z.boolean().optional(),
+	metadata: z.record(z.string(), z.unknown()).optional()
+};
+const boxed = (width, height) => ({
+	...itemEnvelope,
+	size: BoardSizeSchema.default({
+		width,
+		height
+	})
+});
+const unsized = { ...itemEnvelope };
+const fontSize = finite.min(2).max(512);
+const BOARD_TEXT_ALIGNS = [
+	"left",
+	"center",
+	"right"
+];
+const BOARD_SHAPE_GEOMETRIES = [
+	"rectangle",
+	"rounded",
+	"ellipse",
+	"diamond",
+	"triangle",
+	"path"
+];
+const BoardFrameItemSchema = z.object({
+	...boxed(480, 320),
+	type: z.literal("frame"),
+	props: z.object({
+		label: z.string().max(280).default(""),
+		clip: z.boolean().default(true)
+	}).strict().prefault({})
+}).strict();
+const BoardTextItemSchema = z.object({
+	...unsized,
+	type: z.literal("text"),
+	props: z.object({
+		text: z.string().default(""),
+		fontSize: fontSize.default(24),
+		fontWeight: finite.min(100).max(900).default(500),
+		font: z.string().min(1).max(120).default("sans"),
+		align: z.enum(BOARD_TEXT_ALIGNS).default("left"),
+		lineHeight: finite.min(.5).max(4).default(4 / 3),
+		width: finite.positive().optional(),
+		reveal: ratio.default(1),
+		caret: z.boolean().default(false)
+	}).strict().prefault({})
+}).strict();
+const BoardShapeItemSchema = z.object({
+	...boxed(240, 160),
+	type: z.literal("shape"),
+	props: z.object({
+		geometry: z.enum(BOARD_SHAPE_GEOMETRIES).default("rectangle"),
+		path: z.string().min(1).max(2e5).optional(),
+		text: z.string().default(""),
+		fontSize: fontSize.default(20),
+		align: z.enum(BOARD_TEXT_ALIGNS).default("center")
+	}).strict().refine((props) => props.geometry !== "path" || Boolean(props.path), {
+		message: "path geometry requires props.path",
+		path: ["path"]
+	}).prefault({})
+}).strict();
+const BoardDrawPointSchema = z.object({
+	x: finite,
+	y: finite,
+	p: ratio.default(.5)
+}).strict();
+const BoardDrawItemSchema = z.object({
+	...unsized,
+	type: z.literal("draw"),
+	props: z.object({ points: z.array(BoardDrawPointSchema).min(1).max(1e5) }).strict()
+}).strict();
+const BOARD_ANCHOR_SIDES = [
+	"top",
+	"right",
+	"bottom",
+	"left"
+];
+const BoardArrowAnchorSchema = z.union([
+	z.literal("auto"),
+	z.object({
+		side: z.enum(BOARD_ANCHOR_SIDES),
+		offset: ratio.default(.5)
+	}).strict(),
+	z.object({
+		x: ratio,
+		y: ratio
+	}).strict()
+]);
+const BoardArrowBindingSchema = z.object({
+	item: BoardIdSchema,
+	anchor: BoardArrowAnchorSchema.default("auto"),
+	port: z.string().min(1).max(120).optional()
+}).strict();
+const BoardArrowEndSchema = z.union([BoardVec2Schema, BoardArrowBindingSchema]);
+const BOARD_ARROW_ROUTES = [
+	"straight",
+	"curve",
+	"orthogonal"
+];
+const BoardArrowItemSchema = z.object({
+	...unsized,
+	type: z.literal("arrow"),
+	props: z.object({
+		start: BoardArrowEndSchema,
+		end: BoardArrowEndSchema,
+		route: z.enum(BOARD_ARROW_ROUTES).default("straight"),
+		bend: finite.min(-.85).max(.85).default(0),
+		waypoints: z.array(BoardVec2Schema).max(64).default([]),
+		arrowStart: z.boolean().default(false),
+		arrowEnd: z.boolean().default(true),
+		label: z.string().max(280).default(""),
+		fontSize: fontSize.default(14),
+		relation: z.string().max(64).regex(/^[a-z0-9]+(?:[.-][a-z0-9]+)*$/, "relation must be a lowercase slug").optional()
+	}).strict()
+}).strict();
+const BoardMediaSnapshotSchema = z.object({
+	title: z.string().optional(),
+	mimeType: z.string().optional(),
+	size: nonNegative.optional(),
+	mtimeMs: nonNegative.optional(),
+	naturalWidth: finite.positive().optional(),
+	naturalHeight: finite.positive().optional(),
+	durationMs: nonNegative.optional(),
+	excerpt: z.string().optional(),
+	coverPath: z.string().optional(),
+	coverUrl: z.string().optional()
+}).strict();
+const fileProps = {
+	src: srcSchema,
+	snapshot: BoardMediaSnapshotSchema.optional()
+};
+const timedFileProps = {
+	...fileProps,
+	time: nonNegative.optional()
+};
+const BoardCropSchema = z.object({
+	x: ratio,
+	y: ratio,
+	w: ratio,
+	h: ratio
+}).strict();
+const BoardImageItemSchema = z.object({
+	...boxed(640, 360),
+	type: z.literal("image"),
+	props: z.object({
+		...fileProps,
+		crop: BoardCropSchema.optional()
+	}).strict()
+}).strict();
+const BoardVideoItemSchema = z.object({
+	...boxed(640, 360),
+	type: z.literal("video"),
+	props: z.object(timedFileProps).strict()
+}).strict();
+const BoardAudioItemSchema = z.object({
+	...boxed(480, 96),
+	type: z.literal("audio"),
+	props: z.object(timedFileProps).strict()
+}).strict();
+const BoardFileItemSchema = z.object({
+	...boxed(360, 220),
+	type: z.literal("file"),
+	props: z.object(fileProps).strict()
+}).strict();
+const BOARD_TASK_ARTIFACT_LIMIT = 6;
+const httpsUrl = z.string().max(4096).url();
+const artifactBase = {
+	id: z.string().min(1).max(240),
+	title: z.string().max(240).optional(),
+	url: httpsUrl,
+	mimeType: z.string().max(160).optional()
+};
+const BoardTaskArtifactSchema = z.discriminatedUnion("type", [
+	z.object({
+		...artifactBase,
+		type: z.literal("image"),
+		naturalWidth: finite.positive().optional(),
+		naturalHeight: finite.positive().optional()
+	}).strict(),
+	z.object({
+		...artifactBase,
+		type: z.literal("video"),
+		previewUrl: httpsUrl.optional(),
+		durationMs: z.number().int().positive().optional(),
+		naturalWidth: finite.positive().optional(),
+		naturalHeight: finite.positive().optional()
+	}).strict(),
+	z.object({
+		...artifactBase,
+		type: z.literal("audio"),
+		previewUrl: httpsUrl.optional(),
+		durationMs: z.number().int().positive().optional()
+	}).strict(),
+	z.object({
+		id: z.string().min(1).max(240),
+		type: z.literal("text"),
+		title: z.string().max(240).optional(),
+		textExcerpt: z.string().min(1).max(480)
+	}).strict()
+]);
+const BoardTaskSnapshotSchema = z.object({
+	taskType: z.string().min(1).max(120),
+	status: z.enum([
+		"pending",
+		"running",
+		"completed",
+		"failed"
+	]),
+	title: z.string().min(1).max(240),
+	model: z.string().max(160).optional(),
+	promptExcerpt: z.string().max(480).optional(),
+	artifactCount: z.number().int().nonnegative(),
+	artifacts: z.array(BoardTaskArtifactSchema).max(6).default([]),
+	updatedAt: z.string().optional()
+}).strict();
+const BoardTaskItemSchema = z.object({
+	...boxed(420, 240),
+	type: z.literal("task"),
+	props: z.object({
+		taskRunId: z.string().min(1).max(160),
+		snapshot: BoardTaskSnapshotSchema
+	}).strict()
+}).strict();
+const BOARD_EFFECT_KINDS = [
+	"particles",
+	"trail",
+	"impact",
+	"flash",
+	"glow"
+];
+const BOARD_EFFECT_KIND_INFO = {
+	particles: {
+		description: "Continuous particles emitted inside the effect frame.",
+		parameters: {
+			rate: "Particles per second.",
+			life: "Particle lifetime in milliseconds.",
+			particleSize: "Particle size in board units.",
+			speed: "Particle speed in board units per second.",
+			direction: "Emission direction in degrees.",
+			spread: "Emission spread in degrees.",
+			gravity: "Acceleration in board units per second squared.",
+			intensity: "Opacity and size multiplier.",
+			seed: "Stable seed for repeatable particle motion."
+		}
+	},
+	trail: {
+		description: "A fading trail following another item.",
+		parameters: {
+			follow: "ID of the item to follow.",
+			life: "Trail lifetime in milliseconds.",
+			particleSize: "Trail width in board units.",
+			intensity: "Opacity multiplier."
+		}
+	},
+	impact: {
+		description: "A repeating radial burst centered in the effect frame.",
+		parameters: {
+			rate: "Particles per burst.",
+			life: "Time between bursts in milliseconds.",
+			particleSize: "Particle and ring size in board units.",
+			speed: "Particle speed in board units per second.",
+			direction: "Burst direction in degrees.",
+			spread: "Burst spread in degrees.",
+			gravity: "Acceleration in board units per second squared.",
+			intensity: "Opacity multiplier.",
+			seed: "Stable seed for repeatable bursts."
+		}
+	},
+	flash: {
+		description: "A repeating full-frame flash.",
+		parameters: {
+			life: "Time between flashes in milliseconds.",
+			intensity: "Flash opacity multiplier."
+		}
+	},
+	glow: {
+		description: "A pulsing set of concentric rings.",
+		parameters: {
+			life: "Pulse period in milliseconds.",
+			intensity: "Glow opacity multiplier."
+		}
+	}
+};
+const BoardEffectItemSchema = z.object({
+	...boxed(240, 240),
+	type: z.literal("effect"),
+	props: z.object({
+		kind: z.enum(BOARD_EFFECT_KINDS),
+		rate: nonNegative.max(2e4).default(40),
+		life: finite.positive().max(6e4).default(1200),
+		particleSize: finite.positive().max(512).default(6),
+		speed: nonNegative.max(1e4).default(120),
+		direction: finite.default(-90),
+		spread: finite.min(0).max(360).default(360),
+		gravity: finite.default(0),
+		intensity: nonNegative.max(10).default(1),
+		follow: BoardIdSchema.optional(),
+		seed: z.string().min(1).max(160).optional()
+	}).strict()
+}).strict();
+const BoardSketchItemSchema = z.object({
+	...boxed(480, 320),
+	type: z.literal("sketch"),
+	props: z.object({
+		src: srcSchema.refine((path) => /\.m?js$/.test(path), "sketch src must be a .js or .mjs module"),
+		params: z.record(z.string(), z.unknown()).default({}),
+		seed: z.string().min(1).max(160).optional()
+	}).strict()
+}).strict();
+const BOARD_EXTENSION_TYPE_PATTERN = /^[a-z][a-z0-9]*(?:\.[a-z0-9-]+)+$/;
+const BoardExtensionItemSchema = z.object({
+	...itemEnvelope,
+	size: BoardSizeSchema.default({
+		width: 240,
+		height: 160
+	}),
+	type: z.string().regex(BOARD_EXTENSION_TYPE_PATTERN),
+	props: z.record(z.string(), z.unknown()).default({})
+}).strict();
+const BOARD_ITEM_SCHEMAS = {
+	frame: BoardFrameItemSchema,
+	text: BoardTextItemSchema,
+	shape: BoardShapeItemSchema,
+	draw: BoardDrawItemSchema,
+	arrow: BoardArrowItemSchema,
+	image: BoardImageItemSchema,
+	video: BoardVideoItemSchema,
+	audio: BoardAudioItemSchema,
+	file: BoardFileItemSchema,
+	task: BoardTaskItemSchema,
+	effect: BoardEffectItemSchema,
+	sketch: BoardSketchItemSchema
+};
+const BOARD_ITEM_TYPES = Object.keys(BOARD_ITEM_SCHEMAS);
+function isBuiltinItemType(type) {
+	return Object.hasOwn(BOARD_ITEM_SCHEMAS, type);
+}
+function isBuiltinItem(item) {
+	return isBuiltinItemType(item.type);
+}
+function isFileBackedItem(item) {
+	return item.type === "image" || item.type === "video" || item.type === "audio" || item.type === "file";
+}
+function isMediaItem(item) {
+	return item.type === "image" || item.type === "video" || item.type === "audio";
+}
+const BOARD_DERIVED_SIZE_TYPES = [
+	"text",
+	"draw",
+	"arrow"
+];
+function hasAuthoredSize(type) {
+	return !BOARD_DERIVED_SIZE_TYPES.includes(type);
+}
+function boardItemSchema(type) {
+	if (isBuiltinItemType(type)) return BOARD_ITEM_SCHEMAS[type];
+	return BOARD_EXTENSION_TYPE_PATTERN.test(type) ? BoardExtensionItemSchema : null;
+}
+function issuesToDiagnostics(error, path) {
+	return error.issues.map((issue) => {
+		return {
+			severity: "error",
+			code: "INVALID_ITEM",
+			path: [path, ...issue.path.map(String)].filter(Boolean).join("."),
+			message: issue.code === "unrecognized_keys" ? `unknown ${issue.keys.length === 1 ? "property" : "properties"} ${issue.keys.join(", ")}` : issue.message
+		};
+	});
+}
+function parseBoardItem(value, path = "item") {
+	const type = value && typeof value === "object" && !Array.isArray(value) ? value.type : void 0;
+	if (typeof type !== "string") return {
+		ok: false,
+		diagnostics: [{
+			severity: "error",
+			code: "INVALID_ITEM",
+			path: `${path}.type`,
+			message: "type is required"
+		}]
+	};
+	const schema = boardItemSchema(type);
+	if (!schema) return {
+		ok: false,
+		diagnostics: [{
+			severity: "error",
+			code: "INVALID_ITEM",
+			path: `${path}.type`,
+			message: `unknown type ${type}; expected ${BOARD_ITEM_TYPES.join(", ")} or a namespaced extension type`
+		}]
+	};
+	const parsed = schema.safeParse(value);
+	return parsed.success ? {
+		ok: true,
+		item: parsed.data
+	} : {
+		ok: false,
+		diagnostics: issuesToDiagnostics(parsed.error, path)
+	};
+}
+const CSS_EASE_KEYWORDS = /* @__PURE__ */ new Set([
+	"linear",
+	"ease",
+	"ease-in",
+	"ease-out",
+	"ease-in-out",
+	"step-start",
+	"step-end"
+]);
+function isBoardEase(value) {
+	const ease = value.trim();
+	if (CSS_EASE_KEYWORDS.has(ease)) return true;
+	const bezier = /^cubic-bezier\(\s*([^,()]+),\s*([^,()]+),\s*([^,()]+),\s*([^,()]+)\)$/.exec(ease);
+	if (bezier) {
+		const [x1, , x2] = bezier.slice(1).map(Number);
+		return bezier.slice(1).every((part) => Number.isFinite(Number(part))) && x1 >= 0 && x1 <= 1 && x2 >= 0 && x2 <= 1;
+	}
+	return /^steps\(\s*[1-9]\d*\s*(?:,\s*(?:start|end|jump-start|jump-end|jump-none|jump-both)\s*)?\)$/.test(ease);
+}
+const BoardEaseSchema = z.string().max(120).refine(isBoardEase, "expected a CSS easing: linear, ease-in-out, cubic-bezier(…) or steps(…)");
+const BoardKeyframeSchema = z.object({
+	at: nonNegative,
+	value: z.unknown(),
+	ease: BoardEaseSchema.optional()
+}).strict();
+const BoardTrackSchema = z.object({
+	target: z.string().min(1).max(160),
+	property: z.string().min(1).max(200),
+	keyframes: z.array(BoardKeyframeSchema).min(1).max(1e5),
+	composite: z.enum(["replace", "add"]).default("replace"),
+	interpolation: z.enum([
+		"auto",
+		"step",
+		"spline"
+	]).default("auto"),
+	orient: z.boolean().optional()
+}).strict().superRefine((track, context) => {
+	for (let index = 1; index < track.keyframes.length; index += 1) if ((track.keyframes[index]?.at ?? 0) < (track.keyframes[index - 1]?.at ?? 0)) context.addIssue({
+		code: "custom",
+		message: "keyframes must be ordered by at",
+		path: [
+			"keyframes",
+			index,
+			"at"
+		]
+	});
+});
+const BoardMarkerSchema = z.object({
+	at: nonNegative,
+	label: z.string().max(280).optional(),
+	pause: z.boolean().optional()
+}).strict();
+const BOARD_PLAY_MODES = [
+	"manual",
+	"auto",
+	"always"
+];
+const BoardAnimationHeaderSchema = z.object({
+	name: z.string().max(280).optional(),
+	duration: finite.positive().max(864e5),
+	play: z.enum(BOARD_PLAY_MODES).default("manual"),
+	delay: nonNegative.default(0),
+	loop: z.boolean().default(false),
+	end: z.enum(["hold", "reset"]).default("hold"),
+	markers: z.array(BoardMarkerSchema).max(1e4).default([])
+}).strict();
+const BoardAnimationSchema = BoardAnimationHeaderSchema.extend({ tracks: z.record(BoardIdSchema, BoardTrackSchema).default({}) }).strict();
+const BOARD_ENTER_PRESETS = [
+	"fade-in",
+	"rise",
+	"drop",
+	"pop",
+	"deal"
+];
+const BoardBackgroundSchema = z.object({
+	kind: z.enum([
+		"solid",
+		"dots",
+		"grid",
+		"image"
+	]).default("dots"),
+	color: BoardColorSchema.optional(),
+	imageUrl: z.string().url().max(4096).optional(),
+	fit: z.enum([
+		"cover",
+		"contain",
+		"repeat"
+	]).optional(),
+	opacity: ratio.optional()
+}).strict();
+const BOARD_GRID_MIN_SIZE = 4;
+const BOARD_GRID_MAX_SIZE = 512;
+const BOARD_GRID_DEFAULT_SIZE = 24;
+const BoardSettingsSchema = z.object({
+	title: z.string().min(1).max(255).optional(),
+	background: BoardBackgroundSchema.default({ kind: "dots" }),
+	grid: z.object({
+		visible: z.boolean().default(false),
+		size: finite.min(4).max(512).default(24)
+	}).strict().optional(),
+	enter: z.object({
+		preset: z.enum(BOARD_ENTER_PRESETS),
+		duration: finite.positive().max(1e4).optional()
+	}).strict().optional()
+}).strict();
+function emptyBoardDocument() {
+	return {
+		board: BoardSettingsSchema.parse({}),
+		items: {},
+		animations: {}
+	};
+}
+const patchObject = z.record(z.string(), z.unknown());
+const BoardPatchSchema = z.object({
+	board: patchObject.nullable().optional(),
+	items: z.record(BoardIdSchema, patchObject.nullable()).optional(),
+	animations: z.record(BoardIdSchema, patchObject.and(z.object({ tracks: z.record(BoardIdSchema, patchObject.nullable()).optional() })).nullable()).optional()
+}).strict();
+function isEmptyBoardDelta(delta) {
+	return !delta.board && Object.keys(delta.items ?? {}).length === 0 && Object.keys(delta.animations ?? {}).length === 0 && Object.keys(delta.tracks ?? {}).length === 0;
+}
+//#endregion
+export { 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, BoardDrawItemSchema, BoardDrawPointSchema, BoardEaseSchema, BoardEffectItemSchema, BoardExtensionItemSchema, BoardFileItemSchema, BoardFrameItemSchema, BoardIdSchema, BoardImageItemSchema, BoardKeyframeSchema, BoardMarkerSchema, BoardMediaSnapshotSchema, BoardPatchSchema, BoardSettingsSchema, BoardShapeItemSchema, BoardSizeSchema, BoardSketchItemSchema, BoardStyleSchema, BoardTaskArtifactSchema, BoardTaskItemSchema, BoardTaskSnapshotSchema, BoardTextItemSchema, BoardTrackSchema, BoardVec2Schema, BoardVideoItemSchema, boardItemSchema, emptyBoardDocument, hasAuthoredSize, isBoardColorString, isBoardEase, isBuiltinItem, isBuiltinItemType, isEmptyBoardDelta, isFileBackedItem, isMediaItem, isSafeBoardSourcePath, parseBoardItem };

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

@@ -0,0 +1,86 @@
+import { BoardAnimationHeader, BoardDelta, BoardDiagnostic, BoardDocument, BoardItem, BoardPatch, BoardSettings, BoardTrack, BoardVec2 } from "./board-model.js";
+import { z } from "zod";
+//#region ../protocol/dist/board-patch.d.ts
+declare function mergePatch(target: unknown, patch: unknown): unknown;
+declare function diffMergePatch(before: unknown, after: unknown): unknown;
+type BoardValueKind = "number" | "vec2" | "scale" | "color" | "discrete";
+type BoardPropertySpec = {
+  kind: BoardValueKind;
+  schema: z.ZodType;
+  multiplicative?: boolean;
+};
+declare function resolveBoardProperty(targetType: string, property: string): {
+  ok: true;
+  spec: BoardPropertySpec;
+} | {
+  ok: false;
+  message: string;
+};
+declare function listBoardProperties(targetType: string): Array<{
+  property: string;
+  kind: BoardValueKind;
+}>;
+type BoardState = {
+  settings(): BoardSettings;
+  item(id: string): BoardItem | undefined;
+  animation(id: string): BoardAnimationHeader | undefined;
+  track(animationId: string, trackId: string): BoardTrack | undefined;
+  trackIds(animationId: string): string[];
+  children(id: string): string[];
+  binders(id: string): string[];
+  trackRefs(id: string): Array<{
+    animation: string;
+    track: string;
+  }>;
+  maxZ(parent: string | undefined): number;
+};
+declare function trackReferences(track: BoardTrack): string[];
+declare function pruneBoardTrack(track: BoardTrack, deleted: ReadonlySet<string>): BoardTrack | null;
+declare function boardPatchTouches(patch: BoardPatch): {
+  items: string[];
+  animations: string[];
+  tracks: Array<{
+    animation: string;
+    track: string;
+  }>;
+  deletedItems: string[];
+  deletedAnimations: string[];
+  parents: string[];
+  references: string[];
+};
+type BoardApplyOptions = {
+  cascade?: boolean;
+  resolveArrowEnd?: (arrowId: string, which: "start" | "end") => BoardVec2;
+};
+type BoardPatchResult = {
+  ok: true;
+  before: BoardDelta;
+  after: BoardDelta;
+  diagnostics: BoardDiagnostic[];
+} | {
+  ok: false;
+  diagnostics: BoardDiagnostic[];
+};
+declare function applyBoardPatch(state: BoardState, input: BoardPatch, options?: BoardApplyOptions): BoardPatchResult;
+declare function createDocumentState(document: BoardDocument): BoardState;
+declare function applyBoardDelta(document: BoardDocument, delta: BoardDelta): BoardDocument;
+declare function applyBoardPatchToDocument(document: BoardDocument, patch: BoardPatch, options?: BoardApplyOptions): {
+  ok: true;
+  document: BoardDocument;
+  before: BoardDelta;
+  after: BoardDelta;
+} | {
+  ok: false;
+  diagnostics: BoardDiagnostic[];
+};
+declare function diffBoardDocuments(before: BoardDocument, after: BoardDocument): BoardPatch;
+declare function isEmptyBoardPatch(patch: BoardPatch): boolean;
+declare function parseBoardDocument(input: unknown): {
+  ok: true;
+  document: BoardDocument;
+} | {
+  ok: false;
+  diagnostics: BoardDiagnostic[];
+};
+//#endregion
+export { BoardApplyOptions, BoardPatchResult, BoardPropertySpec, BoardState, BoardValueKind, applyBoardDelta, applyBoardPatch, applyBoardPatchToDocument, boardPatchTouches, createDocumentState, diffBoardDocuments, diffMergePatch, isEmptyBoardPatch, listBoardProperties, mergePatch, parseBoardDocument, pruneBoardTrack, resolveBoardProperty, trackReferences };