@neta-art/cohub 8.24.0 → 9.0.0

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

@@ -0,0 +1,33 @@
+//#region ../protocol/dist/board-schema.d.ts
+type JsonSchema = Record<string, unknown>;
+declare const BOARD_SCHEMA_TARGETS: readonly ["board", "animation", "track", "camera", ...("arrow" | "audio" | "draw" | "effect" | "file" | "frame" | "image" | "shape" | "sketch" | "task" | "text" | "video")[]];
+type BoardJsonSchemaResult = {
+  schema?: JsonSchema;
+  properties?: Array<{
+    property: string;
+    kind: string;
+  }>;
+  kinds?: Record<string, {
+    description: string;
+    parameters: Record<string, string>;
+  }>;
+};
+declare function boardJsonSchema(target: string): BoardJsonSchemaResult | null;
+declare function boardSchemaOverview(): {
+  units: {
+    time: string;
+    rotation: string;
+    length: string;
+  };
+  types: ("arrow" | "audio" | "draw" | "effect" | "file" | "frame" | "image" | "shape" | "sketch" | "task" | "text" | "video")[];
+  colors: {
+    tokens: readonly ["brand", "neutral", "black", "white", "blue", "green", "amber", "violet", "rose"];
+    css: string;
+    themed: string;
+  };
+  properties: {
+    [k: string]: string[];
+  };
+};
+//#endregion
+export { BOARD_SCHEMA_TARGETS, BoardJsonSchemaResult, boardJsonSchema, boardSchemaOverview };

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

@@ -0,0 +1,59 @@
+import { BOARD_CAMERA_TARGET, BOARD_COLOR_TOKENS, BOARD_EFFECT_KINDS, BOARD_EFFECT_KIND_INFO, BOARD_ITEM_SCHEMAS, BOARD_ITEM_TYPES, BoardAnimationHeaderSchema, BoardSettingsSchema, BoardTrackSchema, isBuiltinItemType } from "./board-model.js";
+import { listBoardProperties } from "./board-patch.js";
+import { z } from "zod";
+//#region ../protocol/dist/board-schema.js
+function toJsonSchema(schema) {
+	const { $schema: _schema, ...rest } = z.toJSONSchema(schema, {
+		io: "input",
+		unrepresentable: "any"
+	});
+	return rest;
+}
+const BOARD_SCHEMA_TARGETS = [
+	"board",
+	"animation",
+	"track",
+	BOARD_CAMERA_TARGET,
+	...BOARD_ITEM_TYPES
+];
+function boardJsonSchema(target) {
+	if (target === "board") return { schema: toJsonSchema(BoardSettingsSchema) };
+	if (target === "animation") return {
+		schema: toJsonSchema(BoardAnimationHeaderSchema.extend({ tracks: z.record(z.string(), BoardTrackSchema).optional() })),
+		properties: listBoardProperties("animation")
+	};
+	if (target === "track") return { schema: toJsonSchema(BoardTrackSchema) };
+	if (target === "effect") return {
+		schema: toJsonSchema(BOARD_ITEM_SCHEMAS.effect),
+		properties: listBoardProperties("effect"),
+		kinds: Object.fromEntries(BOARD_EFFECT_KINDS.map((kind) => [kind, BOARD_EFFECT_KIND_INFO[kind]]))
+	};
+	if (target === "camera") return { properties: listBoardProperties(BOARD_CAMERA_TARGET) };
+	if (!isBuiltinItemType(target)) return null;
+	return {
+		schema: toJsonSchema(BOARD_ITEM_SCHEMAS[target]),
+		properties: listBoardProperties(target)
+	};
+}
+function boardSchemaOverview() {
+	return {
+		units: {
+			time: "milliseconds",
+			rotation: "degrees",
+			length: "board units (1 = 1 CSS px at zoom 1)"
+		},
+		types: BOARD_ITEM_TYPES,
+		colors: {
+			tokens: BOARD_COLOR_TOKENS,
+			css: "any CSS color",
+			themed: "{ light, dark }"
+		},
+		properties: Object.fromEntries([
+			...BOARD_ITEM_TYPES,
+			BOARD_CAMERA_TARGET,
+			"animation"
+		].map((target) => [target, listBoardProperties(target).map((entry) => entry.property)]))
+	};
+}
+//#endregion
+export { BOARD_SCHEMA_TARGETS, boardJsonSchema, boardSchemaOverview };

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

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

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

