@neta-art/cohub 8.24.0 → 9.0.0

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

@@ -1,383 +0,0 @@
-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 BoardCompositionInputSchema: 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>>;
-}, z.core.$strict>;
-type BoardCompositionInput = z.infer<typeof BoardCompositionInputSchema>;
-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, BoardCompositionInput, BoardCompositionInputSchema, BoardCompositionSchema, BoardEasing, BoardEasingSchema, BoardProceduralClip, BoardProceduralClipSchema, BoardTimelineMarker, BoardTimelineMarkerSchema, BoardTrack, BoardTrackInterpolation, BoardTrackSchema };

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

@@ -1,310 +0,0 @@
-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.nonnegative(), z.object({
-	x: finiteSchema.nonnegative(),
-	y: finiteSchema.nonnegative()
-}).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);
-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 };