@neta-art/cohub 5.9.0 → 6.0.0

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

@@ -0,0 +1,217 @@
+import "./board-constants.js";
+import { z } from "zod";
+//#region ../protocol/dist/board-authoring.js
+const BOARD_COLOR_IDS = [
+	"brand",
+	"neutral",
+	"black",
+	"white",
+	"blue",
+	"green",
+	"amber",
+	"violet",
+	"rose"
+];
+const BOARD_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_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_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 BoardSemanticCommandSchema = z.discriminatedUnion("type", [
+	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({
+	mutationId: idSchema,
+	baseVersion: z.number().int().nonnegative(),
+	clientId: idSchema.optional(),
+	undoGroupId: idSchema.optional(),
+	commands: z.array(BoardSemanticCommandSchema).min(1).max(5e4)
+}).strict();
+//#endregion
+export { BoardArrowAuthoringItemSchema, BoardAudioAuthoringItemSchema, BoardAuthoringItemSchema, BoardBuiltinAuthoringItemSchema, BoardDrawAuthoringItemSchema, BoardExtensionAuthoringItemSchema, BoardFileAuthoringItemSchema, BoardFrameAuthoringItemSchema, BoardGeoAuthoringItemSchema, BoardImageAuthoringItemSchema, BoardItemPatchSchema, BoardItemSourceSchema, BoardItemStyleSchema, BoardSemanticCommandSchema, 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.js";
+import "./board-authoring.js";

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

@@ -0,0 +1,4 @@
+import "./board-authoring.js";
+import "./board.js";
+import "./board-node.js";
+export {};

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

@@ -0,0 +1,258 @@
+import { z } from "zod";
+//#region ../protocol/dist/board-composition.d.ts
+declare const BoardEasingSchema: z.ZodEnum<{
+  "ease-in-cubic": "ease-in-cubic";
+  "ease-in-out-cubic": "ease-in-out-cubic";
+  "ease-in-out-quad": "ease-in-out-quad";
+  "ease-in-quad": "ease-in-quad";
+  "ease-out-cubic": "ease-out-cubic";
+  "ease-out-expo": "ease-out-expo";
+  "ease-out-quad": "ease-out-quad";
+  "ease-out-quart": "ease-out-quart";
+  linear: "linear";
+}>;
+type BoardEasing = z.infer<typeof BoardEasingSchema>;
+declare const BoardAnimationTargetSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"item">;
+  itemId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+  type: z.ZodLiteral<"effect">;
+  effectId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+  type: z.ZodLiteral<"camera">;
+}, z.core.$strict>, z.ZodObject<{
+  type: z.ZodLiteral<"board">;
+}, z.core.$strict>], "type">;
+type BoardAnimationTarget = z.infer<typeof BoardAnimationTargetSchema>;
+type BoardTrackInterpolation = "linear" | "step";
+declare const BoardTrackSchema: z.ZodObject<{
+  id: z.ZodString;
+  target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"item">;
+    itemId: z.ZodString;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"effect">;
+    effectId: z.ZodString;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"camera">;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"board">;
+  }, z.core.$strict>], "type">;
+  channel: z.ZodString;
+  channelVersion: z.ZodDefault<z.ZodNumber>;
+  interpolation: z.ZodDefault<z.ZodEnum<{
+    linear: "linear";
+    step: "step";
+  }>>;
+  fill: z.ZodDefault<z.ZodEnum<{
+    backwards: "backwards";
+    both: "both";
+    forwards: "forwards";
+    none: "none";
+  }>>;
+  keyframes: z.ZodArray<z.ZodObject<{
+    time: z.ZodNumber;
+    value: z.ZodUnknown;
+    easing: z.ZodOptional<z.ZodEnum<{
+      "ease-in-cubic": "ease-in-cubic";
+      "ease-in-out-cubic": "ease-in-out-cubic";
+      "ease-in-out-quad": "ease-in-out-quad";
+      "ease-in-quad": "ease-in-quad";
+      "ease-out-cubic": "ease-out-cubic";
+      "ease-out-expo": "ease-out-expo";
+      "ease-out-quad": "ease-out-quad";
+      "ease-out-quart": "ease-out-quart";
+      linear: "linear";
+    }>>;
+  }, z.core.$strict>>;
+  metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+type BoardTrack = z.infer<typeof BoardTrackSchema>;
+declare const BoardProceduralClipSchema: z.ZodObject<{
+  id: z.ZodString;
+  kind: z.ZodString;
+  kindVersion: z.ZodNumber;
+  target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"item">;
+    itemId: z.ZodString;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"effect">;
+    effectId: z.ZodString;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"camera">;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"board">;
+  }, z.core.$strict>], "type">;
+  start: z.ZodNumber;
+  duration: z.ZodNumber;
+  layer: z.ZodDefault<z.ZodEnum<{
+    behind: "behind";
+    content: "content";
+    front: "front";
+    screen: "screen";
+  }>>;
+  fill: z.ZodDefault<z.ZodEnum<{
+    backwards: "backwards";
+    both: "both";
+    forwards: "forwards";
+    none: "none";
+  }>>;
+  easing: z.ZodDefault<z.ZodEnum<{
+    "ease-in-cubic": "ease-in-cubic";
+    "ease-in-out-cubic": "ease-in-out-cubic";
+    "ease-in-out-quad": "ease-in-out-quad";
+    "ease-in-quad": "ease-in-quad";
+    "ease-out-cubic": "ease-out-cubic";
+    "ease-out-expo": "ease-out-expo";
+    "ease-out-quad": "ease-out-quad";
+    "ease-out-quart": "ease-out-quart";
+    linear: "linear";
+  }>>;
+  params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  assetRefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    type: z.ZodEnum<{
+      extension: "extension";
+      "space-file": "space-file";
+    }>;
+    ref: z.ZodString;
+    digest: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>>;
+  seed: z.ZodString;
+  metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+type BoardProceduralClip = z.infer<typeof BoardProceduralClipSchema>;
+declare const BoardTimelineMarkerSchema: z.ZodObject<{
+  id: z.ZodString;
+  time: z.ZodNumber;
+  duration: z.ZodOptional<z.ZodNumber>;
+  metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+type BoardTimelineMarker = z.infer<typeof BoardTimelineMarkerSchema>;
+declare const BoardCompositionSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  timeline: z.ZodObject<{
+    duration: z.ZodNumber;
+    tracks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"item">;
+        itemId: z.ZodString;
+      }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"effect">;
+        effectId: z.ZodString;
+      }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"camera">;
+      }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"board">;
+      }, z.core.$strict>], "type">;
+      channel: z.ZodString;
+      channelVersion: z.ZodDefault<z.ZodNumber>;
+      interpolation: z.ZodDefault<z.ZodEnum<{
+        linear: "linear";
+        step: "step";
+      }>>;
+      fill: z.ZodDefault<z.ZodEnum<{
+        backwards: "backwards";
+        both: "both";
+        forwards: "forwards";
+        none: "none";
+      }>>;
+      keyframes: z.ZodArray<z.ZodObject<{
+        time: z.ZodNumber;
+        value: z.ZodUnknown;
+        easing: z.ZodOptional<z.ZodEnum<{
+          "ease-in-cubic": "ease-in-cubic";
+          "ease-in-out-cubic": "ease-in-out-cubic";
+          "ease-in-out-quad": "ease-in-out-quad";
+          "ease-in-quad": "ease-in-quad";
+          "ease-out-cubic": "ease-out-cubic";
+          "ease-out-expo": "ease-out-expo";
+          "ease-out-quad": "ease-out-quad";
+          "ease-out-quart": "ease-out-quart";
+          linear: "linear";
+        }>>;
+      }, z.core.$strict>>;
+      metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>>;
+    clips: z.ZodDefault<z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      kind: z.ZodString;
+      kindVersion: z.ZodNumber;
+      target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"item">;
+        itemId: z.ZodString;
+      }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"effect">;
+        effectId: z.ZodString;
+      }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"camera">;
+      }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"board">;
+      }, z.core.$strict>], "type">;
+      start: z.ZodNumber;
+      duration: z.ZodNumber;
+      layer: z.ZodDefault<z.ZodEnum<{
+        behind: "behind";
+        content: "content";
+        front: "front";
+        screen: "screen";
+      }>>;
+      fill: z.ZodDefault<z.ZodEnum<{
+        backwards: "backwards";
+        both: "both";
+        forwards: "forwards";
+        none: "none";
+      }>>;
+      easing: z.ZodDefault<z.ZodEnum<{
+        "ease-in-cubic": "ease-in-cubic";
+        "ease-in-out-cubic": "ease-in-out-cubic";
+        "ease-in-out-quad": "ease-in-out-quad";
+        "ease-in-quad": "ease-in-quad";
+        "ease-out-cubic": "ease-out-cubic";
+        "ease-out-expo": "ease-out-expo";
+        "ease-out-quad": "ease-out-quad";
+        "ease-out-quart": "ease-out-quart";
+        linear: "linear";
+      }>>;
+      params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+      assetRefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+          extension: "extension";
+          "space-file": "space-file";
+        }>;
+        ref: z.ZodString;
+        digest: z.ZodOptional<z.ZodString>;
+      }, z.core.$strict>>>;
+      seed: z.ZodString;
+      metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>>;
+    markers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      time: z.ZodNumber;
+      duration: z.ZodOptional<z.ZodNumber>;
+      metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>>;
+  }, z.core.$strict>;
+  playback: z.ZodDefault<z.ZodObject<{
+    loop: z.ZodDefault<z.ZodBoolean>;
+    endBehavior: z.ZodDefault<z.ZodEnum<{
+      hold: "hold";
+      reset: "reset";
+    }>>;
+    reducedMotion: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      mode: z.ZodLiteral<"base">;
+    }, z.core.$strict>, z.ZodObject<{
+      mode: z.ZodLiteral<"time">;
+      time: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+      mode: z.ZodLiteral<"marker">;
+      markerId: z.ZodString;
+    }, z.core.$strict>], "mode">>;
+  }, z.core.$strict>>;
+  metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  revision: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+type BoardComposition = z.infer<typeof BoardCompositionSchema>;
+//#endregion
+export { BoardAnimationTarget, BoardAnimationTargetSchema, BoardComposition, BoardCompositionSchema, BoardEasing, BoardEasingSchema, BoardProceduralClip, BoardProceduralClipSchema, BoardTimelineMarker, BoardTimelineMarkerSchema, BoardTrack, BoardTrackInterpolation, BoardTrackSchema };