@@ -1,6 +1,5 @@
 import { z } from "zod";
 //#region ../protocol/dist/board-url.d.ts
-declare const BOARD_REMOTE_URL_MAX_LENGTH = 4096;
 declare function isPublicBoardRemoteAddress(value: string): boolean;
 /**
  * Normalize a browser-loadable public HTTP(S) URL. This blocks explicit local
@@ -8,6 +7,5 @@ declare function isPublicBoardRemoteAddress(value: string): boolean;
  * resolution to defend against rebinding.
  */
 declare function normalizeBoardRemoteUrl(value: unknown): string | undefined;
-declare const BoardRemoteUrlSchema: z.ZodString;
 //#endregion
-export { BOARD_REMOTE_URL_MAX_LENGTH, BoardRemoteUrlSchema, isPublicBoardRemoteAddress, normalizeBoardRemoteUrl };
+export { isPublicBoardRemoteAddress, normalizeBoardRemoteUrl };

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

@@ -83,6 +83,6 @@ function normalizeBoardRemoteUrl(value) {
 		return;
 	}
 }
-const BoardRemoteUrlSchema = z.string().max(BOARD_REMOTE_URL_MAX_LENGTH).refine((value) => normalizeBoardRemoteUrl(value) !== void 0, { message: "URL must be a public HTTP(S) URL without credentials" });
+z.string().max(BOARD_REMOTE_URL_MAX_LENGTH).refine((value) => normalizeBoardRemoteUrl(value) !== void 0, { message: "URL must be a public HTTP(S) URL without credentials" });
 //#endregion
-export { BOARD_REMOTE_URL_MAX_LENGTH, BoardRemoteUrlSchema, isPublicBoardRemoteAddress, normalizeBoardRemoteUrl };
+export { BOARD_REMOTE_URL_MAX_LENGTH, isPublicBoardRemoteAddress, normalizeBoardRemoteUrl };

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

@@ -1,13 +1,7 @@
-import { BoardCapability, BoardCoordinateSpace, BoardRenderCost } from "./board-constants.js";
-import { BoardConnectionInput, BoardConnectionPatch, BoardConnectionRecord } from "./board-connection.js";
-import { BoardComposition } from "./board-composition.js";
-import { BoardAssetRef, BoardAssetRefSchema, BoardEffect, BoardEffectInput, BoardEffectInputSchema, BoardEffectSchema } from "./board-effect.js";
-import "./board-authoring.js";
+import { BoardDelta, BoardPatch } from "./board-model.js";
 import { RequestSource } from "./provenance.js";
 import { z } from "zod";
 //#region ../protocol/dist/board.d.ts
