@neta-art/cohub 5.10.0 → 6.0.0

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

@@ -0,0 +1,318 @@
+import { z } from "zod";
+//#region ../protocol/dist/board-composition.js
+const idSchema = z.string().min(1).max(160);
+const finiteSchema = z.number().finite();
+const jsonObjectSchema = z.record(z.string(), z.unknown());
+const BOARD_EASINGS = [
+	"linear",
+	"ease-in-quad",
+	"ease-out-quad",
+	"ease-in-out-quad",
+	"ease-in-cubic",
+	"ease-out-cubic",
+	"ease-in-out-cubic",
+	"ease-out-quart",
+	"ease-out-expo"
+];
+const BoardEasingSchema = z.enum(BOARD_EASINGS);
+const BoardAnimationTargetSchema = z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal("item"),
+		itemId: idSchema
+	}).strict(),
+	z.object({
+		type: z.literal("effect"),
+		effectId: idSchema
+	}).strict(),
+	z.object({ type: z.literal("camera") }).strict(),
+	z.object({ type: z.literal("board") }).strict()
+]);
+const vector2Schema = z.object({
+	x: finiteSchema,
+	y: finiteSchema
+}).strict();
+const scaleSchema = z.union([finiteSchema.positive(), z.object({
+	x: finiteSchema.positive(),
+	y: finiteSchema.positive()
+}).strict()]);
+const BOARD_ANIMATION_CHANNELS = {
+	"transform.translation": {
+		targets: ["item"],
+		value: vector2Schema,
+		interpolations: ["linear", "step"],
+		coordinateSpace: "world-offset",
+		unit: "board"
+	},
+	"transform.rotation": {
+		targets: ["item"],
+		value: finiteSchema,
+		interpolations: ["linear", "step"],
+		unit: "radian"
+	},
+	"transform.scale": {
+		targets: ["item"],
+		value: scaleSchema,
+		interpolations: ["linear", "step"],
+		unit: "ratio"
+	},
+	"style.opacity": {
+		targets: ["item"],
+		value: finiteSchema.min(0).max(1),
+		interpolations: ["linear", "step"],
+		unit: "ratio"
+	}
+};
+const BoardTrackKeyframeSchema = z.object({
+	time: finiteSchema.nonnegative(),
+	value: z.unknown(),
+	easing: BoardEasingSchema.optional()
+}).strict();
+const BoardTrackSchema = z.object({
+	id: idSchema,
+	target: BoardAnimationTargetSchema,
+	channel: z.string().min(1).max(160),
+	channelVersion: z.number().int().positive().default(1),
+	interpolation: z.enum(["linear", "step"]).default("linear"),
+	fill: z.enum([
+		"none",
+		"backwards",
+		"forwards",
+		"both"
+	]).default("none"),
+	keyframes: z.array(BoardTrackKeyframeSchema).min(1).max(1e5),
+	metadata: jsonObjectSchema.default({})
+}).strict().superRefine((track, context) => {
+	let previous = -1;
+	for (const [index, keyframe] of track.keyframes.entries()) {
+		if (keyframe.time <= previous) context.addIssue({
+			code: "custom",
+			message: "keyframe times must be strictly increasing",
+			path: [
+				"keyframes",
+				index,
+				"time"
+			]
+		});
+		previous = keyframe.time;
+	}
+	const channel = BOARD_ANIMATION_CHANNELS[track.channel];
+	if (!channel) {
+		if (!/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+){2,}$/.test(track.channel)) context.addIssue({
+			code: "custom",
+			message: `unknown channel: ${track.channel}`,
+			path: ["channel"]
+		});
+		return;
+	}
+	if (!channel.targets.includes(track.target.type)) context.addIssue({
+		code: "custom",
+		message: `${track.channel} cannot target ${track.target.type}`,
+		path: ["target"]
+	});
+	if (!channel.interpolations.includes(track.interpolation)) context.addIssue({
+		code: "custom",
+		message: `${track.channel} does not support ${track.interpolation} interpolation`,
+		path: ["interpolation"]
+	});
+	for (const [index, keyframe] of track.keyframes.entries()) {
+		const parsed = channel.value.safeParse(keyframe.value);
+		if (!parsed.success) context.addIssue({
+			code: "custom",
+			message: parsed.error.issues[0]?.message ?? `invalid value for ${track.channel}`,
+			path: [
+				"keyframes",
+				index,
+				"value"
+			]
+		});
+	}
+});
+const extensionKindSchema = z.string().regex(/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)+$/).max(160);
+const BoardProceduralClipSchema = z.object({
+	id: idSchema,
+	kind: extensionKindSchema,
+	kindVersion: z.number().int().positive(),
+	target: BoardAnimationTargetSchema,
+	start: finiteSchema.nonnegative(),
+	duration: finiteSchema.positive(),
+	layer: z.enum([
+		"behind",
+		"content",
+		"front",
+		"screen"
+	]).default("content"),
+	fill: z.enum([
+		"none",
+		"backwards",
+		"forwards",
+		"both"
+	]).default("none"),
+	easing: BoardEasingSchema.default("linear"),
+	params: jsonObjectSchema.default({}),
+	assetRefs: z.array(z.object({
+		type: z.enum(["space-file", "extension"]),
+		ref: z.string().min(1).max(4096),
+		digest: z.string().min(16).max(160).optional()
+	}).strict()).default([]),
+	seed: idSchema,
+	metadata: jsonObjectSchema.default({})
+}).strict();
+const BoardTimelineMarkerSchema = z.object({
+	id: idSchema,
+	time: finiteSchema.nonnegative(),
+	duration: finiteSchema.nonnegative().optional(),
+	metadata: jsonObjectSchema.default({})
+}).strict();
+const BoardTimelineSchema = z.object({
+	duration: finiteSchema.nonnegative(),
+	tracks: z.array(BoardTrackSchema).max(5e4).default([]),
+	clips: z.array(BoardProceduralClipSchema).max(5e4).default([]),
+	markers: z.array(BoardTimelineMarkerSchema).max(1e4).default([])
+}).strict().superRefine((timeline, context) => {
+	const ids = /* @__PURE__ */ new Set();
+	const channels = /* @__PURE__ */ new Set();
+	for (const [index, track] of timeline.tracks.entries()) {
+		if (ids.has(track.id)) context.addIssue({
+			code: "custom",
+			message: `duplicate timeline id: ${track.id}`,
+			path: [
+				"tracks",
+				index,
+				"id"
+			]
+		});
+		ids.add(track.id);
+		const targetId = track.target.type === "item" ? track.target.itemId : track.target.type === "effect" ? track.target.effectId : track.target.type;
+		const key = `${track.target.type}:${targetId}:${track.channel}`;
+		if (channels.has(key)) context.addIssue({
+			code: "custom",
+			message: `multiple tracks control ${key}`,
+			path: [
+				"tracks",
+				index,
+				"channel"
+			]
+		});
+		channels.add(key);
+		for (const [keyframeIndex, keyframe] of track.keyframes.entries()) if (keyframe.time > timeline.duration) context.addIssue({
+			code: "custom",
+			message: "keyframe exceeds timeline duration",
+			path: [
+				"tracks",
+				index,
+				"keyframes",
+				keyframeIndex,
+				"time"
+			]
+		});
+	}
+	for (const [index, clip] of timeline.clips.entries()) {
+		if (ids.has(clip.id)) context.addIssue({
+			code: "custom",
+			message: `duplicate timeline id: ${clip.id}`,
+			path: [
+				"clips",
+				index,
+				"id"
+			]
+		});
+		ids.add(clip.id);
+		if (clip.start + clip.duration > timeline.duration) context.addIssue({
+			code: "custom",
+			message: "clip exceeds timeline duration",
+			path: [
+				"clips",
+				index,
+				"duration"
+			]
+		});
+	}
+	for (const [index, marker] of timeline.markers.entries()) {
+		if (ids.has(marker.id)) context.addIssue({
+			code: "custom",
+			message: `duplicate timeline id: ${marker.id}`,
+			path: [
+				"markers",
+				index,
+				"id"
+			]
+		});
+		ids.add(marker.id);
+		if (marker.time + (marker.duration ?? 0) > timeline.duration) context.addIssue({
+			code: "custom",
+			message: "marker exceeds timeline duration",
+			path: ["markers", index]
+		});
+	}
+});
+const BoardCompositionPlaybackSchema = z.object({
+	loop: z.boolean().default(false),
+	endBehavior: z.enum(["hold", "reset"]).default("hold"),
+	reducedMotion: z.discriminatedUnion("mode", [
+		z.object({ mode: z.literal("base") }).strict(),
+		z.object({
+			mode: z.literal("time"),
+			time: finiteSchema.nonnegative()
+		}).strict(),
+		z.object({
+			mode: z.literal("marker"),
+			markerId: idSchema
+		}).strict()
+	]).default({ mode: "base" })
+}).strict();
+const compositionFields = {
+	id: idSchema,
+	name: z.string().min(1).max(255),
+	timeline: BoardTimelineSchema,
+	playback: BoardCompositionPlaybackSchema.default({
+		loop: false,
+		endBehavior: "hold",
+		reducedMotion: { mode: "base" }
+	}),
+	metadata: jsonObjectSchema.default({})
+};
+function validateCompositionFallback(composition, context) {
+	const fallback = composition.playback.reducedMotion;
+	if (fallback.mode === "time" && fallback.time > composition.timeline.duration) context.addIssue({
+		code: "custom",
+		message: "reduced-motion time exceeds timeline duration",
+		path: [
+			"playback",
+			"reducedMotion",
+			"time"
+		]
+	});
+	if (fallback.mode === "marker" && !composition.timeline.markers.some((marker) => marker.id === fallback.markerId)) context.addIssue({
+		code: "custom",
+		message: `marker does not exist: ${fallback.markerId}`,
+		path: [
+			"playback",
+			"reducedMotion",
+			"markerId"
+		]
+	});
+}
+const BoardCompositionInputSchema = z.object(compositionFields).strict().superRefine(validateCompositionFallback);
+const BoardCompositionSchema = z.object({
+	...compositionFields,
+	revision: z.number().int().nonnegative().default(0)
+}).strict().superRefine(validateCompositionFallback);
+/** Accept inspect/get output as apply input while stripping server-owned revision. */
+function parseBoardCompositionInput(value) {
+	if (value && typeof value === "object" && !Array.isArray(value)) {
+		const { revision: _revision, ...input } = value;
+		return BoardCompositionInputSchema.parse(input);
+	}
+	return BoardCompositionInputSchema.parse(value);
+}
+Object.entries(BOARD_ANIMATION_CHANNELS).map(([id, definition]) => ({
+	id,
+	version: 1,
+	targets: definition.targets,
+	interpolations: definition.interpolations,
+	..."coordinateSpace" in definition ? { coordinateSpace: definition.coordinateSpace } : {},
+	..."unit" in definition ? { unit: definition.unit } : {},
+	valueSchema: z.toJSONSchema(definition.value)
+}));
+//#endregion
+export { BOARD_ANIMATION_CHANNELS, BOARD_EASINGS, BoardAnimationTargetSchema, BoardCompositionInputSchema, BoardCompositionPlaybackSchema, BoardCompositionSchema, BoardEasingSchema, BoardProceduralClipSchema, BoardTimelineMarkerSchema, BoardTimelineSchema, BoardTrackSchema, parseBoardCompositionInput };

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

