@neta-art/cohub 5.10.0 → 7.0.0

package/dist/chunks/http.js

@@ -1,7 +1,6 @@
-import { D as getRealtimeBoardRoom, O as getRealtimeSpaceRoom, n as HttpTransport, t as HttpError, y as isUuid } from "./transport.js";
+import { D as getRealtimeSpaceRoom, E as getRealtimeBoardRoom, n as HttpTransport, t as HttpError, y as isUuid } from "./transport.js";
 import { a as resolveApiBaseUrl } from "./environment.js";
 import { z } from "zod";
-import "perfect-freehand";
 //#region src/apis/channels.ts
 var ChannelsApi = class {
 	transport;
@@ -454,7 +453,6 @@ const DEFAULT_BOARD_RENDER_LIMITS = {
 	simulationSteps: 1e5
 };
 const BOARD_BUILTIN_CLIP_KINDS = [
-	"motion.keyframes",
 	"motion.path",
 	"draw.reveal",
 	"draw.handwrite",
@@ -463,31 +461,14 @@ const BOARD_BUILTIN_CLIP_KINDS = [
 	"effects.trail",
 	"effects.impact",
 	"effects.flash",
-	"effects.color",
-	"camera.pan",
-	"camera.zoom",
 	"camera.focus",
 	"camera.shake"
 ];
 const BOARD_BUILTIN_EFFECT_KINDS = ["effects.pulse", "effects.float"];
 const BOARD_ARROW_STROKE_SIZE = 2.5;
 const BOARD_CONNECTION_STROKE_SIZE = 2.5;
-function clampBoardStrokeSize(size) {
-	if (!Number.isFinite(size)) return BOARD_CONNECTION_STROKE_SIZE;
-	return Math.min(64, Math.max(1, size));
-}
 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"
@@ -496,17 +477,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",
@@ -572,12 +542,11 @@ const BoardConnectionAnchorSchema = z.union([
 		ny: z.number().finite().min(0).max(1)
 	})
 ]);
-const AUTO_BOARD_CONNECTION_ANCHOR = { kind: "auto" };
 const BoardConnectionEndpointSchema = z.object({
-	nodeId: z.string().min(1).max(160),
+	itemId: z.string().min(1).max(160),
 	/** Optional semantic port. Older connections omit it and remain valid. */
 	portId: z.string().min(1).max(120).optional(),
-	anchor: BoardConnectionAnchorSchema.default(AUTO_BOARD_CONNECTION_ANCHOR)
+	anchor: BoardConnectionAnchorSchema.default({ kind: "auto" })
 });
 /**
 * Which ends carry an arrowhead.
@@ -652,137 +621,148 @@ const BoardConnectionSchema = z.object({
 	routing: BoardConnectionRoutingSchema.default(DEFAULT_BOARD_CONNECTION_ROUTING),
 	style: BoardConnectionStyleSchema.default(DEFAULT_BOARD_CONNECTION_STYLE),
 	metadata: z.record(z.string(), z.unknown()).default({})
-});
-BoardConnectionSchema.omit({ id: true }).partial();
-function normalizeBoardConnectionStyle(style) {
-	return {
-		color: style?.color?.trim() || DEFAULT_BOARD_CONNECTION_STYLE.color,
-		size: clampBoardStrokeSize(typeof style?.size === "number" && Number.isFinite(style.size) ? style.size : DEFAULT_BOARD_CONNECTION_STYLE.size),
-		line: style?.line ?? DEFAULT_BOARD_CONNECTION_STYLE.line
-	};
-}
+}).strict();
 /**
-* Build a connection with every default filled in.
+* A patch to an existing connection.
 *
-* Callers only state what they mean (which nodes, and optionally the relation),
-* so a connection created by the editor, an agent or the CLI is byte-identical
-* for the same intent.
+* `id` is excluded: a connection's identity never changes, and re-pointing both
+* endpoints is an edit of the same relation, not a new one.
 */
-function createBoardConnection(input) {
-	return {
-		id: input.id,
-		source: {
-			nodeId: input.sourceNodeId,
-			...input.sourcePortId ? { portId: input.sourcePortId } : {},
-			anchor: input.sourceAnchor ?? AUTO_BOARD_CONNECTION_ANCHOR
-		},
-		target: {
-			nodeId: input.targetNodeId,
-			...input.targetPortId ? { portId: input.targetPortId } : {},
-			anchor: input.targetAnchor ?? AUTO_BOARD_CONNECTION_ANCHOR
-		},
-		relation: input.relation ?? "related",
-		direction: input.direction ?? "forward",
-		label: input.label ?? "",
-		routing: {
-			...DEFAULT_BOARD_CONNECTION_ROUTING,
-			...input.routing
-		},
-		style: normalizeBoardConnectionStyle(input.style),
-		metadata: input.metadata ?? {}
-	};
-}
+const BoardConnectionPatchSchema = BoardConnectionSchema.omit({ id: true }).partial();
 //#endregion
-//#region src/realtime.ts
-function ensureRealtimeConnected(websocketClient) {
-	if (websocketClient.state === "open" || websocketClient.state === "connecting" || websocketClient.state === "reconnecting") return;
-	websocketClient.connect().catch((error) => {
-		console.error("[CohubClient] Failed to connect realtime websocket:", error);
-	});
-}
-//#endregion
-//#region ../protocol/dist/board.js
-const BOARD_DOCUMENT_KIND = "cohub.board";
-const BOARD_MANIFEST_KIND = "cohub.board.manifest";
-const idSchema$1 = z.string().min(1).max(160);
-const extensionIdSchema = z.string().regex(/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)+$/).max(160);
-const jsonObjectSchema = z.record(z.string(), z.unknown());
+//#region ../protocol/dist/board-composition.js
+const idSchema$2 = z.string().min(1).max(160);
 const finiteSchema$1 = z.number().finite();
-z.object({
-	kind: z.literal(BOARD_MANIFEST_KIND),
-	version: z.literal(1),
-	boardId: z.string().uuid(),
-	title: z.string().min(1).max(255)
-});
-const BoardTargetSchema = z.discriminatedUnion("type", [
-	z.object({
-		type: z.literal("node"),
-		nodeId: idSchema$1
-	}),
-	z.object({
-		type: z.literal("effect"),
-		effectId: idSchema$1
-	}),
-	z.object({ type: z.literal("board") }),
-	z.object({ type: z.literal("camera") })
+const jsonObjectSchema$2 = z.record(z.string(), z.unknown());
+const BoardEasingSchema = z.enum([
+	"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"
 ]);
-z.object({
-	centerX: finiteSchema$1,
-	centerY: finiteSchema$1,
-	zoom: finiteSchema$1.positive()
-});
-const BoardCameraFocusSchema = z.discriminatedUnion("type", [
+const BoardAnimationTargetSchema = z.discriminatedUnion("type", [
 	z.object({
-		type: z.literal("rect"),
-		rect: z.object({
-			x: finiteSchema$1,
-			y: finiteSchema$1,
-			width: finiteSchema$1.positive(),
-			height: finiteSchema$1.positive()
-		})
-	}),
-	z.object({
-		type: z.literal("node"),
-		nodeId: idSchema$1
-	}),
-	z.object({
-		type: z.literal("nodes"),
-		nodeIds: z.array(idSchema$1).min(1).max(1e3)
-	}),
+		type: z.literal("item"),
+		itemId: idSchema$2
+	}).strict(),
 	z.object({
-		type: z.literal("frame"),
-		frameId: idSchema$1
-	})
+		type: z.literal("effect"),
+		effectId: idSchema$2
+	}).strict(),
+	z.object({ type: z.literal("camera") }).strict(),
+	z.object({ type: z.literal("board") }).strict()
 ]);
