@neta-art/cohub 5.10.0 → 7.0.0

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

@@ -0,0 +1,291 @@
+import "./board-constants.js";
+import { BoardConnectionPatchSchema, BoardConnectionSchema } from "./board-connection.js";
+import { BoardCompositionInputSchema } from "./board-composition.js";
+import { BoardEffectInputSchema } from "./board-effect.js";
+import { z } from "zod";
+//#region ../protocol/dist/board-authoring.js
+const BOARD_AUTHORING_COLOR_IDS = [
+	"brand",
+	"neutral",
+	"black",
+	"white",
+	"blue",
+	"green",
+	"amber",
+	"violet",
+	"rose"
+];
+const BOARD_AUTHORING_GEO_KINDS = [
+	"rectangle",
+	"rounded",
+	"ellipse",
+	"diamond",
+	"triangle"
+];
+const idSchema = z.string().min(1).max(160);
+const jsonObjectSchema = z.record(z.string(), z.unknown());
+const finiteSchema = z.number().finite();
+const extensionTypeSchema = z.string().regex(/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)+$/).max(160);
+const BoardAuthoringFrameSchema = z.object({
+	x: finiteSchema,
+	y: finiteSchema,
+	width: finiteSchema.positive(),
+	height: finiteSchema.positive(),
+	rotation: finiteSchema.default(0)
+}).strict();
+const pointSchema = z.object({
+	x: finiteSchema,
+	y: finiteSchema,
+	p: finiteSchema.min(0).max(1).default(.5)
+}).strict();
+const worldPointSchema = z.object({
+	x: finiteSchema,
+	y: finiteSchema
+}).strict();
+const cropSchema = z.object({
+	x: finiteSchema.min(0).max(1),
+	y: finiteSchema.min(0).max(1),
+	w: finiteSchema.min(0).max(1),
+	h: finiteSchema.min(0).max(1)
+}).strict();
+const BoardItemStyleSchema = z.object({
+	color: z.enum(BOARD_AUTHORING_COLOR_IDS).optional(),
+	strokeWidth: finiteSchema.min(1).max(64).optional(),
+	fillOpacity: finiteSchema.min(0).max(1).optional()
+}).strict();
+const sourceSnapshotSchema = z.record(z.string(), z.unknown());
+function isSafeBoardSourcePath(value) {
+	return value.length > 0 && value.length <= 4096 && !value.startsWith("/") && !value.startsWith("\\") && !value.includes("\\") && value.split("/").every((part) => part.length > 0 && part !== "." && part !== "..");
+}
+const BoardItemSourceSchema = z.object({
+	kind: z.literal("space-file"),
+	path: z.string().refine(isSafeBoardSourcePath, "source path must be a safe relative Board file path"),
+	snapshot: sourceSnapshotSchema.optional()
+}).strict();
+const baseFields = {
+	id: idSchema,
+	frame: BoardAuthoringFrameSchema,
+	parentId: idSchema.nullable().optional(),
+	locked: z.boolean().optional(),
+	metadata: jsonObjectSchema.optional()
+};
+const styledBaseFields = {
+	...baseFields,
+	style: BoardItemStyleSchema.optional()
+};
+const BoardTextAuthoringItemSchema = z.object({
+	...styledBaseFields,
+	type: z.literal("text"),
+	props: z.object({
+		text: z.string().default(""),
+		fontSize: finiteSchema.min(2).max(512).default(24)
+	}).strict()
+}).strict();
+const BoardGeoAuthoringItemSchema = z.object({
+	...styledBaseFields,
+	type: z.literal("geo"),
+	props: z.object({
+		shape: z.enum(BOARD_AUTHORING_GEO_KINDS).default("rectangle"),
+		text: z.string().default("")
+	}).strict()
+}).strict();
+const BoardDrawAuthoringItemSchema = z.object({
+	...styledBaseFields,
+	type: z.literal("draw"),
+	props: z.object({ points: z.array(pointSchema).min(1) }).strict()
+}).strict();
+const BoardArrowAuthoringItemSchema = z.object({
+	...styledBaseFields,
+	type: z.literal("arrow"),
+	props: z.object({
+		start: worldPointSchema,
+		end: worldPointSchema,
+		bend: finiteSchema.min(-.85).max(.85).default(0),
+		arrowStart: z.boolean().default(false),
+		arrowEnd: z.boolean().default(true),
+		label: z.string().default("")
+	}).strict()
+}).strict();
+const BoardFrameAuthoringItemSchema = z.object({
+	...styledBaseFields,
+	type: z.literal("frame"),
+	props: z.object({ label: z.string().default("Frame") }).strict()
+}).strict();
+const fileBackedFields = {
+	...baseFields,
+	style: z.object({}).strict().optional(),
+	source: BoardItemSourceSchema
+};
+const BoardImageAuthoringItemSchema = z.object({
+	...fileBackedFields,
+	type: z.literal("image"),
+	props: z.object({ crop: cropSchema.optional() }).strict()
+}).strict();
+const BoardVideoAuthoringItemSchema = z.object({
+	...fileBackedFields,
+	type: z.literal("video"),
+	props: z.object({}).strict()
+}).strict();
+const BoardAudioAuthoringItemSchema = z.object({
+	...fileBackedFields,
+	type: z.literal("audio"),
+	props: z.object({}).strict()
+}).strict();
+const BoardFileAuthoringItemSchema = z.object({
+	...fileBackedFields,
+	type: z.literal("file"),
+	props: z.object({}).strict()
+}).strict();
+const BoardTaskAuthoringItemSchema = z.object({
+	...baseFields,
+	type: z.literal("task"),
+	props: z.object({
+		taskRunId: z.string().min(1),
+		snapshot: z.record(z.string(), z.unknown())
+	}).strict(),
+	style: z.object({}).strict().optional()
+}).strict();
+const builtinItemSchemas = [
+	BoardTextAuthoringItemSchema,
+	BoardGeoAuthoringItemSchema,
+	BoardDrawAuthoringItemSchema,
+	BoardArrowAuthoringItemSchema,
+	BoardFrameAuthoringItemSchema,
+	BoardImageAuthoringItemSchema,
+	BoardVideoAuthoringItemSchema,
+	BoardAudioAuthoringItemSchema,
+	BoardFileAuthoringItemSchema,
+	BoardTaskAuthoringItemSchema
+];
+const BoardBuiltinAuthoringItemSchema = z.discriminatedUnion("type", builtinItemSchemas);
+const BoardExtensionAuthoringItemSchema = z.object({
+	...baseFields,
+	type: extensionTypeSchema,
+	kindVersion: z.number().int().positive(),
+	props: jsonObjectSchema,
+	style: jsonObjectSchema.optional(),
+	source: z.object({
+		kind: z.string().min(1).max(80),
+		ref: z.string().min(1).max(4096),
+		snapshot: jsonObjectSchema.optional()
+	}).strict().optional()
+}).strict();
+const BoardAuthoringItemSchema = z.union([BoardBuiltinAuthoringItemSchema, BoardExtensionAuthoringItemSchema]);
+const framePatchSchema = z.object({
+	x: finiteSchema.optional(),
+	y: finiteSchema.optional(),
+	width: finiteSchema.positive().optional(),
+	height: finiteSchema.positive().optional(),
+	rotation: finiteSchema.optional()
+}).strict();
+/** JSON Merge Patch semantics, constrained to the stable Item envelope. */
+const BoardItemPatchSchema = z.object({
+	frame: framePatchSchema.optional(),
+	parentId: idSchema.nullable().optional(),
+	locked: z.boolean().nullable().optional(),
+	props: jsonObjectSchema.optional(),
+	style: jsonObjectSchema.nullable().optional(),
+	source: jsonObjectSchema.nullable().optional(),
+	metadata: jsonObjectSchema.nullable().optional()
+}).strict().refine((patch) => Object.keys(patch).length > 0, "item patch is empty");
+const BoardConnectionInputSchema = BoardConnectionSchema;
+const stripServerFields = (value) => {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+	const { boardId: _boardId, revision: _revision, ...input } = value;
+	return input;
+};
+const BoardEffectCommandInputSchema = z.preprocess(stripServerFields, BoardEffectInputSchema);
+const BoardCompositionCommandInputSchema = z.preprocess(stripServerFields, BoardCompositionInputSchema);
+const BoardSemanticCommandSchema = z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal("board.patch"),
+		patch: z.object({
+			title: z.string().min(1).max(255).optional(),
+			metadata: jsonObjectSchema.nullable().optional(),
+			metadataPatch: jsonObjectSchema.optional()
+		}).strict().refine((patch) => Object.keys(patch).length > 0, "board patch is empty")
+	}).strict(),
+	z.object({
+		type: z.literal("item.create"),
+		item: BoardAuthoringItemSchema
+	}).strict(),
+	z.object({
+		type: z.literal("item.patch"),
+		itemId: idSchema,
+		patch: BoardItemPatchSchema
+	}).strict(),
+	z.object({
+		type: z.literal("item.replace"),
+		itemId: idSchema,
+		item: BoardAuthoringItemSchema
+	}).strict(),
+	z.object({
+		type: z.literal("item.delete"),
+		itemId: idSchema,
+		cascade: z.boolean().default(false)
+	}).strict(),
+	z.object({
+		type: z.literal("item.reorder"),
+		itemId: idSchema,
+		index: z.number().int().nonnegative()
+	}).strict(),
+	z.object({
+		type: z.literal("connection.create"),
+		connection: BoardConnectionInputSchema
+	}).strict(),
+	z.object({
+		type: z.literal("connection.patch"),
+		connectionId: idSchema,
+		patch: BoardConnectionPatchSchema
+	}).strict(),
+	z.object({
+		type: z.literal("connection.delete"),
+		connectionId: idSchema
+	}).strict(),
+	z.object({
+		type: z.literal("effect.apply"),
+		effect: BoardEffectCommandInputSchema
+	}).strict(),
+	z.object({
+		type: z.literal("effect.delete"),
+		effectId: idSchema
+	}).strict(),
+	z.object({
+		type: z.literal("composition.apply"),
+		composition: BoardCompositionCommandInputSchema
+	}).strict(),
+	z.object({
+		type: z.literal("composition.delete"),
+		compositionId: idSchema
+	}).strict()
+]);
+const BoardSemanticMutationSchema = z.object({
+	mutationId: idSchema,
+	baseVersion: z.number().int().nonnegative(),
+	clientId: idSchema.optional(),
+	undoGroupId: idSchema.optional(),
+	/** Validate (including server-side reference checks) without writing. */
+	dryRun: z.boolean().default(false),
+	commands: z.array(BoardSemanticCommandSchema).min(1).max(5e4)
+}).strict();
+z.object({
+	include: z.array(z.enum([
+		"items",
+		"connections",
+		"effects",
+		"compositions",
+		"playback"
+	])).optional(),
+	itemIds: z.array(idSchema).max(5e4).optional(),
+	connectionIds: z.array(idSchema).max(5e4).optional(),
+	effectIds: z.array(idSchema).max(5e4).optional(),
+	compositionIds: z.array(idSchema).max(5e4).optional(),
+	viewport: z.object({
+		x: finiteSchema,
+		y: finiteSchema,
+		width: finiteSchema.positive(),
+		height: finiteSchema.positive()
+	}).optional()
+}).strict();
+//#endregion
+export { BOARD_AUTHORING_COLOR_IDS, BOARD_AUTHORING_GEO_KINDS, BoardArrowAuthoringItemSchema, BoardAudioAuthoringItemSchema, BoardAuthoringItemSchema, BoardBuiltinAuthoringItemSchema, BoardDrawAuthoringItemSchema, BoardExtensionAuthoringItemSchema, BoardFileAuthoringItemSchema, BoardFrameAuthoringItemSchema, BoardGeoAuthoringItemSchema, BoardImageAuthoringItemSchema, BoardItemPatchSchema, BoardItemSourceSchema, BoardItemStyleSchema, BoardSemanticCommandSchema, BoardSemanticMutationSchema, BoardTaskAuthoringItemSchema, BoardTextAuthoringItemSchema, BoardVideoAuthoringItemSchema, isSafeBoardSourcePath };