@@ -11,7 +11,6 @@ const DEFAULT_BOARD_RENDER_LIMITS = {
 	simulationSteps: 1e5
 };
 const BOARD_BUILTIN_CLIP_KINDS = [
-	"motion.keyframes",
 	"motion.path",
 	"draw.reveal",
 	"draw.handwrite",
@@ -20,9 +19,6 @@ const BOARD_BUILTIN_CLIP_KINDS = [
 	"effects.trail",
 	"effects.impact",
 	"effects.flash",
-	"effects.color",
-	"camera.pan",
-	"camera.zoom",
 	"camera.focus",
 	"camera.shake"
 ];
@@ -63,16 +59,6 @@ const BOARD_FONT_STACK = "\"Geist\", system-ui, -apple-system, \"Noto Sans CJK S
 const BOARD_MONO_FONT_STACK = "\"Geist Mono\", \"Fira Code\", ui-monospace, \"Noto Sans Mono CJK SC\", monospace";
 function clipSchema(id) {
 	switch (id) {
-		case "motion.keyframes": return { params: {
-			x: {
-				coordinateSpace: "world-offset",
-				unit: "board"
-			},
-			y: {
-				coordinateSpace: "world-offset",
-				unit: "board"
-			}
-		} };
 		case "motion.path": return { params: { points: {
 			coordinateSpace: "world-offset",
 			unit: "board"
@@ -81,17 +67,6 @@ function clipSchema(id) {
 			coordinateSpace: "world",
 			unit: "board"
 		} } };
-		case "camera.pan": return { params: {
-			x: {
-				coordinateSpace: "screen-offset",
-				unit: "css-px"
-			},
-			y: {
-				coordinateSpace: "screen-offset",
-				unit: "css-px"
-			}
-		} };
-		case "camera.zoom": return { params: { scale: { unit: "ratio" } } };
 		case "camera.focus": return { params: {
 			focus: {
 				coordinateSpace: "world",

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

@@ -1,19 +1,8 @@
-import { BoardCoordinateSpace } from "./board-constants.js";
 import { z } from "zod";
 //#region ../protocol/dist/board-node.d.ts
 declare const BOARD_COLOR_IDS: readonly ["brand", "neutral", "black", "white", "blue", "green", "amber", "violet", "rose"];
 type BoardColorId = (typeof BOARD_COLOR_IDS)[number];
 declare const BOARD_GEO_KINDS: readonly ["rectangle", "rounded", "ellipse", "diamond", "triangle"];
 type BoardGeoKind = (typeof BOARD_GEO_KINDS)[number];
-type BoardNodeValidationDiagnostic = {
-  severity: "error";
-  code: "INVALID_BOARD_NODE" | "INVALID_BOARD_GEOMETRY";
-  message: string;
-  path: string;
-  expected?: string;
-  received?: unknown;
-  allowedValues?: readonly string[];
-  coordinateSpace?: BoardCoordinateSpace;
-};
 //#endregion
-export { BOARD_COLOR_IDS, BOARD_GEO_KINDS, BoardColorId, BoardGeoKind, BoardNodeValidationDiagnostic };
+export { BOARD_COLOR_IDS, BOARD_GEO_KINDS, BoardColorId, BoardGeoKind };

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

@@ -155,85 +155,5 @@ function jsonSchema(schema) {
 	return z.toJSONSchema(schema);
 }
 jsonSchema(nodeEnvelopeSchema), Object.fromEntries(BOARD_NATIVE_NODE_TYPES.map((type) => [type, jsonSchema(dataSchemas[type])])), Object.fromEntries(BOARD_NATIVE_NODE_TYPES.map((type) => [type, jsonSchema(viewSchemas[type])]));
-function issueDiagnostic(issue, path) {
-	const fullPath = [path, ...issue.path].join(".");
-	const values = "values" in issue && Array.isArray(issue.values) ? issue.values.filter((value) => typeof value === "string") : void 0;
-	return {
-		severity: "error",
-		code: "INVALID_BOARD_NODE",
-		message: `${fullPath}: ${issue.message}`,
-		path: fullPath,
-		...values?.length ? { allowedValues: values } : {}
-	};
-}
-function drawGeometryDiagnostic(node, data, path) {
-	let minX = Number.POSITIVE_INFINITY;
-	let minY = Number.POSITIVE_INFINITY;
-	let maxX = Number.NEGATIVE_INFINITY;
-	let maxY = Number.NEGATIVE_INFINITY;
-	for (const point of data.points) {
-		const radius = Math.max(.5, data.size / 2 * (.5 + point.p));
-		minX = Math.min(minX, point.x - radius);
-		minY = Math.min(minY, point.y - radius);
-		maxX = Math.max(maxX, point.x + radius);
-		maxY = Math.max(maxY, point.y + radius);
-	}
-	const width = Math.max(1, maxX - minX);
-	const height = Math.max(1, maxY - minY);
-	const tolerance = Math.max(.01, node.width * 1e-6, node.height * 1e-6);
-	if (Math.abs(minX) <= tolerance && Math.abs(minY) <= tolerance && Math.abs(width - node.width) <= tolerance && Math.abs(height - node.height) <= tolerance) return null;
-	return {
-		severity: "error",
-		code: "INVALID_BOARD_GEOMETRY",
-		message: `${path}.data.points must use frame-local coordinates and match the node frame`,
-		path: `${path}.data.points`,
-		expected: "frame-local points with bounds matching width and height",
-		coordinateSpace: "frame-local"
-	};
-}
-function validateBoardNodeInput(node, path = "node") {
-	const envelopeResult = nodeEnvelopeSchema.safeParse(node);
-	if (!envelopeResult.success) return envelopeResult.error.issues.map((issue) => issueDiagnostic(issue, path));
-	if (typeof node.type !== "string" || !BOARD_NATIVE_NODE_TYPES.includes(node.type)) return [{
-		severity: "error",
-		code: "INVALID_BOARD_NODE",
-		message: `${path}.type is not supported`,
-		path: `${path}.type`,
-		expected: "BoardNativeNodeType",
-		received: node.type,
-		allowedValues: BOARD_NATIVE_NODE_TYPES
-	}];
-	const type = node.type;
-	const dataResult = dataSchemas[type].safeParse(node.data ?? {});
-	if (!dataResult.success) return dataResult.error.issues.map((issue) => issueDiagnostic(issue, `${path}.data`));
-	const viewResult = viewSchemas[type].safeParse(node.view ?? {});
-	if (!viewResult.success) return viewResult.error.issues.map((issue) => issueDiagnostic(issue, `${path}.view`));
-	if (type === "image" || type === "video" || type === "audio" || type === "file") {
-		if (node.refKind !== "space_file" || typeof node.refPath !== "string" || !node.refPath) return [{
-			severity: "error",
-			code: "INVALID_BOARD_NODE",
-			message: `${path} requires a space file reference`,
-			path: `${path}.refPath`,
-			expected: "non-empty refPath with refKind space_file"
-		}];
-	}
-	if (type === "draw") {
-		const diagnostic = drawGeometryDiagnostic(node, dataResult.data, path);
-		return diagnostic ? [diagnostic] : [];
-	}
-	if (type === "arrow") {
-		const data = dataResult.data;
-		const inside = (point) => point.x >= node.x && point.x <= node.x + node.width && point.y >= node.y && point.y <= node.y + node.height;
-		if (!inside(data.start) || !inside(data.end)) return [{
-			severity: "error",
-			code: "INVALID_BOARD_GEOMETRY",
-			message: `${path}.data endpoints must be covered by the node frame`,
-			path: `${path}.data`,
-			expected: "world-space endpoints inside the node frame",
-			coordinateSpace: "world"
-		}];
-	}
-	return [];
-}
 //#endregion
-export { BOARD_COLOR_IDS, BOARD_GEO_KINDS, BOARD_NATIVE_NODE_TYPES, BoardColorIdSchema, BoardGeoKindSchema, validateBoardNodeInput };
+export { BOARD_COLOR_IDS, BOARD_GEO_KINDS, BOARD_NATIVE_NODE_TYPES, BoardColorIdSchema, BoardGeoKindSchema };

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

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

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

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

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

@@ -1,5 +1,6 @@
 import { BoardCapability, BoardCoordinateSpace, BoardRenderCost } from "./board-constants.js";
 import { BoardConnectionInput, BoardConnectionPatch } from "./board-connection.js";
+import { BoardComposition } from "./board-composition.js";
 import "./board-node.js";
 import { z } from "zod";
 //#region ../protocol/dist/board.d.ts
@@ -18,17 +19,6 @@ declare class InvalidBoardFileError extends Error {
 }
 declare function parseBoardManifest(input: string | unknown): BoardManifest;
 declare function serializeBoardManifest(manifest: BoardManifest): string;
-declare const BoardTargetSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-  type: z.ZodLiteral<"node">;
-  nodeId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-  type: z.ZodLiteral<"effect">;
-  effectId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-  type: z.ZodLiteral<"board">;
-}, z.core.$strip>, z.ZodObject<{
-  type: z.ZodLiteral<"camera">;
-}, z.core.$strip>], "type">;
 declare const BoardCameraStateSchema: z.ZodObject<{
   centerX: z.ZodNumber;
   centerY: z.ZodNumber;
@@ -43,11 +33,11 @@ declare const BoardCameraFocusSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     height: z.ZodNumber;
   }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{
-  type: z.ZodLiteral<"node">;
-  nodeId: z.ZodString;
+  type: z.ZodLiteral<"item">;
+  itemId: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
-  type: z.ZodLiteral<"nodes">;
-  nodeIds: z.ZodArray<z.ZodString>;
+  type: z.ZodLiteral<"items">;
+  itemIds: z.ZodArray<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
   type: z.ZodLiteral<"frame">;
   frameId: z.ZodString;
@@ -62,11 +52,11 @@ declare const BoardCameraFocusParamsSchema: z.ZodObject<{
       height: z.ZodNumber;
     }, z.core.$strip>;
   }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"node">;
-    nodeId: z.ZodString;
+    type: z.ZodLiteral<"item">;
+    itemId: z.ZodString;
   }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"nodes">;
-    nodeIds: z.ZodArray<z.ZodString>;
+    type: z.ZodLiteral<"items">;
+    itemIds: z.ZodArray<z.ZodString>;
   }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"frame">;
     frameId: z.ZodString;
@@ -87,63 +77,15 @@ declare const BoardAssetRefSchema: z.ZodObject<{
   ref: z.ZodString;
   digest: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-declare const BoardClipSchema: z.ZodObject<{
-  id: z.ZodString;
-  sequenceId: z.ZodString;
-  kind: z.ZodString;
-  kindVersion: z.ZodNumber;
-  target: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    type: z.ZodLiteral<"node">;
-    nodeId: z.ZodString;
-  }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"effect">;
-    effectId: z.ZodString;
-  }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"board">;
-  }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"camera">;
-  }, z.core.$strip>], "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.ZodString>;
-  params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-  keyframes: z.ZodDefault<z.ZodArray<z.ZodObject<{
-    at: z.ZodNumber;
-    value: z.ZodUnknown;
-    easing: z.ZodOptional<z.ZodString>;
-  }, z.core.$strip>>>;
-  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.$strip>>>;
-  seed: z.ZodString;
-  metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strip>;
 declare const BoardEffectSchema: z.ZodObject<{
   id: z.ZodString;
   boardId: z.ZodString;
   target: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    type: z.ZodLiteral<"node">;
-    nodeId: z.ZodString;
-  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"item">;
+    itemId: z.ZodString;
+  }, z.core.$strict>, z.ZodObject<{
     type: z.ZodLiteral<"board">;
-  }, z.core.$strip>], "type">;
+  }, z.core.$strict>], "type">;
   kind: z.ZodString;
   kindVersion: z.ZodNumber;
   enabled: z.ZodDefault<z.ZodBoolean>;