-declare const BOARD_EXTENSION: ".board";
-declare const BOARD_DOCUMENT_KIND: "cohub.board";
 declare const BoardManifestSchema: z.ZodObject<{
   kind: z.ZodLiteral<"cohub.board.manifest">;
   version: z.ZodLiteral<1>;
@@ -17,250 +11,61 @@ declare const BoardManifestSchema: z.ZodObject<{
 type BoardManifest = z.infer<typeof BoardManifestSchema>;
 declare function parseBoardManifest(input: string | unknown): BoardManifest;
 declare function serializeBoardManifest(manifest: BoardManifest): string;
-declare const BoardCameraStateSchema: z.ZodObject<{
-  centerX: z.ZodNumber;
-  centerY: z.ZodNumber;
-  zoom: z.ZodNumber;
-}, z.core.$strip>;
-declare const BoardCameraFocusSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-  type: z.ZodLiteral<"rect">;
-  rect: z.ZodObject<{
-    x: z.ZodNumber;
-    y: z.ZodNumber;
-    width: z.ZodNumber;
-    height: z.ZodNumber;
-  }, z.core.$strip>;
-}, z.core.$strip>, z.ZodObject<{
-  type: z.ZodLiteral<"item">;
-  itemId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-  type: z.ZodLiteral<"items">;
-  itemIds: z.ZodArray<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-  type: z.ZodLiteral<"frame">;
-  frameId: z.ZodString;
-}, z.core.$strip>], "type">;
-declare const BoardCameraFocusParamsSchema: z.ZodObject<{
-  focus: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    type: z.ZodLiteral<"rect">;
-    rect: z.ZodObject<{
-      x: z.ZodNumber;
-      y: z.ZodNumber;
-      width: z.ZodNumber;
-      height: z.ZodNumber;
-    }, z.core.$strip>;
-  }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"item">;
-    itemId: z.ZodString;
-  }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"items">;
-    itemIds: z.ZodArray<z.ZodString>;
-  }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"frame">;
-    frameId: z.ZodString;
-  }, z.core.$strip>], "type">;
-  fit: z.ZodDefault<z.ZodEnum<{
-    contain: "contain";
-    cover: "cover";
-  }>>;
-  padding: z.ZodDefault<z.ZodNumber>;
-  minZoom: z.ZodOptional<z.ZodNumber>;
-  maxZoom: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-type BoardCameraState = z.infer<typeof BoardCameraStateSchema>;
-type BoardCameraFocus = z.infer<typeof BoardCameraFocusSchema>;
-type BoardCameraFocusParams = z.infer<typeof BoardCameraFocusParamsSchema>;
-type BoardRecord = {
-  id: string;
-  spaceId: string;
-  title: string;
-  version: number;
-  metadata: Record<string, unknown>;
-  createdAt: string | null;
-  updatedAt: string | null;
-};
-type BoardNodeRecord = {
-  boardId: string;
-  nodeId: string;
-  type: string;
-  parentId: string | null;
-  orderKey: string | null;
-  x: number;
-  y: number;
-  width: number;
-  height: number;
-  rotation: number;
-  refKind: string | null;
-  refPath: string | null;
-  refUrl: string | null;
-  view: Record<string, unknown>;
-  style: Record<string, unknown>;
-  data: Record<string, unknown>;
-  version: number;
-  createdAt: string | null;
-  updatedAt: string | null;
-};
-type BoardNodeInput = Omit<BoardNodeRecord, "boardId" | "version" | "createdAt" | "updatedAt">;
-declare const BOARD_DELETE_REASONS: readonly ["user-delete", "orphan-cleanup", "layout-replace", "placeholder-cascade", "node-cascade"];
-type BoardDeleteReason = (typeof BOARD_DELETE_REASONS)[number] | (string & {});
-type BoardOperationBase = {
-  opId?: string;
-  /** Optional local undo hint. Servers recompute authoritative inverse data. */
-  inverse?: Record<string, unknown>;
-};
-type BoardOperation = (BoardOperationBase & {
-  type: "board.patch";
-  payload: {
-    patch: {
-      title?: string;
-      metadata?: Record<string, unknown>;
-      metadataPatch?: Record<string, unknown>;
-    };
-  };
-}) | (BoardOperationBase & {
-  type: "node.create";
-  payload: {
-    node: BoardNodeInput;
-  };
-}) | (BoardOperationBase & {
-  type: "node.patch";
-  payload: {
-    nodeId: string;
-    patch: Partial<BoardNodeInput>;
-  };
-}) | (BoardOperationBase & {
-  type: "node.delete";
-  payload: {
-    nodeId: string;
-    reason?: BoardDeleteReason;
-  };
-}) | (BoardOperationBase & {
-  type: "connection.create";
-  payload: {
-    connection: BoardConnectionInput;
-  };
-}) | (BoardOperationBase & {
-  type: "connection.patch";
-  payload: {
-    connectionId: string;
-    patch: BoardConnectionPatch;
-  };
-}) | (BoardOperationBase & {
-  type: "connection.delete";
-  payload: {
-    connectionId: string;
-    reason?: BoardDeleteReason;
-  };
-}) | (BoardOperationBase & {
-  type: "effect.upsert";
-  payload: {
-    effect: Omit<BoardEffect, "boardId" | "revision">;
-  };
-}) | (BoardOperationBase & {
-  type: "effect.delete";
-  payload: {
-    effectId: string;
-  };
-}) | (BoardOperationBase & {
-  type: "composition.apply";
-  payload: {
-    composition: Omit<BoardComposition, "revision">;
-  };
-}) | (BoardOperationBase & {
-  type: "composition.delete";
-  payload: {
-    compositionId: string;
-  };
-});
-type BoardMutationReceipt = {
-  mutationId: string;
-  status: "applied" | "validated";
-  outcome: "applied" | "noop" | "dry-run";
-  replayed: boolean;
-  board: {
-    id: string;
-    version: number;
-  };
-  changed: {
-    items: string[];
-    connections: string[];
-    effects: string[];
-    compositions: string[];
-    board: boolean;
-    orderChanged: boolean;
-  };
-};
-type BoardDiagnostic = {
-  severity: "info" | "warning" | "error";
-  code: string;
-  message: string;
-  path?: string;
-  adaptation?: Record<string, unknown>;
-  expected?: string;
-  received?: unknown;
-  allowedValues?: readonly string[];
-  coordinateSpace?: BoardCoordinateSpace;
-};
-type BoardValidationResult = {
-  valid: boolean;
-  diagnostics: BoardDiagnostic[];
-  peakCost: BoardRenderCost;
-};
-/**
- * One applied Board transaction as recorded in the log, with the server-computed
- * inverse of every operation. Read-only: replay walks the log in either
- * direction without touching Board rows.
- */
+declare function isBoardPath(path: string): boolean;
 type BoardTransactionRecord = {
   id: string;
-  txId: string;
+  mutationId: string;
   baseVersion: number;
-  /** Board version this transaction produced. */
   version: number;
   actorId: string;
   clientId: string | null;
-  undoGroupId: string | null;
   source: RequestSource | null;
   createdAt: string;
-  operations: BoardTransactionOperation[];
-};
-type BoardTransactionOperation = {
-  type: BoardOperation["type"];
-  payload: Record<string, unknown>;
-  inverse: Record<string, unknown> | null;
+  before: BoardDelta | null;
+  after: BoardDelta | null;
 };