package/dist/protocol/dist/board-capability-registry.d.ts

@@ -0,0 +1,2 @@
+import "./board-composition.js";
+import "./board.js";

package/dist/protocol/dist/board-capability-registry.js

@@ -0,0 +1,74 @@
+import { BOARD_BUILTIN_CLIP_KINDS, BOARD_BUILTIN_EFFECT_KINDS, DEFAULT_BOARD_RENDER_LIMITS } from "./board-constants.js";
+import { BoardCameraFocusParamsSchema } from "./board.js";
+//#region ../protocol/dist/board-capability-registry.js
+const CLIPS = new Set(BOARD_BUILTIN_CLIP_KINDS);
+new Set(BOARD_BUILTIN_EFFECT_KINDS);
+const record = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
+const finite = (value) => typeof value === "number" && Number.isFinite(value);
+function validateBuiltinBoardClip(clip, path = "clip") {
+	if (!CLIPS.has(clip.kind)) return [];
+	const errors = [];
+	const error = (message, suffix, coordinateSpace, code = "INVALID_BOARD_CLIP") => {
+		errors.push({
+			severity: "error",
+			code,
+			message,
+			path: `${path}.${suffix}`,
+			...coordinateSpace ? { coordinateSpace } : {}
+		});
+	};
+	if ((clip.kind.startsWith("motion.") || clip.kind.startsWith("draw.") || clip.kind === "text.reveal" || clip.kind === "effects.trail") && clip.target.type !== "item") error(`${clip.kind} must target an item`, "target");
+	if (clip.kind.startsWith("camera.") && clip.target.type !== "camera") error(`${clip.kind} must target the camera`, "target");
+	if (clip.kind === "motion.path") {
+		const points = clip.params.points;
+		if (!Array.isArray(points) || points.length < 2 || points.length > 1e4) error("motion path must contain 2 to 10000 world-offset points", "params.points", "world-offset");
+		else for (const [index, point] of points.entries()) if (!record(point) || !finite(point.x) || !finite(point.y)) error("motion path point must contain finite x and y", `params.points.${index}`, "world-offset");
+	}
+	if (clip.kind === "effects.particles") {
+		const count = clip.params.count;
+		if (!Number.isSafeInteger(count) || count < 1 || count > DEFAULT_BOARD_RENDER_LIMITS.particles) error(`particle count must be an integer from 1 to ${DEFAULT_BOARD_RENDER_LIMITS.particles}`, "params.count", void 0, "INVALID_PARTICLE_COUNT");
+		const bounds = clip.params.bounds;
+		if (!record(bounds) || !finite(bounds.x) || !finite(bounds.y) || !finite(bounds.width) || !finite(bounds.height) || bounds.width <= 0 || bounds.height <= 0) error("particles require positive finite world bounds", "params.bounds", "world", "PARTICLE_BOUNDS_REQUIRED");
+	}
+	if (clip.kind === "camera.focus") {
+		const parsed = BoardCameraFocusParamsSchema.safeParse(clip.params);
+		if (!parsed.success) error(parsed.error.issues[0]?.message ?? "invalid camera focus", "params", "world");
+	}
+	return errors;
+}
+function estimateBuiltinBoardClipCost(clip) {
+	switch (clip.kind) {
+		case "effects.particles": {
+			const count = Number.isSafeInteger(clip.params.count) ? Math.max(0, clip.params.count) : 0;
+			return {
+				particles: count,
+				vertices: count * 4,
+				dynamicVertices: count * 4,
+				drawCalls: 1,
+				bufferBytes: count * 48,
+				simulationSteps: count
+			};
+		}
+		case "effects.trail": return {
+			vertices: 32,
+			dynamicVertices: 32,
+			drawCalls: 1,
+			bufferBytes: 1024,
+			simulationSteps: 16
+		};
+		case "effects.impact":
+		case "effects.flash": return {
+			vertices: 64,
+			drawCalls: 1
+		};
+		case "draw.reveal":
+		case "draw.handwrite": return {
+			drawCalls: 1,
+			dynamicVertices: 1
+		};
+		case "motion.path": return { simulationSteps: Array.isArray(clip.params.points) ? clip.params.points.length : 0 };
+		default: return {};
+	}
+}
+//#endregion
+export { estimateBuiltinBoardClipCost, validateBuiltinBoardClip };

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

@@ -0,0 +1,2 @@
+import "./board-authoring.js";
+import "./board.js";

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

@@ -0,0 +1,19 @@
+import { BoardAuthoringItemSchema, BoardItemPatchSchema } from "./board-authoring.js";
+//#region ../protocol/dist/board-codec.js
+const isRecord = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
+function applyBoardItemPatch(current, value) {
+	const merged = mergePatch(current, BoardItemPatchSchema.parse(value));
+	merged.id = current.id;
+	merged.type = current.type;
+	if ("kindVersion" in current) merged.kindVersion = current.kindVersion;
+	return BoardAuthoringItemSchema.parse(merged);
+}
+function mergePatch(current, patch) {
+	if (!isRecord(patch)) return patch;
+	const result = isRecord(current) ? { ...current } : {};
+	for (const [key, value] of Object.entries(patch)) if (value === null) delete result[key];
+	else result[key] = isRecord(value) ? mergePatch(result[key], value) : value;
+	return result;
+}
+//#endregion
+export { applyBoardItemPatch };