@@ -175,24 +117,11 @@ declare const BoardEffectSchema: z.ZodObject<{
   metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
   revision: z.ZodNumber;
 }, z.core.$strip>;
-declare const BoardSequenceSchema: z.ZodObject<{
-  id: z.ZodString;
-  boardId: z.ZodString;
-  name: z.ZodString;
-  duration: z.ZodNumber;
-  seed: z.ZodString;
-  restPose: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-  metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-  revision: z.ZodNumber;
-}, z.core.$strip>;
-type BoardTarget = z.infer<typeof BoardTargetSchema>;
 type BoardCameraState = z.infer<typeof BoardCameraStateSchema>;
 type BoardCameraFocus = z.infer<typeof BoardCameraFocusSchema>;
 type BoardCameraFocusParams = z.infer<typeof BoardCameraFocusParamsSchema>;
 type BoardAssetRef = z.infer<typeof BoardAssetRefSchema>;
-type BoardClip = z.infer<typeof BoardClipSchema>;
 type BoardEffect = z.infer<typeof BoardEffectSchema>;
-type BoardSequence = z.infer<typeof BoardSequenceSchema>;
 type BoardRecord = {
   id: string;
   spaceId: string;
@@ -285,15 +214,14 @@ type BoardOperation = (BoardOperationBase & {
     effectId: string;
   };
 }) | (BoardOperationBase & {
-  type: "sequence.upsert";
+  type: "composition.apply";
   payload: {
-    sequence: Omit<BoardSequence, "boardId" | "revision">;
-    clips: Array<Omit<BoardClip, "sequenceId">>;
+    composition: Omit<BoardComposition, "revision">;
   };
 }) | (BoardOperationBase & {
-  type: "sequence.delete";
+  type: "composition.delete";
   payload: {
-    sequenceId: string;
+    compositionId: string;
   };
 });
 type BoardDiagnostic = {
@@ -314,11 +242,10 @@ type BoardValidationResult = {
 };
 /** Persisted on `boards.metadata.playback`: how a Board plays when opened. */
 declare const BoardPlaybackPolicySchema: z.ZodObject<{
-  sequenceId: z.ZodString;
+  compositionId: z.ZodString;
   delayMs: z.ZodDefault<z.ZodNumber>;
-  loop: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>;
 type BoardPlaybackPolicy = z.infer<typeof BoardPlaybackPolicySchema>;
 declare function isBoardPath(path: string): boolean;
 //#endregion
-export { BOARD_DELETE_REASONS, BOARD_DOCUMENT_KIND, BOARD_EXTENSION, BoardAssetRef, BoardAssetRefSchema, BoardCameraFocus, BoardCameraFocusParams, BoardCameraFocusParamsSchema, BoardCameraFocusSchema, BoardCameraState, BoardCameraStateSchema, BoardClip, BoardClipSchema, BoardDeleteReason, BoardDiagnostic, BoardEffect, BoardEffectSchema, BoardManifest, BoardManifestSchema, BoardNodeInput, BoardNodeRecord, BoardOperation, BoardPlaybackPolicy, BoardPlaybackPolicySchema, BoardRecord, BoardSequence, BoardSequenceSchema, BoardTarget, BoardTargetSchema, BoardValidationResult, InvalidBoardFileError, isBoardPath, parseBoardManifest, serializeBoardManifest };
+export { BOARD_DELETE_REASONS, BOARD_DOCUMENT_KIND, BOARD_EXTENSION, BoardAssetRef, BoardAssetRefSchema, BoardCameraFocus, BoardCameraFocusParams, BoardCameraFocusParamsSchema, BoardCameraFocusSchema, BoardCameraState, BoardCameraStateSchema, type BoardCapability, BoardDeleteReason, BoardDiagnostic, BoardEffect, BoardEffectSchema, BoardManifest, BoardManifestSchema, BoardNodeInput, BoardNodeRecord, BoardOperation, BoardPlaybackPolicy, BoardPlaybackPolicySchema, BoardRecord, type BoardRenderCost, BoardValidationResult, InvalidBoardFileError, isBoardPath, parseBoardManifest, serializeBoardManifest };