@neta-art/cohub 8.24.0 → 9.0.1

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

@@ -1,302 +0,0 @@
-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 BoardAuthoringPositionSchema = z.object({
-	x: finiteSchema,
-	y: finiteSchema
-}).strict();
-const BoardAuthoringSizeSchema = z.object({
-	width: finiteSchema.positive(),
-	height: finiteSchema.positive()
-}).strict();
-const BoardAuthoringPositionPatchSchema = z.object({
-	x: finiteSchema.optional(),
-	y: finiteSchema.optional()
-}).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 sizedBaseFields = {
-	id: idSchema,
-	position: BoardAuthoringPositionSchema.default({
-		x: 0,
-		y: 0
-	}),
-	rotation: finiteSchema.default(0),
-	parentId: idSchema.nullable().optional(),
-	locked: z.boolean().optional(),
-	metadata: jsonObjectSchema.optional(),
-	size: BoardAuthoringSizeSchema.optional()
-};
-const styledBaseFields = {
-	...sizedBaseFields,
-	style: BoardItemStyleSchema.optional()
-};
-const { position: _positionField, size: _sizeField, ...strokeBaseFields } = sizedBaseFields;
-const strokeStyledBaseFields = {
-	...strokeBaseFields,
-	rotation: z.literal(0).default(0),
-	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({
-	...strokeStyledBaseFields,
-	type: z.literal("draw"),
-	props: z.object({ points: z.array(pointSchema).min(1) }).strict()
-}).strict();
-const BoardArrowAuthoringItemSchema = z.object({
-	...strokeStyledBaseFields,
-	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 = {
-	...sizedBaseFields,
-	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({
-	...sizedBaseFields,
-	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({
-	...sizedBaseFields,
-	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]);
-/** JSON Merge Patch semantics, constrained to the stable Item envelope. */
-const BoardItemPatchSchema = z.object({
-	position: BoardAuthoringPositionPatchSchema.optional(),
-	size: BoardAuthoringSizeSchema.nullable().optional(),
-	rotation: finiteSchema.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

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

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

@@ -1,123 +0,0 @@
-import { BOARD_BUILTIN_CAPABILITIES, BOARD_BUILTIN_CLIP_KINDS, BOARD_BUILTIN_EFFECT_KINDS, DEFAULT_BOARD_RENDER_LIMITS } from "./board-constants.js";
-import { BoardCameraFocusParamsSchema } from "./board.js";
-import { BoardDealParamsSchema } from "./board-animation.js";
-//#region ../protocol/dist/board-capability-registry.js
-const CLIPS = new Set(BOARD_BUILTIN_CLIP_KINDS);
-const EFFECTS = new Set(BOARD_BUILTIN_EFFECT_KINDS);
-const BUILTIN_VERSIONS = new Set(BOARD_BUILTIN_CAPABILITIES.map((c) => `${c.kind}:${c.id}@${c.version}`));
-/**
-* True when a built-in renderer exists for exactly this kind@version. A known
-* kind at an unknown version is not built-in: it must not pass as one.
-*/
-function isBuiltinBoardCapability(kind, id, version) {
-	return BUILTIN_VERSIONS.has(`${kind}:${id}@${version}`);
-}
-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 validateBuiltinBoardEffect(effect, path = "effect") {
-	const diagnostics = [];
-	if (effect.lifecycle === "on-enter") {
-		if (effect.target.type !== "item") diagnostics.push({
-			severity: "error",
-			code: "INVALID_BOARD_EFFECT",
-			message: "on-enter effects must target an item",
-			path: `${path}.target`
-		});
-		if (effect.timeOrigin !== "activation") diagnostics.push({
-			severity: "error",
-			code: "INVALID_BOARD_EFFECT",
-			message: "on-enter effects must use activation time",
-			path: `${path}.timeOrigin`
-		});
-	} else if (EFFECTS.has(effect.kind) && effect.target.type !== "item") diagnostics.push({
-		severity: "error",
-		code: "INVALID_BOARD_EFFECT",
-		message: `${effect.kind} must target an item`,
-		path: `${path}.target`
-	});
-	if (effect.kind === "effects.deal" && effect.kindVersion === 1) {
-		if (effect.lifecycle !== "on-enter") diagnostics.push({
-			severity: "error",
-			code: "INVALID_BOARD_EFFECT",
-			message: "effects.deal must use the on-enter lifecycle",
-			path: `${path}.lifecycle`
-		});
-		const parsed = BoardDealParamsSchema.safeParse(effect.params);
-		if (!parsed.success) diagnostics.push({
-			severity: "error",
-			code: "INVALID_BOARD_EFFECT",
-			message: parsed.error.issues[0]?.message ?? "invalid effects.deal parameters",
-			path: `${path}.params`
-		});
-	}
-	return diagnostics;
-}
-function estimateBuiltinBoardEffectCost(effect) {
-	return isBuiltinBoardCapability("effect", effect.kind, effect.kindVersion) ? { drawCalls: 1 } : {};
-}
-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": 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, estimateBuiltinBoardEffectCost, isBuiltinBoardCapability, validateBuiltinBoardClip, validateBuiltinBoardEffect };

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

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