-/**
- * A page of the transaction log, newest first. The newest page (no `before`)
- * carries the current rows unless `snapshot=false`, so a replay can start from
- * the live state and walk inverses backwards; older pages carry transactions only.
- */
-type BoardTransactionsPage = {
-  board: {
-    id: string;
-    version: number;
-  };
+type BoardHistoryPage = {
+  version: number;
   transactions: BoardTransactionRecord[];
-  /** Version to pass as `before` for the next older page, or null when exhausted. */
   nextBefore: number | null;
-  snapshot?: {
-    board: BoardRecord;
-    nodes: BoardNodeRecord[];
-    connections: BoardConnectionRecord[];
-  };
 };
 type BoardPlaybackStatus = "playing" | "paused" | "stopped";
 type BoardPlaybackSnapshot = {
-  boardId: string;
   playbackId: string;
-  compositionId: string;
-  compositionRevision: number;
-  playbackRevision: number;
+  animationId: string;
+  animationRevision: number;
+  revision: number;
   status: BoardPlaybackStatus;
   position: number;
   effectiveAt: number;
   timeScale: number;
   seed: string;
+  commandId: string;
 };
-declare function isBoardPath(path: string): boolean;
+declare const BoardPlaybackCommandSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  commandId: z.ZodString;
+  type: z.ZodLiteral<"play">;
+  animationId: z.ZodString;
+  position: z.ZodOptional<z.ZodNumber>;
+  timeScale: z.ZodOptional<z.ZodNumber>;
+  seed: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+  commandId: z.ZodString;
+  type: z.ZodLiteral<"pause">;
+}, z.core.$strict>, z.ZodObject<{
+  commandId: z.ZodString;
+  type: z.ZodLiteral<"resume">;
+}, z.core.$strict>, z.ZodObject<{
+  commandId: z.ZodString;
+  type: z.ZodLiteral<"seek">;
+  position: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+  commandId: z.ZodString;
+  type: z.ZodLiteral<"next">;
+}, z.core.$strict>, z.ZodObject<{
+  commandId: z.ZodString;
+  type: z.ZodLiteral<"stop">;
+}, z.core.$strict>], "type">;
+type BoardPlaybackCommand = z.infer<typeof BoardPlaybackCommandSchema>;
 //#endregion