-const BoardCameraFocusParamsSchema = z.object({
-	focus: BoardCameraFocusSchema,
-	fit: z.enum(["contain", "cover"]).default("contain"),
-	padding: finiteSchema$1.nonnegative().default(32),
-	minZoom: finiteSchema$1.positive().optional(),
-	maxZoom: finiteSchema$1.positive().optional()
-}).superRefine((value, context) => {
-	if (value.minZoom !== void 0 && value.maxZoom !== void 0 && value.minZoom > value.maxZoom) context.addIssue({
+const vector2Schema = z.object({
+	x: finiteSchema$1,
+	y: finiteSchema$1
+}).strict();
+const scaleSchema = z.union([finiteSchema$1.positive(), z.object({
+	x: finiteSchema$1.positive(),
+	y: finiteSchema$1.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$1,
+		interpolations: ["linear", "step"],
+		unit: "radian"
+	},
+	"transform.scale": {
+		targets: ["item"],
+		value: scaleSchema,
+		interpolations: ["linear", "step"],
+		unit: "ratio"
+	},
+	"style.opacity": {
+		targets: ["item"],
+		value: finiteSchema$1.min(0).max(1),
+		interpolations: ["linear", "step"],
+		unit: "ratio"
+	}
+};
+const BoardTrackKeyframeSchema = z.object({
+	time: finiteSchema$1.nonnegative(),
+	value: z.unknown(),
+	easing: BoardEasingSchema.optional()
+}).strict();
+const BoardTrackSchema = z.object({
+	id: idSchema$2,
+	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$2.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: "minZoom must not exceed maxZoom",
-		path: ["minZoom"]
+		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 BoardAssetRefSchema = z.object({
-	type: z.enum(["space-file", "extension"]),
-	ref: z.string().min(1).max(4096),
-	digest: z.string().min(16).max(160).optional()
-});
-const BoardKeyframeSchema = z.object({
-	at: finiteSchema$1.nonnegative(),
-	value: z.unknown(),
-	easing: z.string().min(1).max(80).optional()
-});
-const BoardClipSchema = z.object({
-	id: idSchema$1,
-	sequenceId: idSchema$1,
-	kind: extensionIdSchema,
+const extensionKindSchema = z.string().regex(/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)+$/).max(160);
+const BoardProceduralClipSchema = z.object({
+	id: idSchema$2,
+	kind: extensionKindSchema,
 	kindVersion: z.number().int().positive(),
-	target: BoardTargetSchema,
+	target: BoardAnimationTargetSchema,
 	start: finiteSchema$1.nonnegative(),
 	duration: finiteSchema$1.positive(),
 	layer: z.enum([
@@ -797,20 +777,207 @@ const BoardClipSchema = z.object({
 		"forwards",
 		"both"
 	]).default("none"),
-	easing: z.string().min(1).max(80).default("linear"),
-	params: jsonObjectSchema.default({}),
-	keyframes: z.array(BoardKeyframeSchema).default([]),
-	assetRefs: z.array(BoardAssetRefSchema).default([]),
-	seed: z.string().min(1).max(160),
-	metadata: jsonObjectSchema.default({})
+	easing: BoardEasingSchema.default("linear"),
+	params: jsonObjectSchema$2.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$2,
+	metadata: jsonObjectSchema$2.default({})
+}).strict();
+const BoardTimelineMarkerSchema = z.object({
+	id: idSchema$2,
+	time: finiteSchema$1.nonnegative(),
+	duration: finiteSchema$1.nonnegative().optional(),
+	metadata: jsonObjectSchema$2.default({})
+}).strict();
+const BoardTimelineSchema = z.object({
+	duration: finiteSchema$1.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$1.nonnegative()
+		}).strict(),
+		z.object({
+			mode: z.literal("marker"),
+			markerId: idSchema$2
+		}).strict()
+	]).default({ mode: "base" })
+}).strict();
+const compositionFields = {
+	id: idSchema$2,
+	name: z.string().min(1).max(255),
+	timeline: BoardTimelineSchema,
+	playback: BoardCompositionPlaybackSchema.default({
+		loop: false,
+		endBehavior: "hold",
+		reducedMotion: { mode: "base" }
+	}),
+	metadata: jsonObjectSchema$2.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`. Anything else that looks server-owned (or simply unknown) fails
+* with a pointer at the offending key, so a get → edit → apply round-trip that
+* accidentally carries runtime fields names the culprit instead of a bare
+* "Unrecognized key".
+*/
+function parseBoardCompositionInput(value) {
+	if (value && typeof value === "object" && !Array.isArray(value)) {
+		const { revision: _revision, ...input } = value;
+		const result = BoardCompositionInputSchema.safeParse(input);
+		if (!result.success) {
+			const issue = result.error.issues.find((item) => item.code === "unrecognized_keys");
+			if (issue) throw new Error(`unknown field in composition input: ${issue.message}. Server-owned fields such as revision are stripped automatically; remove other fields not part of the composition schema`);
+			throw result.error;
+		}
+		return result.data;
+	}
+	return BoardCompositionInputSchema.parse(value);
+}
+const BOARD_ANIMATION_CHANNEL_CAPABILITIES = 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
+//#region ../protocol/dist/board-effect.js
+/**
+* Board effect schema, isolated so `board-authoring.ts` can reuse the exact
+* definition without a runtime cycle through `board.ts`. One definition, one
+* strictness level — semantic mutations and Board create must not drift apart.
+*/
+const idSchema$1 = z.string().min(1).max(160);
+const extensionIdSchema = z.string().regex(/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)+$/).max(160);
+const jsonObjectSchema$1 = z.record(z.string(), z.unknown());
+const BoardAssetRefSchema = z.object({
+	type: z.enum(["space-file", "extension"]),
+	ref: z.string().min(1).max(4096),
+	digest: z.string().min(16).max(160).optional()
+}).strict();
 const BoardEffectSchema = z.object({
 	id: idSchema$1,
 	boardId: z.string().uuid(),
 	target: z.discriminatedUnion("type", [z.object({
-		type: z.literal("node"),
-		nodeId: idSchema$1
-	}), z.object({ type: z.literal("board") })]),
+		type: z.literal("item"),
+		itemId: idSchema$1
+	}).strict(), z.object({ type: z.literal("board") }).strict()]),
 	kind: extensionIdSchema,
 	kindVersion: z.number().int().positive(),
 	enabled: z.boolean().default(true),
@@ -827,610 +994,30 @@ const BoardEffectSchema = z.object({
 	layer: z.enum([
 		"behind",
 		"front",
-		"screen"
-	]).default("front"),
-	seed: z.string().min(1).max(160),
-	params: jsonObjectSchema.default({}),
-	assetRefs: z.array(BoardAssetRefSchema).default([]),
-	metadata: jsonObjectSchema.default({}),
-	revision: z.number().int().nonnegative()
-});
-const BoardSequenceSchema = z.object({
-	id: idSchema$1,
-	boardId: z.string().uuid(),
-	name: z.string().min(1).max(255),
-	duration: finiteSchema$1.nonnegative(),
-	seed: z.string().min(1).max(160),
-	restPose: jsonObjectSchema.default({}),
-	metadata: jsonObjectSchema.default({}),
-	revision: z.number().int().nonnegative()
-});
-const BoardNodeInputSchema = z.object({
-	nodeId: idSchema$1,
-	type: z.string().min(1).max(40),
-	parentId: idSchema$1.nullable(),
-	orderKey: z.string().max(4096).nullable(),
-	x: finiteSchema$1,
-	y: finiteSchema$1,
-	width: finiteSchema$1.positive(),
-	height: finiteSchema$1.positive(),
-	rotation: finiteSchema$1,
-	refKind: z.string().max(40).nullable(),
-	refPath: z.string().max(4096).nullable(),
-	refUrl: z.string().max(4096).nullable(),
-	view: jsonObjectSchema,
-	style: jsonObjectSchema,
-	data: jsonObjectSchema
-});
-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(),
-	nodes: z.array(BoardNodeInputSchema).max(5e4).optional(),
-	connections: z.array(BoardConnectionSchema).max(5e4).optional(),
-	effects: z.array(BoardEffectSchema.omit({
-		boardId: true,
-		revision: true
-	})).optional(),
-	sequences: z.array(z.object({
-		sequence: BoardSequenceSchema.omit({
-			boardId: true,
-			revision: true
-		}),
-		clips: z.array(BoardClipSchema.omit({ sequenceId: true }))
-	})).optional()
-});
-z.object({
-	include: z.array(z.enum([
-		"nodes",
-		"connections",
-		"effects",
-		"sequences",
-		"clips",
-		"playback"
-	])).optional(),
-	viewport: z.object({
-		x: finiteSchema$1,
-		y: finiteSchema$1,
-		width: finiteSchema$1.positive(),
-		height: finiteSchema$1.positive()
-	}).optional()
-});
-/** Persisted on `boards.metadata.playback`: how a Board plays when opened. */
-const BoardPlaybackPolicySchema = z.object({
-	sequenceId: idSchema$1,
-	/** Delay before the first local playback after opening the Board, in milliseconds. */
-	delayMs: finiteSchema$1.nonnegative().default(0),
-	loop: z.boolean().default(false)
-});
-function parseBoardPlaybackPolicy(metadata) {
-	const parsed = BoardPlaybackPolicySchema.safeParse(metadata.playback);
-	return parsed.success ? parsed.data : null;
-}
-z.discriminatedUnion("type", [
-	z.object({
-		commandId: idSchema$1,
-		type: z.literal("play"),
-		sequenceId: idSchema$1,
-		position: finiteSchema$1.nonnegative().optional(),
-		timeScale: finiteSchema$1.positive().max(4).optional(),
-		shared: z.boolean().optional(),
-		seed: idSchema$1.optional()
-	}),
-	z.object({
-		commandId: idSchema$1,
-		type: z.literal("pause"),
-		playbackId: z.string().uuid()
-	}),
-	z.object({
-		commandId: idSchema$1,
-		type: z.literal("seek"),
-		playbackId: z.string().uuid(),
-		position: finiteSchema$1.nonnegative()
-	}),
-	z.object({
-		commandId: idSchema$1,
-		type: z.literal("stop"),
-		playbackId: z.string().uuid()
-	})
-]);
-const BoardContentKindSchema = z.enum([
-	"text",
-	"image",
-	"video",
-	"audio",
-	"file",
-	"json",
-	"collection"
-]);
-const BoardPortSchema = z.object({
-	id: z.string().min(1).max(120),
-	kind: BoardContentKindSchema,
-	role: z.string().min(1).max(80).optional(),
-	required: z.boolean().optional(),
-	multiple: z.boolean().optional(),
-	maxItems: z.number().int().positive().optional()
-}).strict();
-z.object({
-	inputs: z.array(BoardPortSchema),
-	outputs: z.array(BoardPortSchema)
-}).strict();
-//#endregion
-//#region ../protocol/dist/board-url.js
-const BOARD_REMOTE_URL_MAX_LENGTH = 4096;
-function parseIpv4(host) {
-	const parts = host.split(".").map(Number);
-	return parts.length === 4 && parts.every((part) => Number.isInteger(part) && part >= 0 && part <= 255) ? parts : null;
-}
-function isBlockedIpv4(host) {
-	const parts = parseIpv4(host);
-	if (!parts) return false;
-	const [first, second, third] = parts;
-	if (first === 0 || first === 10 || first === 127) return true;
-	if (first === 100 && second >= 64 && second <= 127) return true;
-	if (first === 169 && second === 254) return true;
-	if (first === 172 && second >= 16 && second <= 31) return true;
-	if (first === 192 && second === 168) return true;
-	if (first === 192 && second === 0 && (third === 0 || third === 2)) return true;
-	if (first === 192 && second === 88 && third === 99) return true;
-	if (first === 198 && (second === 18 || second === 19)) return true;
-	if (first === 198 && second === 51 && third === 100) return true;
-	if (first === 203 && second === 0 && third === 113) return true;
-	return first >= 224;
-}
-function expandIpv6(host) {
-	const [head, tail, extra] = host.toLowerCase().split("::");
-	if (extra !== void 0) return null;
-	const headParts = head ? head.split(":").filter(Boolean) : [];
-	const tailParts = tail ? tail.split(":").filter(Boolean) : [];
-	const missing = 8 - headParts.length - tailParts.length;
-	if (missing < 0 || tail === void 0 && missing !== 0) return null;
-	const parts = [
-		...headParts,
-		...Array.from({ length: missing }, () => "0"),
-		...tailParts
-	];
-	if (parts.length !== 8 || parts.some((part) => !/^[0-9a-f]{1,4}$/.test(part))) return null;
-	return parts.map((part) => part.padStart(4, "0"));
-}
-function isBlockedIpv6(host) {
-	const parts = expandIpv6(host);
-	if (!parts) return true;
-	if (parts.every((part) => part === "0000")) return true;
-	if (parts.slice(0, 7).every((part) => part === "0000") && parts[7] === "0001") return true;
-	if (parts.slice(0, 5).every((part) => part === "0000") && parts[5] === "ffff") {
-		const high = Number.parseInt(parts[6] ?? "0", 16);
-		const low = Number.parseInt(parts[7] ?? "0", 16);
-		return isBlockedIpv4(`${high >> 8}.${high & 255}.${low >> 8}.${low & 255}`);
-	}
-	if (parts.slice(0, 6).every((part) => part === "0000")) return true;
-	const first = Number.parseInt(parts[0] ?? "0", 16);
-	if ((first & 65024) === 64512) return true;
-	if ((first & 65472) === 65152 || (first & 65472) === 65216) return true;
-	if ((first & 65280) === 65280) return true;
-	return parts[0] === "2001" && parts[1] === "0db8";
-}
-function isPublicBoardRemoteAddress(value) {
-	const address = value.toLowerCase().replace(/^\[|\]$/g, "").replace(/\.$/, "");
-	if (parseIpv4(address)) return !isBlockedIpv4(address);
-	return address.includes(":") && !isBlockedIpv6(address);
-}
-function isBlockedHost(hostname) {
-	const host = hostname.toLowerCase().replace(/^\[|\]$/g, "").replace(/\.$/, "");
-	if (host === "localhost" || host.endsWith(".localhost") || host.endsWith(".local") || host.endsWith(".internal")) return true;
-	if (parseIpv4(host) || host.includes(":")) return !isPublicBoardRemoteAddress(host);
-	return false;
-}
-/**
-* Normalize a browser-loadable public HTTP(S) URL. This blocks explicit local
-* addresses; any future server-side fetcher must additionally validate DNS
-* resolution to defend against rebinding.
-*/
-function normalizeBoardRemoteUrl(value) {
-	if (typeof value !== "string") return void 0;
-	const input = value.trim();
-	if (!input || input.length > 4096) return void 0;
-	try {
-		const url = new URL(input);
-		if (url.protocol !== "https:" && url.protocol !== "http:") return void 0;
-		if (url.username || url.password || isBlockedHost(url.hostname)) return;
-		const normalized = url.toString();
-		return normalized.length <= 4096 ? normalized : void 0;
-	} catch {
-		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" });
-//#endregion
-//#region ../protocol/dist/board-document.js
-const BoardFrameSchema = z.object({
-	x: z.number().finite(),
-	y: z.number().finite(),
-	width: z.number().finite().positive(),
-	height: z.number().finite().positive(),
-	rotation: z.number().finite().default(0)
-});
-/**
-* The board camera. This is local UI state, not synced content: semantic ops
-* (see diffBoardDocuments) never describe the viewport, and the editor holds
-* the live camera separately from the persisted document. Here it only serves
-* as an initial camera hint when a document is first loaded.
-*/
-const BoardViewportSchema = z.object({
-	x: z.number().finite(),
-	y: z.number().finite(),
-	zoom: z.number().finite().min(.05).max(8)
-});
-const BoardAppearanceSchema = z.object({
-	theme: z.string().min(1).default("clean"),
-	background: z.object({
-		kind: z.enum([
-			"solid",
-			"dots",
-			"grid",
-			"image",
-			"shader",
-			"custom"
-		]).default("dots"),
-		color: z.string().optional(),
-		imageUrl: BoardRemoteUrlSchema.optional(),
-		fit: z.enum([
-			"cover",
-			"contain",
-			"repeat"
-		]).optional(),
-		position: z.enum([
-			"center",
-			"top",
-			"bottom",
-			"left",
-			"right"
-		]).optional(),
-		opacity: z.number().finite().min(0).max(1).optional()
-	}).default({ kind: "solid" }),
-	grid: z.object({
-		visible: z.boolean().default(false),
-		size: z.number().finite().min(4).default(24),
-		opacity: z.number().finite().min(0).max(1).default(.12)
-	}).default({
-		visible: false,
-		size: 24,
-		opacity: .12
-	}),
-	mood: z.enum([
-		"clean",
-		"playful",
-		"arcane",
-		"cyber",
-		"natural"
-	]).default("clean")
-});
-/** Optional visual chrome still carried by a few older shapes. */
-const BoardItemStyleSchema = z.object({
-	variant: z.string().min(1).default("default"),
-	theme: z.string().min(1).optional(),
-	accentColor: z.string().optional(),
-	size: z.enum([
-		"sm",
-		"md",
-		"lg"
-	]).default("md"),
-	emphasis: z.enum([
-		"normal",
-		"rare",
-		"epic",
-		"legendary"
-	]).default("normal"),
-	effects: z.array(z.string().min(1)).default([])
-});
-const SpaceFileRefSchema = z.object({
-	kind: z.literal("space-file"),
-	path: z.string().min(1)
-});
-const BoardMediaSnapshotSchema = z.object({
-	title: z.string().optional(),
-	mimeType: z.string().optional(),
-	size: z.number().finite().nonnegative().optional(),
-	mtimeMs: z.number().finite().nonnegative().optional(),
-	/** Intrinsic pixel size once known. */
-	naturalWidth: z.number().finite().positive().optional(),
-	naturalHeight: z.number().finite().positive().optional()
-});
-const BoardItemBaseSchema = z.object({
-	id: z.string().min(1),
-	frame: BoardFrameSchema,
-	/** When true the shape cannot be moved, resized, or deleted. */
-	locked: z.boolean().optional(),
-	style: BoardItemStyleSchema.optional(),
-	metadata: z.record(z.string(), z.unknown()).optional()
-});
-/** Freestanding text — no card chrome; its frame always follows the glyphs. */
-const BoardTextItemSchema = BoardItemBaseSchema.extend({
-	type: z.literal("text"),
-	text: z.string().default(""),
-	color: z.string().min(1).default("neutral"),
-	fontSize: z.number().finite().min(2).max(512).default(24)
-});
-const BoardGeoItemSchema = BoardItemBaseSchema.extend({
-	type: z.literal("geo"),
-	geo: z.string().min(1).default("rectangle"),
-	text: z.string().default(""),
-	color: z.string().min(1).default("brand"),
-	fillOpacity: z.number().finite().min(0).max(1).default(0)
-});
-/** A raw freehand sample. Pressure defaults to 0.5 (mouse) when absent. */
-const DrawPointSchema = z.object({
-	x: z.number().finite(),
-	y: z.number().finite(),
-	p: z.number().finite().min(0).max(1).default(.5)
-});
-/** A world-space point. */
-const BoardPointSchema = z.object({
-	x: z.number().finite(),
-	y: z.number().finite()
-});
-const BoardDrawItemSchema = BoardItemBaseSchema.extend({
-	type: z.literal("draw"),
-	points: z.array(DrawPointSchema).default([]),
-	color: z.string().min(1).default("brand"),
-	size: z.number().finite().positive().default(4)
-});
-/**
-* A free arrow — a standalone annotation stroke between two world points.
-*
-* Arrows do not relate nodes. A relation between two nodes is a
-* `BoardConnection`, which is stored separately and resolves its geometry from
-* the live node frames. Keeping the two apart is what lets an arrow be a plain
-* shape (its own frame, freely movable) while a connection stays purely
-* semantic — neither has to pretend to be the other.
-*/
-const BoardArrowItemSchema = BoardItemBaseSchema.extend({
-	type: z.literal("arrow"),
-	start: BoardPointSchema,
-	end: BoardPointSchema,
-	bend: z.number().finite().min(-.85).max(.85).default(0),
-	color: z.string().min(1).default("brand"),
-	size: z.number().finite().positive().default(BOARD_ARROW_STROKE_SIZE),
-	arrowStart: z.boolean().default(false),
-	arrowEnd: z.boolean().default(true),
-	label: z.string().default("")
-});
-/** A frame container for organising shapes. */
-const BoardFrameItemSchema = BoardItemBaseSchema.extend({
-	type: z.literal("frame"),
-	label: z.string().default("Frame"),
-	color: z.string().min(1).default("neutral")
-});
-/** Image node — space file only, natural aspect, no chrome. */
-const BoardImageItemSchema = BoardItemBaseSchema.extend({
-	type: z.literal("image"),
-	ref: SpaceFileRefSchema,
-	snapshot: BoardMediaSnapshotSchema.optional(),
-	/** Optional normalized crop in source image space (0..1). */
-	crop: z.object({
-		x: z.number().finite().min(0).max(1).default(0),
-		y: z.number().finite().min(0).max(1).default(0),
-		w: z.number().finite().min(0).max(1).default(1),
-		h: z.number().finite().min(0).max(1).default(1)
-	}).optional()
-});
-/** Video node — space file only. Playback state is local UI, never synced. */
-const BoardVideoItemSchema = BoardItemBaseSchema.extend({
-	type: z.literal("video"),
-	ref: SpaceFileRefSchema,
-	snapshot: BoardMediaSnapshotSchema.optional()
-});
-/** Audio node — space file only. Playback state is local UI, never synced. */
-const BoardAudioItemSchema = BoardItemBaseSchema.extend({
-	type: z.literal("audio"),
-	ref: SpaceFileRefSchema,
-	snapshot: BoardMediaSnapshotSchema.extend({ durationMs: z.number().finite().nonnegative().optional() }).optional()
-});
-/**
-* Cached display facts for a file card.
-*
-* Purely derived from the referenced file and versioned by `mtimeMs`, so it is a
-* cache and never a second source of truth: the workspace file remains
-* authoritative, and a stale snapshot is detectable rather than silently wrong.
-* It is stored so that opening a board renders complete cards immediately, with
-* no per-node file read on the first paint.
-*/
-const BoardFileSnapshotSchema = z.object({
-	title: z.string().optional(),
-	mimeType: z.string().optional(),
-	size: z.number().finite().nonnegative().optional(),
-	mtimeMs: z.number().finite().nonnegative().optional(),
-	/** Cleaned leading prose. Capped when written (see FILE_EXCERPT_MAX_CHARS). */
-	excerpt: z.string().optional(),
-	/** Cover image inside the space, already resolved to a workspace path. */
-	coverPath: z.string().optional(),
-	/** Cover image at an absolute https URL, as declared by the file itself. */
-	coverUrl: z.string().optional()
-});
-/**
-* File node — a thumbnail entry point to any workspace file.
-*
-* This is the fallback for every dropped file that is not natively an image or
-* video, including binaries and unknown extensions: a board should never refuse
-* a file, only present it with less detail. Presentation tiers are derived from
-* the snapshot (see filePreviewKind), not stored, so there is no display state
-* to drift from the facts.
-*/
-const BoardFileItemSchema = BoardItemBaseSchema.extend({
-	type: z.literal("file"),
-	ref: SpaceFileRefSchema,
-	snapshot: BoardFileSnapshotSchema.optional()
-});
-const BoardTaskMediaArtifactFields = {
-	id: z.string().min(1).max(240),
-	title: z.string().max(240).optional(),
-	url: BoardRemoteUrlSchema,
-	mimeType: z.string().max(160).optional()
-};
-const BoardTaskArtifactSchema = z.discriminatedUnion("type", [
-	z.object({
-		...BoardTaskMediaArtifactFields,
-		type: z.literal("image"),
-		naturalWidth: z.number().positive().optional(),
-		naturalHeight: z.number().positive().optional()
-	}).strict(),
-	z.object({
-		...BoardTaskMediaArtifactFields,
-		type: z.literal("video"),
-		previewUrl: BoardRemoteUrlSchema.optional(),
-		durationMs: z.number().int().positive().optional(),
-		naturalWidth: z.number().positive().optional(),
-		naturalHeight: z.number().positive().optional()
-	}).strict(),
-	z.object({
-		...BoardTaskMediaArtifactFields,
-		type: z.literal("audio"),
-		previewUrl: BoardRemoteUrlSchema.optional(),
-		durationMs: z.number().int().positive().optional()
-	}).strict(),
-	z.object({
-		id: z.string().min(1).max(240),
-		type: z.literal("text"),
-		title: z.string().max(240).optional(),
-		textExcerpt: z.string().min(1).max(480)
-	}).strict()
-]);
-/**
-* Cached task facts used for an immediate first paint. The task run remains the
-* source of truth and live clients refresh this projection by `taskRunId`.
-*/
-const BoardTaskSnapshotSchema = z.object({
-	taskType: z.string().min(1).max(120),
-	status: z.enum([
-		"pending",
-		"running",
-		"completed",
-		"failed"
-	]),
-	title: z.string().min(1).max(240),
-	model: z.string().max(160).optional(),
-	promptExcerpt: z.string().max(480).optional(),
-	artifactCount: z.number().int().nonnegative(),
-	artifacts: z.array(BoardTaskArtifactSchema).max(6).default([]),
-	updatedAt: z.string().optional()
-}).strict();
-/** A stable reference to a task run with a small, replaceable display cache. */
-const BoardTaskItemSchema = BoardItemBaseSchema.extend({
-	type: z.literal("task"),
-	taskRunId: z.string().min(1),
-	snapshot: BoardTaskSnapshotSchema
-});
-/**
-* A forward-compatible carrier for shape types this client does not recognise.
-* Its discriminant is the literal `"unknown"` so the item union still narrows
-* cleanly on `type`. The real type string and every original field are preserved
-* verbatim in `raw`.
-*/
-const UNKNOWN_BOARD_ITEM_TYPE = "unknown";
-const BoardItemSchema = z.any().transform((raw) => parseBoardItemLoose(raw));
-/**
-* Parse a single item leniently: known types are validated and normalised;
-* anything else becomes a lossless unknown item. Never throws on shape data —
-* a malformed known item degrades to unknown rather than failing the document.
-*/
-function parseBoardItemLoose(raw) {
-	if (!raw || typeof raw !== "object") return makeUnknownItem(raw);
-	switch (raw.type) {
-		case "image": {
-			const parsed = BoardImageItemSchema.safeParse(raw);
-			return parsed.success ? parsed.data : makeUnknownItem(raw);
-		}
-		case "video": {
-			const parsed = BoardVideoItemSchema.safeParse(raw);
-			return parsed.success ? parsed.data : makeUnknownItem(raw);
-		}
-		case "audio": {
-			const parsed = BoardAudioItemSchema.safeParse(raw);
-			return parsed.success ? parsed.data : makeUnknownItem(raw);
-		}
-		case "file": {
-			const parsed = BoardFileItemSchema.safeParse(raw);
-			return parsed.success ? parsed.data : makeUnknownItem(raw);
-		}
-		case "task": {
-			const parsed = BoardTaskItemSchema.safeParse(raw);
-			return parsed.success ? parsed.data : makeUnknownItem(raw);
-		}
-		case "text": {
-			const parsed = BoardTextItemSchema.safeParse(raw);
-			return parsed.success ? parsed.data : makeUnknownItem(raw);
-		}
-		case "geo": {
-			const parsed = BoardGeoItemSchema.safeParse(raw);
-			return parsed.success ? parsed.data : makeUnknownItem(raw);
-		}
-		case "draw": {
-			const parsed = BoardDrawItemSchema.safeParse(raw);
-			return parsed.success ? parsed.data : makeUnknownItem(raw);
-		}
-		case "arrow": {
-			const parsed = BoardArrowItemSchema.safeParse(raw);
-			return parsed.success ? parsed.data : makeUnknownItem(raw);
-		}
-		case "frame": {
-			const parsed = BoardFrameItemSchema.safeParse(raw);
-			return parsed.success ? parsed.data : makeUnknownItem(raw);
-		}
-		default: return makeUnknownItem(raw);
-	}
-}
-function makeUnknownItem(raw) {
-	const record = raw && typeof raw === "object" ? raw : {};
-	const frameParsed = BoardFrameSchema.safeParse(record.frame);
-	const styleParsed = BoardItemStyleSchema.safeParse(record.style);
-	return {
-		id: typeof record.id === "string" && record.id ? record.id : "unknown",
-		type: UNKNOWN_BOARD_ITEM_TYPE,
-		frame: frameParsed.success ? frameParsed.data : {
-			x: 0,
-			y: 0,
-			width: 120,
-			height: 80,
-			rotation: 0
-		},
-		...record.locked === true ? { locked: true } : {},
-		...styleParsed.success && record.style ? { style: styleParsed.data } : {},
-		...record.metadata && typeof record.metadata === "object" ? { metadata: record.metadata } : {},
-		raw: record
-	};
-}
-z.object({
-	kind: z.literal(BOARD_DOCUMENT_KIND),
-	version: z.literal(1),
-	appearance: BoardAppearanceSchema.default({
-		theme: "clean",
-		background: { kind: "solid" },
-		grid: {
-			visible: false,
-			size: 24,
-			opacity: .12
-		},
-		mood: "clean"
-	}),
-	viewport: BoardViewportSchema,
-	items: z.array(BoardItemSchema),
-	/**
-	* Node relations. Separate from `items` because a connection has no frame of
-	* its own — its geometry is derived from the nodes it joins, so it is a
-	* relation over the item set rather than a member of it.
-	*
-	* Connections referencing a missing node are dropped on parse: a relation to
-	* nothing is not a relation, and keeping one would let an invisible dangling
-	* edge accumulate silently. Callers that need to know write through the
-	* transaction API, which reports the reference error instead.
-	*/
-	connections: z.array(BoardConnectionSchema).default([])
+		"screen"
+	]).default("front"),
+	seed: z.string().min(1).max(160),
+	params: jsonObjectSchema$1.default({}),
+	assetRefs: z.array(BoardAssetRefSchema).default([]),
+	metadata: jsonObjectSchema$1.default({}),
+	revision: z.number().int().nonnegative()
+}).strict();
+/** The client-authored effect form: no server-owned `boardId`/`revision`. */
+const BoardEffectInputSchema = BoardEffectSchema.omit({
+	boardId: true,
+	revision: true
 });
+/** Accept a read projection in a write command while stripping server fields. */
+function parseBoardEffectInput(value) {
+	if (value && typeof value === "object" && !Array.isArray(value)) {
+		const { boardId: _boardId, revision: _revision, ...input } = value;
+		return BoardEffectInputSchema.parse(input);
+	}
+	return BoardEffectInputSchema.parse(value);
+}
 //#endregion
-//#region ../protocol/dist/board-node.js
-const BOARD_COLOR_IDS = [
+//#region ../protocol/dist/board-authoring.js
+const BOARD_AUTHORING_COLOR_IDS = [
 	"brand",
 	"neutral",
 	"black",
@@ -1441,417 +1028,273 @@ const BOARD_COLOR_IDS = [
 	"violet",
 	"rose"
 ];
-const BoardColorIdSchema = z.enum(BOARD_COLOR_IDS);
-const BOARD_GEO_KINDS = [
+const BOARD_AUTHORING_GEO_KINDS = [
 	"rectangle",
 	"rounded",
 	"ellipse",
 	"diamond",
 	"triangle"
 ];
-const BoardGeoKindSchema = z.enum(BOARD_GEO_KINDS);
-const BOARD_NATIVE_NODE_TYPES = [
-	"image",
-	"video",
-	"audio",
-	"file",
-	"task",
-	"text",
-	"geo",
-	"draw",
-	"arrow",
-	"frame"
-];
-const metadataSchema = z.record(z.string(), z.unknown());
-const commonData = {
-	locked: z.boolean().optional(),
-	metadata: metadataSchema.optional()
-};
+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: z.number().finite(),
-	y: z.number().finite(),
-	p: z.number().finite().min(0).max(1).default(.5)
+	x: finiteSchema,
+	y: finiteSchema,
+	p: finiteSchema.min(0).max(1).default(.5)
 }).strict();
 const worldPointSchema = z.object({
-	x: z.number().finite(),
-	y: z.number().finite()
+	x: finiteSchema,
+	y: finiteSchema
 }).strict();
-const strokeSizeSchema = z.number().finite().min(1).max(64);
-const mediaViewSchema = z.object({
-	title: z.string().optional(),
-	mimeType: z.string().optional(),
-	size: z.number().finite().nonnegative().optional(),
-	mtimeMs: z.number().finite().nonnegative().optional(),
-	naturalWidth: z.number().finite().positive().optional(),
-	naturalHeight: z.number().finite().positive().optional()
+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 audioViewSchema = mediaViewSchema.extend({ durationMs: z.number().finite().nonnegative().optional() });
-const dataSchemas = {
-	text: z.object({
-		...commonData,
-		text: z.string().default(""),
-		color: BoardColorIdSchema.default("neutral"),
-		fontSize: z.number().finite().min(2).max(512).default(24)
-	}).strict(),
-	geo: z.object({
-		...commonData,
-		geo: BoardGeoKindSchema.default("rectangle"),
+const BoardItemStyleSchema = z.object({
+	color: z.enum(BOARD_AUTHORING_COLOR_IDS).optional(),
+	strokeWidth: finiteSchema.min(1).max(64).optional(),
+	fillOpacity: finiteSchema.min(0).max(1).optional()
+}).strict();
+const sourceSnapshotSchema = z.record(z.string(), z.unknown());
+function isSafeBoardSourcePath(value) {
+	return value.length > 0 && value.length <= 4096 && !value.startsWith("/") && !value.startsWith("\\") && !value.includes("\\") && value.split("/").every((part) => part.length > 0 && part !== "." && part !== "..");
+}
+const BoardItemSourceSchema = z.object({
+	kind: z.literal("space-file"),
+	path: z.string().refine(isSafeBoardSourcePath, "source path must be a safe relative Board file path"),
+	snapshot: sourceSnapshotSchema.optional()
+}).strict();
+const 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(""),
-		color: BoardColorIdSchema.default("brand"),
-		fillOpacity: z.number().finite().min(0).max(1).default(0)
-	}).strict(),
-	draw: z.object({
-		...commonData,
-		points: z.array(pointSchema).min(1),
-		color: BoardColorIdSchema.default("brand"),
-		size: strokeSizeSchema.default(4)
-	}).strict(),
-	arrow: z.object({
-		...commonData,
+		fontSize: finiteSchema.min(2).max(512).default(24)
+	}).strict()
+}).strict();
+const BoardGeoAuthoringItemSchema = z.object({
+	...styledBaseFields,
+	type: z.literal("geo"),
+	props: z.object({
+		shape: z.enum(BOARD_AUTHORING_GEO_KINDS).default("rectangle"),
+		text: z.string().default("")
+	}).strict()
+}).strict();
+const BoardDrawAuthoringItemSchema = z.object({
+	...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: z.number().finite().min(-.85).max(.85).default(0),
-		color: BoardColorIdSchema.default("brand"),
-		size: strokeSizeSchema.default(BOARD_ARROW_STROKE_SIZE),
+		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 builtinItemSchemas = [
+	BoardTextAuthoringItemSchema,
+	BoardGeoAuthoringItemSchema,
+	BoardDrawAuthoringItemSchema,
+	BoardArrowAuthoringItemSchema,
+	BoardFrameAuthoringItemSchema,
+	z.object({
+		...fileBackedFields,
+		type: z.literal("image"),
+		props: z.object({ crop: cropSchema.optional() }).strict()
+	}).strict(),
+	z.object({
+		...fileBackedFields,
+		type: z.literal("video"),
+		props: z.object({}).strict()
 	}).strict(),
-	frame: z.object({
-		...commonData,
-		label: z.string().default("Frame"),
-		color: BoardColorIdSchema.default("neutral")
+	z.object({
+		...fileBackedFields,
+		type: z.literal("audio"),
+		props: z.object({}).strict()
 	}).strict(),
-	image: z.object({
-		...commonData,
-		crop: z.object({
-			x: z.number().finite().min(0).max(1),
-			y: z.number().finite().min(0).max(1),
-			w: z.number().finite().min(0).max(1),
-			h: z.number().finite().min(0).max(1)
-		}).strict().optional()
+	z.object({
+		...fileBackedFields,
+		type: z.literal("file"),
+		props: z.object({}).strict()
 	}).strict(),
-	video: z.object(commonData).strict(),
-	audio: z.object(commonData).strict(),
-	file: z.object(commonData).strict(),
-	task: z.object({
-		...commonData,
-		taskRunId: z.string().min(1)
+	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 fileViewSchema = z.object({
-	title: z.string().optional(),
-	mimeType: z.string().optional(),
-	size: z.number().finite().nonnegative().optional(),
-	mtimeMs: z.number().finite().nonnegative().optional(),
-	excerpt: z.string().optional(),
-	coverPath: z.string().optional(),
-	coverUrl: z.string().url().optional()
+];
+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 taskViewSchema = BoardTaskSnapshotSchema;
-const emptyViewSchema = z.object({}).strict();
-const viewSchemas = {
-	image: mediaViewSchema,
-	video: mediaViewSchema,
-	audio: audioViewSchema,
-	file: fileViewSchema,
-	task: taskViewSchema,
-	text: emptyViewSchema,
-	geo: emptyViewSchema,
-	draw: emptyViewSchema,
-	arrow: emptyViewSchema,
-	frame: emptyViewSchema
-};
-const nodeEnvelopeSchema = z.object({
-	nodeId: z.string().min(1).max(160),
-	type: z.string().min(1).max(40),
-	parentId: z.string().min(1).max(160).nullable(),
-	orderKey: z.string().max(4096).nullable(),
-	x: z.number().finite(),
-	y: z.number().finite(),
-	width: z.number().finite().positive(),
-	height: z.number().finite().positive(),
-	rotation: z.number().finite(),
-	refKind: z.string().max(40).nullable(),
-	refPath: z.string().max(4096).nullable(),
-	refUrl: z.string().max(4096).nullable(),
-	view: z.record(z.string(), z.unknown()),
-	style: z.record(z.string(), z.unknown()),
-	data: z.record(z.string(), z.unknown())
+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();
-function jsonSchema(schema) {
-	return z.toJSONSchema(schema);
-}
-const BOARD_NODE_CONTRACT = {
-	types: BOARD_NATIVE_NODE_TYPES,
-	colors: BOARD_COLOR_IDS,
-	geos: BOARD_GEO_KINDS,
-	coordinates: {
-		frame: "world",
-		drawPoints: "frame-local",
-		arrowEndpoints: "world"
-	},
-	references: {
-		nodeTypes: [
-			"image",
-			"video",
-			"audio",
-			"file"
-		],
-		kind: "space_file",
-		pathField: "refPath"
-	},
-	schemas: {
-		envelope: jsonSchema(nodeEnvelopeSchema),
-		data: Object.fromEntries(BOARD_NATIVE_NODE_TYPES.map((type) => [type, jsonSchema(dataSchemas[type])])),
-		view: Object.fromEntries(BOARD_NATIVE_NODE_TYPES.map((type) => [type, jsonSchema(viewSchemas[type])]))
-	}
+/** 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 BoardConnectionInputSchema = BoardConnectionSchema;
+const stripServerFields = (value) => {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+	const { boardId: _boardId, revision: _revision, ...input } = value;
+	return input;
 };
-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
-//#region ../protocol/dist/realtime/board-awareness.js
-const idSchema = z.string().min(1).max(160);
-const finiteSchema = z.number().finite();
-const BoardAwarenessPointSchema = z.object({
-	x: finiteSchema,
-	y: finiteSchema
-});
-const BoardAwarenessDrawPointSchema = BoardAwarenessPointSchema.extend({ p: finiteSchema.min(0).max(1) });
-const BoardAwarenessFrameSchema = z.object({
-	x: finiteSchema,
-	y: finiteSchema,
-	width: finiteSchema.positive(),
-	height: finiteSchema.positive(),
-	rotation: finiteSchema
-});
-const BoardAwarenessNodePreviewSchema = z.object({
-	nodeId: idSchema,
-	frame: BoardAwarenessFrameSchema,
-	/** Live endpoints of a free arrow being dragged. */
-	arrow: z.object({
-		start: BoardAwarenessPointSchema,
-		end: BoardAwarenessPointSchema,
-		bend: finiteSchema
-	}).optional()
-});
-const BoardAwarenessStateUpdateSchema = z.object({
-	type: z.literal("state"),
-	client: z.object({ formFactor: z.enum(["desktop", "mobile"]) }).optional(),
-	cursor: BoardAwarenessPointSchema.extend({ pointerType: z.enum([
-		"mouse",
-		"pen",
-		"touch"
-	]) }).nullable(),
-	tool: z.string().min(1).max(40),
-	selection: z.object({
-		ids: z.array(idSchema).max(64),
-		count: z.number().int().nonnegative().max(5e4),
-		bounds: BoardAwarenessFrameSchema.nullable()
-	}),
-	editingId: idSchema.nullable()
-});
-const BoardAwarenessGestureSchema = z.discriminatedUnion("kind", [
+const BoardEffectCommandInputSchema = z.preprocess(stripServerFields, BoardEffectInputSchema);
+const BoardCompositionCommandInputSchema = z.preprocess(stripServerFields, BoardCompositionInputSchema);
+const BoardSemanticCommandSchema = z.discriminatedUnion("type", [
 	z.object({
-		kind: z.literal("draw"),
-		id: idSchema,
-		nodeId: idSchema,
-		color: z.string().min(1).max(64),
-		size: finiteSchema.positive().max(256),
-		from: z.number().int().nonnegative().max(1e5),
-		points: z.array(BoardAwarenessDrawPointSchema).min(1).max(64)
-	}),
+		type: z.literal("board.patch"),
+		patch: z.object({
+			title: z.string().min(1).max(255).optional(),
+			metadata: jsonObjectSchema.nullable().optional(),
+			metadataPatch: jsonObjectSchema.optional()
+		}).strict().refine((patch) => Object.keys(patch).length > 0, "board patch is empty")
+	}).strict(),
 	z.object({
-		kind: z.literal("arrow"),
-		id: idSchema,
-		nodeId: idSchema,
-		start: BoardAwarenessPointSchema,
-		current: BoardAwarenessPointSchema,
-		color: z.string().min(1).max(64),
-		size: finiteSchema.positive().max(256).default(BOARD_ARROW_STROKE_SIZE)
-	}),
+		type: z.literal("item.create"),
+		item: BoardAuthoringItemSchema
+	}).strict(),
 	z.object({
-		kind: z.literal("box"),
-		id: idSchema,
-		nodeId: idSchema,
-		shape: z.enum(["geo", "frame"]),
-		start: BoardAwarenessPointSchema,
-		current: BoardAwarenessPointSchema,
-		color: z.string().min(1).max(64),
-		geo: z.string().min(1).max(40)
-	}),
+		type: z.literal("item.patch"),
+		itemId: idSchema,
+		patch: BoardItemPatchSchema
+	}).strict(),
 	z.object({
-		kind: z.literal("connection"),
-		id: idSchema,
-		sourceNodeId: idSchema,
-		targetNodeId: idSchema.nullable(),
-		current: BoardAwarenessPointSchema,
-		color: z.string().min(1).max(64),
-		size: finiteSchema.positive().max(256).default(BOARD_CONNECTION_STROKE_SIZE)
-	}),
+		type: z.literal("item.replace"),
+		itemId: idSchema,
+		item: BoardAuthoringItemSchema
+	}).strict(),
 	z.object({
-		kind: z.literal("transform"),
-		id: idSchema,
-		mode: z.enum([
-			"translate",
-			"resize",
-			"rotate",
-			"arrow",
-			"connection"
-		]),
-		nodes: z.array(BoardAwarenessNodePreviewSchema).max(64),
-		bounds: BoardAwarenessFrameSchema.nullable()
-	})
-]);
-const BoardAwarenessUpdateSchema = z.discriminatedUnion("type", [
-	BoardAwarenessStateUpdateSchema,
+		type: z.literal("item.delete"),
+		itemId: idSchema,
+		cascade: z.boolean().default(false)
+	}).strict(),
 	z.object({
-		type: z.literal("gesture"),
-		gesture: BoardAwarenessGestureSchema
-	}),
+		type: z.literal("item.reorder"),
+		itemId: idSchema,
+		index: z.number().int().nonnegative()
+	}).strict(),
 	z.object({
-		type: z.literal("gesture.end"),
-		gestureId: idSchema,
-		resultingNodeIds: z.array(idSchema).max(64)
-	}),
+		type: z.literal("connection.create"),
+		connection: BoardConnectionInputSchema
+	}).strict(),
 	z.object({
-		type: z.literal("gesture.cancel"),
-		gestureId: idSchema
-	})
-]);
-const BoardAwarenessClientPayloadSchema = z.object({
-	spaceId: z.string().uuid(),
-	boardId: z.string().uuid(),
-	seq: z.number().int().nonnegative(),
-	update: BoardAwarenessUpdateSchema
-});
-//#endregion
-//#region ../protocol/dist/public-identifiers.js
-const USERNAME_PATTERN = /^(?!-)(?!.*--)[a-z0-9-]{1,39}(?<!-)$/;
-const SPACE_SLUG_PATTERN = /^[a-z0-9](?:[a-z0-9_-]{0,78}[a-z0-9])?$/;
-/**
-* Platform-owned path segments that must not be newly assigned to public
-* identities. Existing stored values remain readable through parse helpers.
-*/
-const RESERVED_PLATFORM_PATH_SEGMENTS = Object.freeze([
-	"admin",
-	"api",
-	"assets",
-	"auth",
-	"callback",
-	"changelog",
-	"docs",
-	"explore",
-	"invite",
-	"landing",
-	"login",
-	"logout",
-	"new",
-	"org",
-	"pricing",
-	"pwa",
-	"referrals",
-	"sessions",
-	"settings",
-	"spaces",
-	"static",
-	"teams",
-	"trending",
-	"u",
-	"user",
-	"users",
-	"work-auth"
+		type: z.literal("connection.patch"),
+		connectionId: idSchema,
+		patch: BoardConnectionPatchSchema
+	}).strict(),
+	z.object({
+		type: z.literal("connection.delete"),
+		connectionId: idSchema
+	}).strict(),
+	z.object({
+		type: z.literal("effect.apply"),
+		effect: BoardEffectCommandInputSchema
+	}).strict(),
+	z.object({
+		type: z.literal("effect.delete"),
+		effectId: idSchema
+	}).strict(),
+	z.object({
+		type: z.literal("composition.apply"),
+		composition: BoardCompositionCommandInputSchema
+	}).strict(),
+	z.object({
+		type: z.literal("composition.delete"),
+		compositionId: idSchema
+	}).strict()
 ]);
-new Set(RESERVED_PLATFORM_PATH_SEGMENTS);
-[...RESERVED_PLATFORM_PATH_SEGMENTS];
-function parseUsername(value) {
-	if (value === null || value === void 0) return null;
-	const normalized = value.trim().toLowerCase();
-	return USERNAME_PATTERN.test(normalized) ? normalized : null;
-}
-function parseSpaceSlug(value) {
-	if (value === null || value === void 0) return null;
-	const normalized = value.trim();
-	return SPACE_SLUG_PATTERN.test(normalized) ? normalized : null;
-}
+const BoardSemanticMutationSchema = z.object({
+	mutationId: idSchema,
+	baseVersion: z.number().int().nonnegative(),
+	clientId: idSchema.optional(),
+	undoGroupId: idSchema.optional(),
+	/** Validate (including server-side reference checks) without writing. */
+	dryRun: z.boolean().default(false),
+	commands: z.array(BoardSemanticCommandSchema).min(1).max(5e4)
+}).strict();
+z.object({
+	include: z.array(z.enum([
+		"items",
+		"connections",
+		"effects",
+		"compositions",
+		"playback"
+	])).optional(),
+	itemIds: z.array(idSchema).max(5e4).optional(),
+	connectionIds: z.array(idSchema).max(5e4).optional(),
+	effectIds: z.array(idSchema).max(5e4).optional(),
+	compositionIds: z.array(idSchema).max(5e4).optional(),
+	viewport: z.object({
+		x: finiteSchema,
+		y: finiteSchema,
+		width: finiteSchema.positive(),
+		height: finiteSchema.positive()
+	}).optional()
+}).strict();
 //#endregion
 //#region ../protocol/dist/ui-command.js
 /**
@@ -1887,14 +1330,14 @@ const parseUiCommandId = (value) => {
 	const trimmed = value.trim();
 	return UI_COMMAND_ID_RE.test(trimmed) ? trimmed : null;
 };
-const isRecord$2 = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
+const isRecord$1 = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
 const asTrimmed = (value) => {
 	if (typeof value !== "string") return null;
 	const trimmed = value.trim();
 	return trimmed ? trimmed : null;
 };
 const parseLaunch = (value) => {
-	if (!isRecord$2(value)) return void 0;
+	if (!isRecord$1(value)) return void 0;
 	const search = asTrimmed(value.search);
 	const hash = asTrimmed(value.hash);
 	if (!search && !hash) return void 0;
@@ -1912,7 +1355,7 @@ const measureUiCommandPayload = (value) => {
 	}
 };
 const parseUiCommand = (input) => {
-	if (!isRecord$2(input)) return {
+	if (!isRecord$1(input)) return {
 		command: null,
 		error: "command must be an object"
 	};
@@ -1921,7 +1364,7 @@ const parseUiCommand = (input) => {
 		error: "command.type must be one of: preview.show"
 	};
 	const preview = input.preview;
-	if (!isRecord$2(preview)) return {
+	if (!isRecord$1(preview)) return {
 		command: null,
 		error: "command.preview is required"
 	};
@@ -1978,7 +1421,7 @@ const parseUiCommand = (input) => {
 	}
 	let request;
 	if (input.request !== void 0 && input.request !== null) {
-		if (!isRecord$2(input.request)) return {
+		if (!isRecord$1(input.request)) return {
 			command: null,
 			error: "command.request must be an object"
 		};
@@ -2030,303 +1473,12 @@ const parseUiCommand = (input) => {
 	};
 };
 //#endregion
-//#region ../protocol/dist/work-surface.js
-const WORK_SURFACE_PROTOCOL = "cohub.surface";
-const WORK_SURFACE_READY_TIMEOUT_MS = 1e4;
-const WORK_SURFACE_REQUEST_TIMEOUT_MS = 15e3;
-const WORK_COMPOSER_CHIP_KEY_MAX_LENGTH = 80;
-const WORK_COMPOSER_CHIP_LABEL_MAX_LENGTH = 120;
-const WORK_COMPOSER_CHIP_CONTENT_MAX_BYTES = 32 * 1024;
-const isRecord$1 = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
-const isSurfaceEnvelope = (value) => isRecord$1(value) && value.protocol === "cohub.surface" && value.version === 1;
-const parseWorkSurfaceReady = (value) => {
-	if (!isSurfaceEnvelope(value) || value.type !== "ready") return null;
-	const methods = Array.isArray(value.methods) ? value.methods.filter((method) => typeof method === "string" && Boolean(method)) : [];
-	return {
-		protocol: WORK_SURFACE_PROTOCOL,
-		version: 1,
-		type: "ready",
-		methods
-	};
-};
-const parseWorkSurfaceResponse = (value) => {
-	if (!isSurfaceEnvelope(value) || value.type !== "response") return null;
-	if (typeof value.requestId !== "string" || !value.requestId) return null;
-	const error = isRecord$1(value.error) ? {
-		code: typeof value.error.code === "string" && value.error.code ? value.error.code : "surface_error",
-		message: typeof value.error.message === "string" ? value.error.message : "Work surface call failed"
-	} : void 0;
-	return {
-		protocol: WORK_SURFACE_PROTOCOL,
-		version: 1,
-		type: "response",
-		requestId: value.requestId,
-		ok: value.ok === true,
-		...error ? { error } : {}
-	};
-};
-const parseComposerChipKey = (value) => {
-	if (typeof value !== "string") return null;
-	const key = value.trim();
-	if (!key || key.length > 80) return null;
-	return key;
-};
-const parseWorkComposerChipSet = (value) => {
-	if (!isSurfaceEnvelope(value) || value.type !== "composer.chip.set" || !isRecord$1(value.chip)) return null;
-	const key = parseComposerChipKey(value.chip.key);
-	if (!key || typeof value.chip.label !== "string" || typeof value.chip.content !== "string") return null;
-	const label = value.chip.label.trim();
-	if (!label || label.length > 120) return null;
-	if (!value.chip.content.trim()) return null;
-	if (new TextEncoder().encode(value.chip.content).length > 32768) return null;
-	return {
-		protocol: WORK_SURFACE_PROTOCOL,
-		version: 1,
-		type: "composer.chip.set",
-		chip: {
-			key,
-			label,
-			content: value.chip.content
-		}
-	};
-};
-const parseWorkComposerChipClear = (value) => {
-	if (!isSurfaceEnvelope(value) || value.type !== "composer.chip.clear") return null;
-	const key = parseComposerChipKey(value.key);
-	return key ? {
-		protocol: WORK_SURFACE_PROTOCOL,
-		version: 1,
-		type: "composer.chip.clear",
-		key
-	} : null;
-};
-const parseWorkSurfaceRequest = (value) => {
-	if (!isSurfaceEnvelope(value) || value.type !== "request") return null;
-	if (typeof value.requestId !== "string" || !value.requestId) return null;
-	if (typeof value.method !== "string" || !value.method) return null;
-	const commandId = parseUiCommandId(value.commandId);
-	if (!commandId) return null;
-	return {
-		protocol: WORK_SURFACE_PROTOCOL,
-		version: 1,
-		type: "request",
-		requestId: value.requestId,
-		method: value.method,
-		...value.input === void 0 ? {} : { input: value.input },
-		commandId
-	};
-};
-const buildWorkSurfaceReady = (methods) => ({
-	protocol: WORK_SURFACE_PROTOCOL,
-	version: 1,
-	type: "ready",
-	methods: [...methods]
-});
-const buildWorkSurfaceRequest = (input) => ({
-	protocol: WORK_SURFACE_PROTOCOL,
-	version: 1,
-	type: "request",
-	...input
-});
-const buildWorkSurfaceResponse = (input) => ({
-	protocol: WORK_SURFACE_PROTOCOL,
-	version: 1,
-	type: "response",
-	...input
-});
-const buildWorkComposerChipSet = (chip) => ({
-	protocol: WORK_SURFACE_PROTOCOL,
-	version: 1,
-	type: "composer.chip.set",
-	chip
-});
-const buildWorkComposerChipClear = (key) => ({
-	protocol: WORK_SURFACE_PROTOCOL,
-	version: 1,
-	type: "composer.chip.clear",
-	key
-});
-//#endregion
-//#region src/board/core/draw-geometry.ts
-/** Radius of a sample in world units given the stroke size and pressure. */
-function sampleRadius(size, pressure) {
-	const clamped = Math.min(1, Math.max(0, pressure));
-	return Math.max(.5, size / 2 * (.5 + clamped));
-}
-/** Axis-aligned bounds of a stroke in its local space, padded by stroke width. */
-function computeDrawBounds(points, size) {
-	if (points.length === 0) return {
-		x: 0,
-		y: 0,
-		width: 1,
-		height: 1
-	};
-	let minX = Number.POSITIVE_INFINITY;
-	let minY = Number.POSITIVE_INFINITY;
-	let maxX = Number.NEGATIVE_INFINITY;
-	let maxY = Number.NEGATIVE_INFINITY;
-	for (const point of points) {
-		const r = sampleRadius(size, point.p);
-		minX = Math.min(minX, point.x - r);
-		minY = Math.min(minY, point.y - r);
-		maxX = Math.max(maxX, point.x + r);
-		maxY = Math.max(maxY, point.y + r);
-	}
-	return {
-		x: minX,
-		y: minY,
-		width: Math.max(1, maxX - minX),
-		height: Math.max(1, maxY - minY)
-	};
-}
-//#endregion
-//#region src/board/nodes.ts
-var BoardInputError = class extends Error {
-	code = "INVALID_BOARD_NODE";
-	diagnostics;
-	body;
-	constructor(diagnostics) {
-		const message = diagnostics[0]?.message ?? "Invalid Board node";
-		super(message);
-		this.name = "BoardInputError";
-		this.diagnostics = diagnostics;
-		this.body = {
-			code: this.code,
-			message,
-			diagnostics
-		};
-	}
-};
-function baseNode(spec, frame) {
-	return {
-		nodeId: spec.id,
-		type: spec.type,
-		parentId: spec.parentId ?? null,
-		orderKey: spec.orderKey ?? null,
-		x: frame.x,
-		y: frame.y,
-		width: frame.width,
-		height: frame.height,
-		rotation: frame.rotation ?? 0,
-		refKind: null,
-		refPath: null,
-		refUrl: null,
-		view: {},
-		style: spec.style ?? {},
-		data: {}
-	};
-}
-function arrowFrame(start, end) {
-	const padding = 16;
-	return {
-		x: Math.min(start.x, end.x) - padding,
-		y: Math.min(start.y, end.y) - padding,
-		width: Math.max(1, Math.abs(end.x - start.x) + padding * 2),
-		height: Math.max(1, Math.abs(end.y - start.y) + padding * 2)
-	};
-}
-/**
-* Create one validated wire node from semantic Board input.
-*
-* Box nodes take an explicit world-space frame. Draw samples and arrow endpoints
-* take world coordinates; the builder derives their frame and local storage form.
-*/
-function createBoardNode(spec) {
-	let node;
-	if (spec.type === "draw") {
-		const size = spec.size ?? 4;
-		const worldPoints = spec.points.map((point) => ({
-			x: point.x,
-			y: point.y,
-			p: point.p ?? .5
-		}));
-		const bounds = computeDrawBounds(worldPoints, size);
-		node = baseNode(spec, bounds);
-		node.data = {
-			points: worldPoints.map((point) => ({
-				x: point.x - bounds.x,
-				y: point.y - bounds.y,
-				p: point.p
-			})),
-			color: spec.color ?? "brand",
-			size
-		};
-	} else if (spec.type === "arrow") {
-		node = baseNode(spec, arrowFrame(spec.start, spec.end));
-		node.data = {
-			start: spec.start,
-			end: spec.end,
-			bend: spec.bend ?? 0,
-			color: spec.color ?? "brand",
-			size: spec.size ?? 2.5,
-			arrowStart: spec.arrowStart ?? false,
-			arrowEnd: spec.arrowEnd ?? true,
-			label: spec.label ?? ""
-		};
-	} else {
-		node = baseNode(spec, spec.frame);
-		switch (spec.type) {
-			case "text":
-				node.data = {
-					text: spec.text ?? "",
-					color: spec.color ?? "neutral",
-					fontSize: spec.fontSize ?? 24
-				};
-				break;
-			case "geo":
-				node.data = {
-					geo: spec.geo ?? "rectangle",
-					text: spec.text ?? "",
-					color: spec.color ?? "brand",
-					fillOpacity: spec.fillOpacity ?? 0
-				};
-				break;
-			case "frame":
-				node.data = {
-					label: spec.label ?? "Frame",
-					color: spec.color ?? "neutral"
-				};
-				break;
-			case "image":
-				node.refKind = "space_file";
-				node.refPath = spec.path;
-				node.view = spec.snapshot ?? {};
-				node.data = spec.crop ? { crop: spec.crop } : {};
-				break;
-			case "video":
-			case "audio":
-				node.refKind = "space_file";
-				node.refPath = spec.path;
-				node.view = spec.snapshot ?? {};
-				break;
-			case "file":
-				node.refKind = "space_file";
-				node.refPath = spec.path;
-				node.view = spec.snapshot ?? {};
-				break;
-			case "task":
-				node.view = spec.snapshot;
-				node.data = { taskRunId: spec.taskRunId };
-				break;
-		}
-	}
-	assertBoardNodes([node]);
-	return node;
-}
-function validateBoardNodes(nodes, path = "nodes") {
-	return nodes.flatMap((node, index) => validateBoardNodeInput(node, `${path}.${index}`));
-}
-function assertBoardNodes(nodes, path = "nodes") {
-	const diagnostics = validateBoardNodes(nodes, path);
-	if (diagnostics.length > 0) throw new BoardInputError(diagnostics);
-}
-function assertBoardTransactionNodeCreates(operations) {
-	const diagnostics = operations.flatMap((operation, index) => {
-		if (operation.type !== "node.create") return [];
-		const payload = operation.payload;
-		return payload.node ? validateBoardNodeInput(payload.node, `operations.${index}.payload.node`) : [];
+//#region src/realtime.ts
+function ensureRealtimeConnected(websocketClient) {
+	if (websocketClient.state === "open" || websocketClient.state === "connecting" || websocketClient.state === "reconnecting") return;
+	websocketClient.connect().catch((error) => {
+		console.error("[CohubClient] Failed to connect realtime websocket:", error);
 	});
-	if (diagnostics.length > 0) throw new BoardInputError(diagnostics);
 }
 //#endregion
 //#region src/session-patch-reducer.ts
@@ -3339,26 +2491,6 @@ const getFilenameFromContentDisposition = (value) => {
 	return value.match(/filename="?([^";]+)"?/i)?.[1] ?? null;
 };
 /**
-* A board transaction rejected by the server. `status`/`code` let callers
-* distinguish a recoverable version conflict (409 / "VERSION_CONFLICT") from
-* transient failures, so they can rebase and retry instead of surfacing an error.
-*/
-var BoardTransactionError = class extends Error {
-	status;
-	code;
-	body;
-	constructor(message, status, code, body, options) {
-		super(message, options);
-		this.status = status;
-		this.code = code;
-		this.body = body;
-		this.name = "BoardTransactionError";
-	}
-	get isVersionConflict() {
-		return this.code === "VERSION_CONFLICT";
-	}
-};
-/**
 * Identifier for a client-authored Board entity (connection id, transaction id).
 *
 * `crypto.randomUUID` is used where available and falls back to a random string
@@ -3973,7 +3105,7 @@ var SpaceEventsApi = class {
 				handler(event);
 				return;
 			}
-			if (type === "board.transaction.applied" && event.type === "board.transaction.applied") {
+			if (type === "board.changed" && event.type === "board.changed") {
 				handler(event);
 				return;
 			}
@@ -4331,10 +3463,10 @@ var BoardRealtimeClient = class {
 		const releaseRoom = this.websocketClient.retainRooms([getRealtimeSpaceRoom(this.spaceId), getRealtimeBoardRoom(this.boardId)]);
 		const unsubscribe = this.websocketClient.on("event", (event) => {
 			if (event.spaceId !== this.spaceId) return;
-			if (event.type === "board.transaction.applied" && event.payload.boardId === this.boardId) {
-				const transactionEvent = event;
-				handlers.event?.(transactionEvent);
-				handlers.transaction?.(transactionEvent);
+			if (event.type === "board.changed" && event.payload.boardId === this.boardId) {
+				const changedEvent = event;
+				handlers.event?.(changedEvent);
+				handlers.changed?.(changedEvent);
 			}
 			if (event.type === "board.awareness.updated" && event.payload.boardId === this.boardId) {
 				const awarenessEvent = event;
@@ -4355,7 +3487,7 @@ var BoardRealtimeClient = class {
 		};
 	}
 	on(type, handler) {
-		if (type === "transaction") return this.subscribe({ transaction: handler });
+		if (type === "changed") return this.subscribe({ changed: handler });
 		if (type === "awareness") return this.subscribe({ awareness: handler });
 		return this.subscribe({ playback: handler });
 	}
@@ -4373,45 +3505,22 @@ var BoardClient = class {
 		this.boards = new SpaceBoardsApi(transport, spaceId, websocketClient);
 		this.realtime = new BoardRealtimeClient(websocketClient, spaceId, id);
 	}
-	inspect(input = {}, customFetch) {
-		return this.boards.inspect(this.id, input, customFetch);
-	}
 	capabilities(customFetch) {
 		return this.boards.capabilities(this.id, customFetch);
 	}
 	summary(customFetch) {
 		return this.boards.summary(this.id, customFetch);
 	}
-	async mutate(input) {
-		const retries = input.retries ?? 1;
-		if (!Number.isSafeInteger(retries) || retries < 0 || retries > 3) throw new RangeError("Board mutation retries must be an integer from 0 to 3");
-		for (let attempt = 0;; attempt += 1) {
-			const current = await this.inspect({ include: input.include ?? [] });
-			const operations = await input.build(current);
-			if (operations.length === 0) return current;
-			try {
-				return await this.apply({
-					txId: randomBoardId(),
-					baseVersion: current.board.version,
-					operations
-				}, { compact: true });
-			} catch (cause) {
-				if (!(cause instanceof BoardTransactionError) || !cause.isVersionConflict || attempt >= retries) throw cause;
-			}
-		}
+	authoring(input = {}, customFetch) {
+		return this.boards.authoring(this.id, input, customFetch);
 	}
-	validate(transaction) {
-		return this.boards.validate({
-			...transaction,
-			boardId: this.id
+	mutateSemantic(input) {
+		return this.boards.mutateSemantic(this.id, {
+			...input,
+			mutationId: input.mutationId ?? randomBoardId(),
+			dryRun: input.dryRun ?? false
 		});
 	}
-	apply(transaction, options) {
-		return this.boards.apply({
-			...transaction,
-			boardId: this.id
-		}, options);
-	}
 	updateAwareness(seq, update) {
 		if (!this.websocketClient) return Promise.resolve();
 		return this.websocketClient.updateBoardAwareness({
@@ -4421,91 +3530,6 @@ var BoardClient = class {
 			update
 		});
 	}
-	playback(command) {
-		return this.boards.playback(this.id, command);
-	}
-	/**
-	* Read the Board's relations.
-	*
-	* A dedicated read rather than a filter over `inspect()`: a caller that wants
-	* the graph should not have to fetch every node's geometry to get it.
-	*/
-	async connections(customFetch) {
-		return (await this.boards.inspect(this.id, { include: ["connections"] }, customFetch)).connections;
-	}
-	/**
-	* Connections touching a node, in either direction.
-	*
-	* Filtered client-side from the Board's relation set, which is a single read and
-	* bounded by the Board rather than by the node's degree.
-	*/
-	async connectionsForNode(nodeId, customFetch) {
-		return (await this.connections(customFetch)).filter((connection) => connection.source.nodeId === nodeId || connection.target.nodeId === nodeId);
-	}
-	/**
-	* Connect two nodes.
-	*
-	* Wraps the transaction so the common case is one call: the caller supplies the
-	* two nodes and, optionally, the relation. `baseVersion` still has to be the
-	* version the caller last read, because a relation is only meaningful against
-	* the node set it was authored on.
-	*/
-	connect(input) {
-		const connection = createBoardConnection({
-			id: input.id ?? randomBoardId(),
-			sourceNodeId: input.sourceNodeId,
-			targetNodeId: input.targetNodeId,
-			...input.relation === void 0 ? {} : { relation: input.relation },
-			...input.direction === void 0 ? {} : { direction: input.direction },
-			...input.label === void 0 ? {} : { label: input.label },
-			...input.sourcePortId === void 0 ? {} : { sourcePortId: input.sourcePortId },
-			...input.targetPortId === void 0 ? {} : { targetPortId: input.targetPortId }
-		});
-		return this.apply({
-			txId: input.txId ?? randomBoardId(),
-			baseVersion: input.baseVersion,
-			operations: [{
-				type: "connection.create",
-				payload: { connection }
-			}]
-		});
-	}
-	/** Remove a connection. The nodes it joined are untouched. */
-	disconnect(input) {
-		return this.apply({
-			txId: input.txId ?? randomBoardId(),
-			baseVersion: input.baseVersion,
-			operations: [{
-				type: "connection.delete",
-				payload: { connectionId: input.connectionId }
-			}]
-		});
-	}
-	/**
-	* Delete a node together with every relation that names it.
-	*
-	* The server refuses to orphan a relation, so the cascade is explicit and lands
-	* in one transaction: one undo step restores the node and its edges together.
-	* `connections` is the relation set the caller already read, so this stays a
-	* single round-trip.
-	*/
-	deleteNodeWithConnections(input) {
-		const incident = input.connections.filter((connection) => connection.source.nodeId === input.nodeId || connection.target.nodeId === input.nodeId);
-		return this.apply({
-			txId: input.txId ?? randomBoardId(),
-			baseVersion: input.baseVersion,
-			operations: [...incident.map((connection) => ({
-				type: "connection.delete",
-				payload: {
-					connectionId: connection.id,
-					reason: "node-cascade"
-				}
-			})), {
-				type: "node.delete",
-				payload: { nodeId: input.nodeId }
-			}]
-		});
-	}
 	play(command) {
 		return this.boards.play(this.id, command);
 	}
@@ -4522,7 +3546,7 @@ var BoardClient = class {
 		return this.realtime.subscribe(handlers);
 	}
 	on(type, handler) {
-		if (type === "transaction") return this.realtime.on("transaction", handler);
+		if (type === "changed") return this.realtime.on("changed", handler);
 		if (type === "awareness") return this.realtime.on("awareness", handler);
 		return this.realtime.on("playback", handler);
 	}
@@ -4539,20 +3563,34 @@ var SpaceBoardsApi = class {
 	byId(boardId) {
 		return new BoardClient(this.spaceId, boardId, this.transport, this.websocketClient);
 	}
-	create(input) {
-		assertBoardNodes(input.nodes ?? []);
+	async create(input) {
+		for (const item of input.items ?? []) BoardAuthoringItemSchema.parse(item);
 		return this.transport.request(`/api/spaces/${this.spaceId}/boards`, {
 			method: "POST",
 			headers: { "Content-Type": "application/json" },
 			body: JSON.stringify(input)
 		});
 	}
-	inspect(boardId, input = {}, customFetch) {
+	authoring(boardId, input = {}, customFetch) {
 		const params = new URLSearchParams();
-		for (const section of input.include ?? []) params.append("include", section);
+		if (input.include) {
+			for (const section of input.include) params.append("include", section);
+			if (input.include.length === 0) params.set("include", "");
+		}
+		if (input.itemIds?.length) params.set("itemIds", input.itemIds.join(","));
+		if (input.connectionIds?.length) params.set("connectionIds", input.connectionIds.join(","));
+		if (input.effectIds?.length) params.set("effectIds", input.effectIds.join(","));
+		if (input.compositionIds?.length) params.set("compositionIds", input.compositionIds.join(","));
 		if (input.viewport) params.set("viewport", JSON.stringify(input.viewport));
 		const query = params.toString();
-		return this.transport.request(`/api/spaces/${this.spaceId}/boards/${boardId}${query ? `?${query}` : ""}`, { fetch: customFetch });
+		return this.transport.request(`/api/spaces/${this.spaceId}/boards/${boardId}/authoring${query ? `?${query}` : ""}`, { fetch: customFetch });
+	}
+	mutateSemantic(boardId, mutation) {
+		return this.transport.request(`/api/spaces/${this.spaceId}/boards/${boardId}/mutations`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(mutation)
+		});
 	}
 	summary(boardId, customFetch) {
 		return this.transport.request(`/api/spaces/${this.spaceId}/boards/${boardId}/summary`, { fetch: customFetch });
@@ -4560,26 +3598,6 @@ var SpaceBoardsApi = class {
 	capabilities(boardId, customFetch) {
 		return this.transport.request(`/api/spaces/${this.spaceId}/boards/${boardId}/capabilities`, { fetch: customFetch });
 	}
-	validate(transaction) {
-		return this.transport.request(`/api/spaces/${this.spaceId}/boards/${transaction.boardId}/validate`, {
-			method: "POST",
-			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify(transaction)
-		});
-	}
-	async apply(transaction, options) {
-		assertBoardTransactionNodeCreates(transaction.operations);
-		try {
-			return await this.transport.request(`/api/spaces/${this.spaceId}/boards/${transaction.boardId}/transactions${options?.compact ? "?compact=1" : ""}`, {
-				method: "POST",
-				headers: { "Content-Type": "application/json" },
-				body: JSON.stringify(transaction)
-			});
-		} catch (cause) {
-			if (cause instanceof HttpError) throw new BoardTransactionError(cause.message, cause.status, cause.code ?? void 0, cause.body, { cause });
-			throw cause;
-		}
-	}
 	playback(boardId, command) {
 		return this.transport.request(`/api/spaces/${this.spaceId}/boards/${boardId}/playback`, {
 			method: "POST",
@@ -5359,4 +4377,4 @@ var CohubHttpClient = class {
 };
 const createHttpClient = (options) => new CohubHttpClient(options);
 //#endregion
-export { parseUsername as $, WORK_SURFACE_READY_TIMEOUT_MS as A, parseWorkSurfaceRequest as B, BoardInputError as C, WORK_COMPOSER_CHIP_CONTENT_MAX_BYTES as D, validateBoardNodes as E, buildWorkSurfaceRequest as F, UI_COMMAND_PENDING_TTL_SECONDS as G, UI_COMMAND_DEFAULT_TIMEOUT_MS as H, buildWorkSurfaceResponse as I, UI_COMMAND_VERSION as J, UI_COMMAND_SETTLEMENT_GRACE_SECONDS as K, parseWorkComposerChipClear as L, buildWorkComposerChipClear as M, buildWorkComposerChipSet as N, WORK_COMPOSER_CHIP_KEY_MAX_LENGTH as O, buildWorkSurfaceReady as P, parseSpaceSlug as Q, parseWorkComposerChipSet as R, createSessionPatchReducer as S, createBoardNode as T, UI_COMMAND_MAX_TIMEOUT_MS as U, parseWorkSurfaceResponse as V, UI_COMMAND_PAYLOAD_MAX_BYTES as W, isUiSurfaceMethod as X, isTerminalUiCommandStatus as Y, parseUiCommand as Z, buildSpacePath as _, PromptsApi as _t, ReferralsApi as a, validateBoardNodeInput as at, parseAssistantMessageCommit as b, CronJobsApi as bt, UiCommandsApi as c, parseBoardPlaybackPolicy as ct, BoardTransactionError as d, DEFAULT_BOARD_RENDER_LIMITS as dt, BoardAwarenessClientPayloadSchema as et, SpaceClient as f, SessionAccessApi as ft, buildSpaceInvitePath as g, SkillsApi as gt, PublicInviteApi as h, PublicAssetsApi as ht, WorksApi as i, BOARD_NODE_CONTRACT as it, WORK_SURFACE_REQUEST_TIMEOUT_MS as j, WORK_COMPOSER_CHIP_LABEL_MAX_LENGTH as k, TasksApi as l, ensureRealtimeConnected as lt, SpacesApi as m, SearchApi as mt, createHttpClient as n, BOARD_GEO_KINDS as nt, UsersApi as o, BoardCameraFocusParamsSchema as ot, SpacePublicFilesApi as p, ReferencesApi as pt, UI_COMMAND_TERMINAL_TTL_SECONDS as q, WorkCommerceApi as r, BOARD_NATIVE_NODE_TYPES as rt, UserApi as s, BoardPlaybackPolicySchema as st, CohubHttpClient as t, BOARD_COLOR_IDS as tt, BoardClient as u, BOARD_BUILTIN_CAPABILITIES as ut, SessionGenerationStreamClient as v, ModelsApi as vt, assertBoardNodes as w, SessionPatchReducer as x, ChannelsApi as xt, createSessionGenerationStreamClient as y, GenerationsApi as yt, parseWorkSurfaceReady as z };
+export { SessionAccessApi as $, isTerminalUiCommandStatus as A, BOARD_ANIMATION_CHANNELS as B, UI_COMMAND_DEFAULT_TIMEOUT_MS as C, UI_COMMAND_SETTLEMENT_GRACE_SECONDS as D, UI_COMMAND_PENDING_TTL_SECONDS as E, BoardItemPatchSchema as F, BoardTrackSchema as G, BoardCompositionInputSchema as H, BoardSemanticMutationSchema as I, BOARD_ARROW_STROKE_SIZE as J, parseBoardCompositionInput as K, BoardEffectInputSchema as L, parseUiCommand as M, parseUiCommandId as N, UI_COMMAND_TERMINAL_TTL_SECONDS as O, BoardAuthoringItemSchema as P, DEFAULT_BOARD_RENDER_LIMITS as Q, BoardEffectSchema as R, ensureRealtimeConnected as S, UI_COMMAND_PAYLOAD_MAX_BYTES as T, BoardCompositionSchema as U, BOARD_ANIMATION_CHANNEL_CAPABILITIES as V, BoardProceduralClipSchema as W, BOARD_BUILTIN_CLIP_KINDS as X, BOARD_BUILTIN_CAPABILITIES as Y, BOARD_BUILTIN_EFFECT_KINDS as Z, SessionGenerationStreamClient as _, ReferralsApi as a, ModelsApi as at, SessionPatchReducer as b, UiCommandsApi as c, ChannelsApi as ct, SpaceClient as d, ReferencesApi as et, SpacePublicFilesApi as f, buildSpacePath as g, buildSpaceInvitePath as h, WorksApi as i, PromptsApi as it, isUiSurfaceMethod as j, UI_COMMAND_VERSION as k, TasksApi as l, PublicInviteApi as m, createHttpClient as n, PublicAssetsApi as nt, UsersApi as o, GenerationsApi as ot, SpacesApi as p, BoardConnectionSchema as q, WorkCommerceApi as r, SkillsApi as rt, UserApi as s, CronJobsApi as st, CohubHttpClient as t, SearchApi as tt, BoardClient as u, createSessionGenerationStreamClient as v, UI_COMMAND_MAX_TIMEOUT_MS as w, createSessionPatchReducer as x, parseAssistantMessageCommit as y, parseBoardEffectInput as z };