-export { BOARD_DELETE_REASONS, BOARD_DOCUMENT_KIND, BOARD_EXTENSION, type BoardAssetRef, BoardCameraFocus, BoardCameraFocusParams, BoardCameraFocusParamsSchema, BoardCameraFocusSchema, BoardCameraState, BoardCameraStateSchema, type BoardCapability, BoardDeleteReason, BoardDiagnostic, type BoardEffect, BoardManifest, BoardManifestSchema, BoardMutationReceipt, BoardNodeInput, BoardNodeRecord, BoardOperation, BoardPlaybackSnapshot, BoardPlaybackStatus, BoardRecord, type BoardRenderCost, BoardTransactionOperation, BoardTransactionRecord, BoardTransactionsPage, BoardValidationResult, isBoardPath, parseBoardManifest, serializeBoardManifest };
+export { BoardHistoryPage, BoardManifest, BoardManifestSchema, BoardPlaybackCommand, BoardPlaybackCommandSchema, BoardPlaybackSnapshot, BoardPlaybackStatus, BoardTransactionRecord, isBoardPath, parseBoardManifest, serializeBoardManifest };

package/dist/protocol/dist/board.js

@@ -1,15 +1,8 @@
-import { BoardConnectionSchema } from "./board-connection.js";
-import { BoardCompositionInputSchema } from "./board-composition.js";
-import { BoardEffectInputSchema } from "./board-effect.js";
-import { BoardAuthoringItemSchema, BoardItemPatchSchema, BoardSemanticMutationSchema } from "./board-authoring.js";
+import { BoardIdSchema, BoardPatchSchema } from "./board-model.js";
 import { z } from "zod";
 //#region ../protocol/dist/board.js
 const BOARD_EXTENSION = ".board";
-const BOARD_DOCUMENT_KIND = "cohub.board";
 const BOARD_MANIFEST_KIND = "cohub.board.manifest";
-const idSchema = z.string().min(1).max(160);
-const jsonObjectSchema = z.record(z.string(), z.unknown());
-const finiteSchema = z.number().finite();
 const BoardManifestSchema = z.object({
 	kind: z.literal(BOARD_MANIFEST_KIND),
 	version: z.literal(1),
@@ -37,169 +30,78 @@ function parseBoardManifest(input) {
 function serializeBoardManifest(manifest) {
 	return `${JSON.stringify(BoardManifestSchema.parse(manifest), null, 2)}\n`;
 }
-const BoardCameraStateSchema = z.object({
-	centerX: finiteSchema,
-	centerY: finiteSchema,
-	zoom: finiteSchema.positive()
-});
-const BoardCameraFocusSchema = z.discriminatedUnion("type", [
-	z.object({
-		type: z.literal("rect"),
-		rect: z.object({
-			x: finiteSchema,
-			y: finiteSchema,
-			width: finiteSchema.positive(),
-			height: finiteSchema.positive()
-		})
-	}),
-	z.object({
-		type: z.literal("item"),
-		itemId: idSchema
-	}),
-	z.object({
-		type: z.literal("items"),
-		itemIds: z.array(idSchema).min(1).max(1e3)
-	}),
-	z.object({
-		type: z.literal("frame"),
-		frameId: idSchema
-	})
-]);
-const BoardCameraFocusParamsSchema = z.object({
-	focus: BoardCameraFocusSchema,
-	fit: z.enum(["contain", "cover"]).default("contain"),
-	padding: finiteSchema.nonnegative().default(32),
-	minZoom: finiteSchema.positive().optional(),
-	maxZoom: finiteSchema.positive().optional()
-}).superRefine((value, context) => {
-	if (value.minZoom !== void 0 && value.maxZoom !== void 0 && value.minZoom > value.maxZoom) context.addIssue({
-		code: "custom",
-		message: "minZoom must not exceed maxZoom",
-		path: ["minZoom"]
-	});
-});
-const BoardNodeInputSchema = z.object({
-	nodeId: idSchema,
-	type: z.string().min(1).max(40),
-	parentId: idSchema.nullable(),
-	orderKey: z.string().max(4096).nullable(),
-	x: finiteSchema,
-	y: finiteSchema,
-	width: finiteSchema.positive(),
-	height: finiteSchema.positive(),
-	rotation: finiteSchema,
-	refKind: z.string().max(40).nullable(),
-	refPath: z.string().max(4096).nullable(),
-	refUrl: z.string().max(4096).nullable(),
-	view: jsonObjectSchema,
-	style: jsonObjectSchema,
-	data: jsonObjectSchema
-});
-const stripBoardServerFields = (value) => {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return value;
-	const { boardId: _boardId, revision: _revision, ...input } = value;
-	return input;
-};
-const BoardCreateEffectInputSchema = z.preprocess(stripBoardServerFields, BoardEffectInputSchema);
-const BoardCreateCompositionInputSchema = z.preprocess(stripBoardServerFields, BoardCompositionInputSchema);
-const BoardCreateInputSchema = z.object({
-	path: z.string().min(1),
-	/** Reused by clients when board creation is interrupted and retried. */
-	mutationId: z.string().max(128).optional(),
-	title: z.string().min(1).max(255).optional(),
-	metadata: jsonObjectSchema.optional(),
-	items: z.array(BoardAuthoringItemSchema).max(5e4).optional(),
-	connections: z.array(BoardConnectionSchema).max(5e4).optional(),
-	effects: z.array(BoardCreateEffectInputSchema).max(5e4).optional(),
-	compositions: z.array(BoardCreateCompositionInputSchema).max(5e4).optional()
-});
-const jsonSchema = (schema) => z.toJSONSchema(schema);
-const authoringSchemaFactories = {
-	item: () => jsonSchema(BoardAuthoringItemSchema),
-	itemPatch: () => jsonSchema(BoardItemPatchSchema),
-	mutation: () => jsonSchema(BoardSemanticMutationSchema),
-	composition: () => jsonSchema(BoardCompositionInputSchema),
-	effect: () => jsonSchema(BoardEffectInputSchema),
-	create: () => jsonSchema(BoardCreateInputSchema)
-};
-/**
-* JSON Schemas for the semantic authoring surface. Each property is enumerable
-* for Object.keys/JSON.stringify, but generated only when that property is
-* requested. This keeps protocol imports cheap while capabilities still returns
-* the complete machine-readable schema object.
-*/
-const BOARD_AUTHORING_SCHEMAS = {};
-for (const key of Object.keys(authoringSchemaFactories)) {
-	let cached;
-	Object.defineProperty(BOARD_AUTHORING_SCHEMAS, key, {
-		enumerable: true,
-		configurable: false,
-		get() {
-			cached ??= authoringSchemaFactories[key]();
-			return cached;
-		}
-	});
+function isBoardPath(path) {
+	return path.toLowerCase().endsWith(BOARD_EXTENSION);
 }
+const BOARD_READ_SECTIONS = ["items", "animations"];
+const rectSchema = z.object({
+	x: z.number().finite(),
+	y: z.number().finite(),
+	width: z.number().finite().positive(),
+	height: z.number().finite().positive()
+}).strict();
 z.object({
-	include: z.array(z.enum([
-		"nodes",
-		"connections",
-		"effects",
-		"compositions",
-		"playback"
-	])).optional(),
-	nodeIds: 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()
+	only: z.array(z.enum(BOARD_READ_SECTIONS)).optional(),
+	rect: rectSchema.optional(),
+	within: BoardIdSchema.optional(),
+	items: z.array(z.string().min(1)).max(5e4).optional(),
+	animations: z.array(z.string().min(1)).max(1e4).optional(),
+	limit: z.number().int().min(1).max(5e4).optional(),
+	cursor: z.string().min(1).optional()
+}).strict().refine((read) => !(read.cursor && (read.rect || read.within)), {
+	path: ["cursor"],
+	message: "cursor pages by id, so it cannot be combined with rect or within"
 });
 z.object({
-	/** Return transactions with `version < before`. Omit for the newest page. */
-	before: z.number().int().positive().optional(),
-	limit: z.number().int().min(1).max(500).default(200),
-	/** Include the current rows on the newest page (default true). Tail refreshes turn this off. */
-	snapshot: z.boolean().default(true)
-});
+	patch: BoardPatchSchema,
+	replace: z.boolean().default(false),
+	cascade: z.boolean().default(false),
+	dryRun: z.boolean().default(false),
+	baseVersion: z.number().int().nonnegative().optional(),
+	mutationId: z.string().min(1).max(160).optional(),
+	clientId: z.string().min(1).max(160).optional()
+}).strict();
 z.object({
-	compositionId: idSchema,
-	/** Delay before the first local playback after opening the Board, in milliseconds. */
-	delayMs: finiteSchema.nonnegative().default(0)
-});
+	path: z.string().min(1),
+	title: z.string().min(1).max(255).optional(),
+	document: BoardPatchSchema.optional(),
+	mutationId: z.string().max(160).optional()
+}).strict();
+z.object({
+	before: z.number().int().positive().optional(),
+	limit: z.number().int().min(1).max(500).default(200)
+}).strict();
+const commandId = z.string().min(1).max(160);
 z.discriminatedUnion("type", [
 	z.object({
-		commandId: idSchema,
+		commandId,
 		type: z.literal("play"),
-		compositionId: idSchema,
-		position: finiteSchema.nonnegative().optional(),
-		timeScale: finiteSchema.positive().max(4).optional(),
-		shared: z.boolean().optional(),
-		seed: idSchema.optional()
-	}),
+		animationId: z.string().min(1),
+		position: z.number().finite().nonnegative().optional(),
+		timeScale: z.number().finite().positive().max(4).optional(),
+		seed: z.string().min(1).max(160).optional()
+	}).strict(),
+	z.object({
+		commandId,
+		type: z.literal("pause")
+	}).strict(),
 	z.object({
-		commandId: idSchema,
-		type: z.literal("pause"),
-		playbackId: z.string().uuid()
-	}),
+		commandId,
+		type: z.literal("resume")
+	}).strict(),
 	z.object({
-		commandId: idSchema,
+		commandId,
 		type: z.literal("seek"),
-		playbackId: z.string().uuid(),
-		position: finiteSchema.nonnegative()
-	}),
+		position: z.number().finite().nonnegative()
+	}).strict(),
+	z.object({
+		commandId,
+		type: z.literal("next")
+	}).strict(),
 	z.object({
-		commandId: idSchema,
-		type: z.literal("stop"),
-		playbackId: z.string().uuid()
-	})
+		commandId,
+		type: z.literal("stop")
+	}).strict()
 ]);
-function isBoardPath(path) {
-	return path.toLowerCase().endsWith(BOARD_EXTENSION);
-}
 //#endregion
-export { BOARD_AUTHORING_SCHEMAS, BOARD_DOCUMENT_KIND, BOARD_EXTENSION, BOARD_MANIFEST_KIND, BoardCameraFocusParamsSchema, BoardCameraFocusSchema, BoardCameraStateSchema, BoardCreateInputSchema, BoardManifestSchema, BoardNodeInputSchema, InvalidBoardFileError, isBoardPath, parseBoardManifest, serializeBoardManifest };
+export { BOARD_EXTENSION, BOARD_MANIFEST_KIND, BOARD_READ_SECTIONS, BoardManifestSchema, InvalidBoardFileError, isBoardPath, parseBoardManifest, serializeBoardManifest };

package/dist/protocol/dist/display/actions.d.ts

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

package/dist/protocol/dist/display/index.d.ts

@@ -0,0 +1,2 @@
+import "./actions.js";
+import { z } from "zod";