@neta-art/cohub 8.23.0 → 9.0.0

package/dist/index.js

@@ -1,5 +1,5 @@
-import { $ as BoardEffectInputSchema, A as SkillsApi, B as DESKTOP_COMMAND_SETTLEMENT_GRACE_SECONDS, C as SessionPatchReducer, D as ReferencesApi, E as SessionAccessApi, F as ChannelsApi, G as parseDesktopCommand, H as DESKTOP_COMMAND_VERSION, I as DESKTOP_COMMAND_DEFAULT_TIMEOUT_MS, J as NAVIGATION_ERROR_MESSAGE_MAX_LENGTH, K as parseDesktopCommandId, L as DESKTOP_COMMAND_MAX_TIMEOUT_MS, M as ModelsApi, N as GenerationsApi, O as SearchApi, P as CronJobsApi, Q as BoardSemanticMutationSchema, R as DESKTOP_COMMAND_PAYLOAD_MAX_BYTES, S as parseAssistantMessageCommit, T as ensureRealtimeConnected, U as isDesktopCallMethod, V as DESKTOP_COMMAND_TERMINAL_TTL_SECONDS, W as isTerminalDesktopCommandStatus, X as BoardItemPatchSchema, Y as BoardAuthoringItemSchema, Z as BoardSemanticCommandSchema, _ as PublicInviteApi, a as DesktopCommandsApi, at as BoardCompositionSchema, b as SessionGenerationStreamClient, c as ReferralsApi, ct as parseBoardCompositionInput, d as TasksApi, dt as BOARD_BUILTIN_CAPABILITIES, et as BoardEffectSchema, f as BoardClient, ft as BOARD_BUILTIN_CLIP_KINDS, g as SpacesApi, h as SpaceWebhooksApi, i as WorkCommerceApi, it as BoardCompositionInputSchema, j as PromptsApi, k as PublicAssetsApi, l as UsersApi, lt as BoardConnectionSchema, m as SpacePublicFilesApi, mt as DEFAULT_BOARD_RENDER_LIMITS, n as createHttpClient, nt as BOARD_ANIMATION_CHANNELS, o as UiCommandsApi, ot as BoardProceduralClipSchema, p as SpaceClient, pt as BOARD_BUILTIN_EFFECT_KINDS, q as resolveOpenSurface, r as AppCommerceApi, rt as BOARD_ANIMATION_CHANNEL_CAPABILITIES, s as AppsApi, st as BoardTrackSchema, t as CohubHttpClient, tt as parseBoardEffectInput, u as UserApi, ut as BOARD_ARROW_STROKE_SIZE, v as buildSpaceInvitePath, w as createSessionPatchReducer, x as createSessionGenerationStreamClient, y as buildSpacePath, z as DESKTOP_COMMAND_PENDING_TTL_SECONDS } from "./chunks/http.js";
-import { _ as requestSourceToHeaders, a as sanitizeAccessToken, b as REALTIME_ROOM_EVENT_NAME_PATTERN, c as REQUEST_SOURCE_VIA_MAX_LENGTH, d as isRequestSourceEmpty, f as isRequestSourceUuid, g as readRequestSourceFromEnv, h as parseRequestSourceFromHeaders, i as matchesUnauthorizedErrorToken, l as hasRequestSourceIdentity, m as normalizeRequestSource, n as HttpTransport, o as COHUB_SOURCE_HEADER, p as mergeRequestSourceIntoMeta, r as joinApiUrl, s as COHUB_SOURCE_HEADER_NAMES, t as HttpError, u as isRequestSourceClientId, v as resolveRequestSourceChannel, y as isUuid } from "./chunks/transport.js";
+import { $ as resolveOpenSurface, A as ReferencesApi, B as DESKTOP_COMMAND_DEFAULT_TIMEOUT_MS, C as SessionPatchReducer, D as connectDisplay, E as DisplayConnection, F as ModelsApi, G as DESKTOP_COMMAND_SETTLEMENT_GRACE_SECONDS, H as DESKTOP_COMMAND_OPEN_TIMEOUT_MS, I as GenerationsApi, J as defaultDesktopCommandTimeoutMs, K as DESKTOP_COMMAND_TERMINAL_TTL_SECONDS, L as CronJobsApi, M as PublicAssetsApi, N as SkillsApi, O as ensureRealtimeConnected, P as PromptsApi, Q as parseDesktopCommandId, R as ChannelsApi, S as parseAssistantMessageCommit, T as SpaceDisplaysApi, U as DESKTOP_COMMAND_PAYLOAD_MAX_BYTES, V as DESKTOP_COMMAND_MAX_TIMEOUT_MS, W as DESKTOP_COMMAND_PENDING_TTL_SECONDS, X as isTerminalDesktopCommandStatus, Y as isDesktopCallMethod, Z as parseDesktopCommand, _ as PublicInviteApi, a as DesktopCommandsApi, at as normalizeDisplayPoint, b as SessionGenerationStreamClient, c as ReferralsApi, d as TasksApi, et as NAVIGATION_ERROR_MESSAGE_MAX_LENGTH, f as BoardClient, g as SpacesApi, h as SpaceWebhooksApi, i as WorkCommerceApi, it as DISPLAY_SYSTEM_ACTIONS, j as SearchApi, k as SessionAccessApi, l as UsersApi, m as SpacePublicFilesApi, n as createHttpClient, o as UiCommandsApi, ot as splitDisplayText, p as SpaceClient, q as DESKTOP_COMMAND_VERSION, r as AppCommerceApi, rt as DISPLAY_INPUT_MAX_TEXT, s as AppsApi, t as CohubHttpClient, tt as DISPLAY_ELEMENT_REF_PATTERN, u as UserApi, v as buildSpaceInvitePath, w as createSessionPatchReducer, x as createSessionGenerationStreamClient, y as buildSpacePath, z as DESKTOP_COMMAND_ACCEPT_TIMEOUT_MS } from "./chunks/http.js";
+import { A as isUuid, C as isRequestSourceUuid, D as readRequestSourceFromEnv, E as parseRequestSourceFromHeaders, M as isUuidOrShortUuid, O as requestSourceToHeaders, S as isRequestSourceEmpty, T as normalizeRequestSource, _ as COHUB_SOURCE_HEADER, a as sanitizeAccessToken, b as hasRequestSourceIdentity, i as matchesUnauthorizedErrorToken, j as isUuidLike, k as resolveRequestSourceChannel, n as HttpTransport, o as REALTIME_ROOM_EVENT_NAME_PATTERN, r as joinApiUrl, t as HttpError, v as COHUB_SOURCE_HEADER_NAMES, w as mergeRequestSourceIntoMeta, x as isRequestSourceClientId, y as REQUEST_SOURCE_VIA_MAX_LENGTH } from "./chunks/transport.js";
 import { a as normalizeWebsocketUrl, c as resolveExecutionAppId, d as resolveWebBaseUrl, f as resolveWebsocketUrl, g as scopeListHasPermission, h as isUserLevelPermission, i as normalizeVoiceInputWebsocketUrl, l as resolveExecutionToken, m as USER_LEVEL_PERMISSIONS, n as getCohubContext, o as resolveApiBaseUrl, p as PERMISSIONS, r as normalizeBaseUrl, s as resolveCohubEnvironment, t as COHUB_ENVIRONMENTS, u as resolveVoiceInputWebsocketUrl } from "./chunks/environment.js";
 import { a as extractBillingPayload, c as isFeatureNotEntitledError, i as FEATURE_NOT_ENTITLED_ERROR_CODE, l as isHttpErrorCode, n as createWebsocketClient, o as isBillingAccessBlockedCode, r as BILLING_ACCESS_BLOCKED_ERROR_CODE, s as isBillingAccessBlockedError, t as WebsocketClient } from "./chunks/websocket.js";
 import { VoiceApi, VoiceInputClient, createVoiceInputClient } from "./voice-input.js";
@@ -71,335 +71,1579 @@ const appAuthorizationResultSchema = z.discriminatedUnion("status", [
 		code: z.string()
 	})
 ]);
-//#endregion
-//#region ../protocol/dist/board.js
-const BOARD_DOCUMENT_KIND = "cohub.board";
-const BOARD_MANIFEST_KIND = "cohub.board.manifest";
-const idSchema = z.string().min(1).max(160);
-const jsonObjectSchema$1 = z.record(z.string(), z.unknown());
-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)
-});
-z.object({
-	centerX: finiteSchema$1,
-	centerY: finiteSchema$1,
-	zoom: finiteSchema$1.positive()
+const GiB = 1073741824;
+/** Maximum size of a single uploaded file. */
+const UPLOAD_MAX_FILE_BYTES = 1 * GiB;
+/** Maximum combined size of one upload batch. */
+const UPLOAD_MAX_BATCH_BYTES = 2 * GiB;
+/** Maximum file count of one upload batch. */
+const UPLOAD_MAX_BATCH_FILES = 2e3;
+const BOARD_CAMERA_TARGET = "camera";
+const BoardIdSchema = z.string().min(1).max(160).regex(/^[^\s/]+$/, "ids must not contain whitespace or '/'").refine((value) => value !== BOARD_CAMERA_TARGET, "\"camera\" is reserved");
+const finite$1 = z.number().finite();
+const nonNegative = finite$1.nonnegative();
+const ratio = finite$1.min(0).max(1);
+const BoardVec2Schema = z.object({
+	x: finite$1,
+	y: finite$1
+}).strict();
+const BoardSizeSchema = z.object({
+	width: finite$1.positive(),
+	height: finite$1.positive()
+}).strict();
+const BOARD_COLOR_TOKENS = [
+	"brand",
+	"neutral",
+	"black",
+	"white",
+	"blue",
+	"green",
+	"amber",
+	"violet",
+	"rose"
+];
+const CSS_NAMED_COLORS = new Set("transparent aliceblue antiquewhite aqua aquamarine azure beige bisque blanchedalmond blueviolet brown burlywood cadetblue chartreuse chocolate coral cornflowerblue cornsilk crimson cyan darkblue darkcyan darkgoldenrod darkgray darkgreen darkgrey darkkhaki darkmagenta darkolivegreen darkorange darkorchid darkred darksalmon darkseagreen darkslateblue darkslategray darkslategrey darkturquoise darkviolet deeppink deepskyblue dimgray dimgrey dodgerblue firebrick floralwhite forestgreen fuchsia gainsboro ghostwhite gold goldenrod gray grey greenyellow honeydew hotpink indianred indigo ivory khaki lavender lavenderblush lawngreen lemonchiffon lightblue lightcoral lightcyan lightgoldenrodyellow lightgray lightgreen lightgrey lightpink lightsalmon lightseagreen lightskyblue lightslategray lightslategrey lightsteelblue lightyellow lime limegreen linen magenta maroon mediumaquamarine mediumblue mediumorchid mediumpurple mediumseagreen mediumslateblue mediumspringgreen mediumturquoise mediumvioletred midnightblue mintcream mistyrose moccasin navajowhite navy oldlace olive olivedrab orange orangered orchid palegoldenrod palegreen paleturquoise palevioletred papayawhip peachpuff peru pink plum powderblue purple rebeccapurple red rosybrown royalblue saddlebrown salmon sandybrown seagreen seashell sienna silver skyblue slateblue slategray slategrey snow springgreen steelblue tan teal thistle tomato turquoise violet wheat whitesmoke yellow yellowgreen".split(" "));
+function isBoardColorString(value) {
+	const color = value.trim().toLowerCase();
+	return BOARD_COLOR_TOKENS.includes(color) || CSS_NAMED_COLORS.has(color) || /^#(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/.test(color) || /^(?:rgba?|hsla?|hwb|lab|lch|oklab|oklch|color)\([^()]*\)$/.test(color);
+}
+const colorString = z.string().max(120).refine(isBoardColorString, "expected a palette token or a CSS color");
+const BoardColorSchema = z.union([colorString, z.object({
+	light: colorString,
+	dark: colorString
+}).strict()]);
+const BoardStyleSchema = z.object({
+	fill: BoardColorSchema.optional(),
+	fillOpacity: ratio.optional(),
+	stroke: BoardColorSchema.optional(),
+	strokeWidth: finite$1.min(0).max(64).optional(),
+	dash: z.enum([
+		"solid",
+		"dashed",
+		"dotted"
+	]).optional(),
+	radius: nonNegative.optional(),
+	trim: ratio.optional()
+}).strict();
+function isSafeBoardSourcePath(value) {
+	return value.length > 0 && value.length <= 4096 && !value.startsWith("/") && !value.includes("\\") && value.split("/").every((part) => part.length > 0 && part !== "." && part !== "..");
+}
+const srcSchema = z.string().refine(isSafeBoardSourcePath, "src must be a relative Space file path");
+const itemEnvelope = {
+	parent: BoardIdSchema.optional(),
+	z: finite$1.optional(),
+	position: BoardVec2Schema.default({
+		x: 0,
+		y: 0
+	}),
+	rotation: finite$1.default(0),
+	scale: z.union([finite$1, BoardVec2Schema]).default(1),
+	origin: BoardVec2Schema.default({
+		x: .5,
+		y: .5
+	}),
+	opacity: ratio.default(1),
+	style: BoardStyleSchema.default({}),
+	locked: z.boolean().optional(),
+	metadata: z.record(z.string(), z.unknown()).optional()
+};
+const boxed = (width, height) => ({
+	...itemEnvelope,
+	size: BoardSizeSchema.default({
+		width,
+		height
+	})
 });
-const BoardCameraFocusSchema = z.discriminatedUnion("type", [
+const unsized = { ...itemEnvelope };
+const fontSize = finite$1.min(2).max(512);
+const BOARD_TEXT_ALIGNS = [
+	"left",
+	"center",
+	"right"
+];
+const BOARD_SHAPE_GEOMETRIES = [
+	"rectangle",
+	"rounded",
+	"ellipse",
+	"diamond",
+	"triangle",
+	"path"
+];
+const BoardFrameItemSchema = z.object({
+	...boxed(480, 320),
+	type: z.literal("frame"),
+	props: z.object({
+		label: z.string().max(280).default(""),
+		clip: z.boolean().default(true)
+	}).strict().prefault({})
+}).strict();
+const BoardTextItemSchema = z.object({
+	...unsized,
+	type: z.literal("text"),
+	props: z.object({
+		text: z.string().default(""),
+		fontSize: fontSize.default(24),
+		fontWeight: finite$1.min(100).max(900).default(500),
+		font: z.string().min(1).max(120).default("sans"),
+		align: z.enum(BOARD_TEXT_ALIGNS).default("left"),
+		lineHeight: finite$1.min(.5).max(4).default(4 / 3),
+		width: finite$1.positive().optional(),
+		reveal: ratio.default(1),
+		caret: z.boolean().default(false)
+	}).strict().prefault({})
+}).strict();
+const BoardShapeItemSchema = z.object({
+	...boxed(240, 160),
+	type: z.literal("shape"),
+	props: z.object({
+		geometry: z.enum(BOARD_SHAPE_GEOMETRIES).default("rectangle"),
+		path: z.string().min(1).max(2e5).optional(),
+		text: z.string().default(""),
+		fontSize: fontSize.default(20),
+		align: z.enum(BOARD_TEXT_ALIGNS).default("center")
+	}).strict().refine((props) => props.geometry !== "path" || Boolean(props.path), {
+		message: "path geometry requires props.path",
+		path: ["path"]
+	}).prefault({})
+}).strict();
+const BoardDrawPointSchema = z.object({
+	x: finite$1,
+	y: finite$1,
+	p: ratio.default(.5)
+}).strict();
+const BoardDrawItemSchema = z.object({
+	...unsized,
+	type: z.literal("draw"),
+	props: z.object({ points: z.array(BoardDrawPointSchema).min(1).max(1e5) }).strict()
+}).strict();
+const BoardArrowAnchorSchema = z.union([
+	z.literal("auto"),
 	z.object({
-		type: z.literal("rect"),
-		rect: z.object({
-			x: finiteSchema$1,
-			y: finiteSchema$1,
-			width: finiteSchema$1.positive(),
-			height: finiteSchema$1.positive()
-		})
-	}),
+		side: z.enum([
+			"top",
+			"right",
+			"bottom",
+			"left"
+		]),
+		offset: ratio.default(.5)
+	}).strict(),
 	z.object({
-		type: z.literal("item"),
-		itemId: idSchema
-	}),
+		x: ratio,
+		y: ratio
+	}).strict()
+]);
+const BoardArrowBindingSchema = z.object({
+	item: BoardIdSchema,
+	anchor: BoardArrowAnchorSchema.default("auto"),
+	port: z.string().min(1).max(120).optional()
+}).strict();
+const BoardArrowEndSchema = z.union([BoardVec2Schema, BoardArrowBindingSchema]);
+const BOARD_ARROW_ROUTES = [
+	"straight",
+	"curve",
+	"orthogonal"
+];
+const BoardArrowItemSchema = z.object({
+	...unsized,
+	type: z.literal("arrow"),
+	props: z.object({
+		start: BoardArrowEndSchema,
+		end: BoardArrowEndSchema,
+		route: z.enum(BOARD_ARROW_ROUTES).default("straight"),
+		bend: finite$1.min(-.85).max(.85).default(0),
+		waypoints: z.array(BoardVec2Schema).max(64).default([]),
+		arrowStart: z.boolean().default(false),
+		arrowEnd: z.boolean().default(true),
+		label: z.string().max(280).default(""),
+		fontSize: fontSize.default(14),
+		relation: z.string().max(64).regex(/^[a-z0-9]+(?:[.-][a-z0-9]+)*$/, "relation must be a lowercase slug").optional()
+	}).strict()
+}).strict();
+const fileProps = {
+	src: srcSchema,
+	snapshot: z.object({
+		title: z.string().optional(),
+		mimeType: z.string().optional(),
+		size: nonNegative.optional(),
+		mtimeMs: nonNegative.optional(),
+		naturalWidth: finite$1.positive().optional(),
+		naturalHeight: finite$1.positive().optional(),
+		durationMs: nonNegative.optional(),
+		excerpt: z.string().optional(),
+		coverPath: z.string().optional(),
+		coverUrl: z.string().optional()
+	}).strict().optional()
+};
+const timedFileProps = {
+	...fileProps,
+	time: nonNegative.optional()
+};
+const BoardCropSchema = z.object({
+	x: ratio,
+	y: ratio,
+	w: ratio,
+	h: ratio
+}).strict();
+const BoardImageItemSchema = z.object({
+	...boxed(640, 360),
+	type: z.literal("image"),
+	props: z.object({
+		...fileProps,
+		crop: BoardCropSchema.optional()
+	}).strict()
+}).strict();
+const BoardVideoItemSchema = z.object({
+	...boxed(640, 360),
+	type: z.literal("video"),
+	props: z.object(timedFileProps).strict()
+}).strict();
+const BoardAudioItemSchema = z.object({
+	...boxed(480, 96),
+	type: z.literal("audio"),
+	props: z.object(timedFileProps).strict()
+}).strict();
+const BoardFileItemSchema = z.object({
+	...boxed(360, 220),
+	type: z.literal("file"),
+	props: z.object(fileProps).strict()
+}).strict();
+const httpsUrl = z.string().max(4096).url();
+const artifactBase = {
+	id: z.string().min(1).max(240),
+	title: z.string().max(240).optional(),
+	url: httpsUrl,
+	mimeType: z.string().max(160).optional()
+};
+const BoardTaskArtifactSchema = z.discriminatedUnion("type", [
 	z.object({
-		type: z.literal("items"),
-		itemIds: z.array(idSchema).min(1).max(1e3)
-	}),
+		...artifactBase,
+		type: z.literal("image"),
+		naturalWidth: finite$1.positive().optional(),
+		naturalHeight: finite$1.positive().optional()
+	}).strict(),
 	z.object({
-		type: z.literal("frame"),
-		frameId: idSchema
-	})
+		...artifactBase,
+		type: z.literal("video"),
+		previewUrl: httpsUrl.optional(),
+		durationMs: z.number().int().positive().optional(),
+		naturalWidth: finite$1.positive().optional(),
+		naturalHeight: finite$1.positive().optional()
+	}).strict(),
+	z.object({
+		...artifactBase,
+		type: z.literal("audio"),
+		previewUrl: httpsUrl.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()
+]);
+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();
+const BoardTaskItemSchema = z.object({
+	...boxed(420, 240),
+	type: z.literal("task"),
+	props: z.object({
+		taskRunId: z.string().min(1).max(160),
+		snapshot: BoardTaskSnapshotSchema
+	}).strict()
+}).strict();
+const BOARD_EFFECT_KINDS = [
+	"particles",
+	"trail",
+	"impact",
+	"flash",
+	"glow"
+];
+const BoardEffectItemSchema = z.object({
+	...boxed(240, 240),
+	type: z.literal("effect"),
+	props: z.object({
+		kind: z.enum(BOARD_EFFECT_KINDS),
+		rate: nonNegative.max(2e4).default(40),
+		life: finite$1.positive().max(6e4).default(1200),
+		particleSize: finite$1.positive().max(512).default(6),
+		speed: nonNegative.max(1e4).default(120),
+		direction: finite$1.default(-90),
+		spread: finite$1.min(0).max(360).default(360),
+		gravity: finite$1.default(0),
+		intensity: nonNegative.max(10).default(1),
+		follow: BoardIdSchema.optional(),
+		seed: z.string().min(1).max(160).optional()
+	}).strict()
+}).strict();
+const BoardSketchItemSchema = z.object({
+	...boxed(480, 320),
+	type: z.literal("sketch"),
+	props: z.object({
+		src: srcSchema.refine((path) => /\.m?js$/.test(path), "sketch src must be a .js or .mjs module"),
+		params: z.record(z.string(), z.unknown()).default({}),
+		seed: z.string().min(1).max(160).optional()
+	}).strict()
+}).strict();
+const BOARD_EXTENSION_TYPE_PATTERN = /^[a-z][a-z0-9]*(?:\.[a-z0-9-]+)+$/;
+const BoardExtensionItemSchema = z.object({
+	...itemEnvelope,
+	size: BoardSizeSchema.default({
+		width: 240,
+		height: 160
+	}),
+	type: z.string().regex(BOARD_EXTENSION_TYPE_PATTERN),
+	props: z.record(z.string(), z.unknown()).default({})
+}).strict();
+const BOARD_ITEM_SCHEMAS = {
+	frame: BoardFrameItemSchema,
+	text: BoardTextItemSchema,
+	shape: BoardShapeItemSchema,
+	draw: BoardDrawItemSchema,
+	arrow: BoardArrowItemSchema,
+	image: BoardImageItemSchema,
+	video: BoardVideoItemSchema,
+	audio: BoardAudioItemSchema,
+	file: BoardFileItemSchema,
+	task: BoardTaskItemSchema,
+	effect: BoardEffectItemSchema,
+	sketch: BoardSketchItemSchema
+};
+const BOARD_ITEM_TYPES = Object.keys(BOARD_ITEM_SCHEMAS);
+function isBuiltinItemType(type) {
+	return Object.hasOwn(BOARD_ITEM_SCHEMAS, type);
+}
+function boardItemSchema(type) {
+	if (isBuiltinItemType(type)) return BOARD_ITEM_SCHEMAS[type];
+	return BOARD_EXTENSION_TYPE_PATTERN.test(type) ? BoardExtensionItemSchema : null;
+}
+function issuesToDiagnostics(error, path) {
+	return error.issues.map((issue) => {
+		return {
+			severity: "error",
+			code: "INVALID_ITEM",
+			path: [path, ...issue.path.map(String)].filter(Boolean).join("."),
+			message: issue.code === "unrecognized_keys" ? `unknown ${issue.keys.length === 1 ? "property" : "properties"} ${issue.keys.join(", ")}` : issue.message
+		};
+	});
+}
+function parseBoardItem(value, path = "item") {
+	const type = value && typeof value === "object" && !Array.isArray(value) ? value.type : void 0;
+	if (typeof type !== "string") return {
+		ok: false,
+		diagnostics: [{
+			severity: "error",
+			code: "INVALID_ITEM",
+			path: `${path}.type`,
+			message: "type is required"
+		}]
+	};
+	const schema = boardItemSchema(type);
+	if (!schema) return {
+		ok: false,
+		diagnostics: [{
+			severity: "error",
+			code: "INVALID_ITEM",
+			path: `${path}.type`,
+			message: `unknown type ${type}; expected ${BOARD_ITEM_TYPES.join(", ")} or a namespaced extension type`
+		}]
+	};
+	const parsed = schema.safeParse(value);
+	return parsed.success ? {
+		ok: true,
+		item: parsed.data
+	} : {
+		ok: false,
+		diagnostics: issuesToDiagnostics(parsed.error, path)
+	};
+}
+const CSS_EASE_KEYWORDS = /* @__PURE__ */ new Set([
+	"linear",
+	"ease",
+	"ease-in",
+	"ease-out",
+	"ease-in-out",
+	"step-start",
+	"step-end"
 ]);
-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({
+function isBoardEase(value) {
+	const ease = value.trim();
+	if (CSS_EASE_KEYWORDS.has(ease)) return true;
+	const bezier = /^cubic-bezier\(\s*([^,()]+),\s*([^,()]+),\s*([^,()]+),\s*([^,()]+)\)$/.exec(ease);
+	if (bezier) {
+		const [x1, , x2] = bezier.slice(1).map(Number);
+		return bezier.slice(1).every((part) => Number.isFinite(Number(part))) && x1 >= 0 && x1 <= 1 && x2 >= 0 && x2 <= 1;
+	}
+	return /^steps\(\s*[1-9]\d*\s*(?:,\s*(?:start|end|jump-start|jump-end|jump-none|jump-both)\s*)?\)$/.test(ease);
+}
+const BoardEaseSchema = z.string().max(120).refine(isBoardEase, "expected a CSS easing: linear, ease-in-out, cubic-bezier(…) or steps(…)");
+const BoardKeyframeSchema = z.object({
+	at: nonNegative,
+	value: z.unknown(),
+	ease: BoardEaseSchema.optional()
+}).strict();
+const BoardTrackSchema = z.object({
+	target: z.string().min(1).max(160),
+	property: z.string().min(1).max(200),
+	keyframes: z.array(BoardKeyframeSchema).min(1).max(1e5),
+	composite: z.enum(["replace", "add"]).default("replace"),
+	interpolation: z.enum([
+		"auto",
+		"step",
+		"spline"
+	]).default("auto"),
+	orient: z.boolean().optional()
+}).strict().superRefine((track, context) => {
+	for (let index = 1; index < track.keyframes.length; index += 1) if ((track.keyframes[index]?.at ?? 0) < (track.keyframes[index - 1]?.at ?? 0)) context.addIssue({
 		code: "custom",
-		message: "minZoom must not exceed maxZoom",
-		path: ["minZoom"]
+		message: "keyframes must be ordered by at",
+		path: [
+			"keyframes",
+			index,
+			"at"
+		]
 	});
 });
-z.object({
-	nodeId: idSchema,
-	type: z.string().min(1).max(40),
-	parentId: idSchema.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$1,
-	style: jsonObjectSchema$1,
-	data: jsonObjectSchema$1
-});
-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(),
+const BoardMarkerSchema = z.object({
+	at: nonNegative,
+	label: z.string().max(280).optional(),
+	pause: z.boolean().optional()
+}).strict();
+const BoardAnimationHeaderSchema = z.object({
+	name: z.string().max(280).optional(),
+	duration: finite$1.positive().max(864e5),
+	play: z.enum([
+		"manual",
+		"auto",
+		"always"
+	]).default("manual"),
+	delay: nonNegative.default(0),
+	loop: z.boolean().default(false),
+	end: z.enum(["hold", "reset"]).default("hold"),
+	markers: z.array(BoardMarkerSchema).max(1e4).default([])
+}).strict();
+const BoardAnimationSchema = BoardAnimationHeaderSchema.extend({ tracks: z.record(BoardIdSchema, BoardTrackSchema).default({}) }).strict();
+const BOARD_ENTER_PRESETS = [
+	"fade-in",
+	"rise",
+	"drop",
+	"pop",
+	"deal"
+];
+const BoardBackgroundSchema = z.object({
+	kind: z.enum([
+		"solid",
+		"dots",
+		"grid",
+		"image"
+	]).default("dots"),
+	color: BoardColorSchema.optional(),
+	imageUrl: z.string().url().max(4096).optional(),
+	fit: z.enum([
+		"cover",
+		"contain",
+		"repeat"
+	]).optional(),
+	opacity: ratio.optional()
+}).strict();
+const BoardSettingsSchema = z.object({
 	title: z.string().min(1).max(255).optional(),
-	metadata: jsonObjectSchema$1.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$1 = (schema) => z.toJSONSchema(schema);
-const authoringSchemaFactories = {
-	item: () => jsonSchema$1(BoardAuthoringItemSchema),
-	itemPatch: () => jsonSchema$1(BoardItemPatchSchema),
-	mutation: () => jsonSchema$1(BoardSemanticMutationSchema),
-	composition: () => jsonSchema$1(BoardCompositionInputSchema),
-	effect: () => jsonSchema$1(BoardEffectInputSchema),
-	create: () => jsonSchema$1(BoardCreateInputSchema)
+	background: BoardBackgroundSchema.default({ kind: "dots" }),
+	grid: z.object({
+		visible: z.boolean().default(false),
+		size: finite$1.min(4).max(512).default(24)
+	}).strict().optional(),
+	enter: z.object({
+		preset: z.enum(BOARD_ENTER_PRESETS),
+		duration: finite$1.positive().max(1e4).optional()
+	}).strict().optional()
+}).strict();
+const patchObject = z.record(z.string(), z.unknown());
+const BoardPatchSchema = z.object({
+	board: patchObject.nullable().optional(),
+	items: z.record(BoardIdSchema, patchObject.nullable()).optional(),
+	animations: z.record(BoardIdSchema, patchObject.and(z.object({ tracks: z.record(BoardIdSchema, patchObject.nullable()).optional() })).nullable()).optional()
+}).strict();
+//#endregion
+//#region ../protocol/dist/board-json.js
+/** Structural equality for JSON-shaped semantic values. */
+function boardJsonEquals(a, b) {
+	if (a === b) return true;
+	if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return Number.isNaN(a) && Number.isNaN(b);
+	const aArray = Array.isArray(a);
+	const bArray = Array.isArray(b);
+	if (aArray !== bArray) return false;
+	if (aArray && bArray) return a.length === b.length && a.every((value, index) => boardJsonEquals(value, b[index]));
+	const aRecord = a;
+	const bRecord = b;
+	const keys = Object.keys(aRecord);
+	return keys.length === Object.keys(bRecord).length && keys.every((key) => Object.hasOwn(bRecord, key) && boardJsonEquals(aRecord[key], bRecord[key]));
+}
+//#endregion
+//#region ../protocol/dist/board-layout.js
+const IDENTITY_MATRIX = [
+	1,
+	0,
+	0,
+	1,
+	0,
+	0
+];
+function multiplyMatrix(parent, child) {
+	const [a1, b1, c1, d1, tx1, ty1] = parent;
+	const [a2, b2, c2, d2, tx2, ty2] = child;
+	return [
+		a1 * a2 + c1 * b2,
+		b1 * a2 + d1 * b2,
+		a1 * c2 + c1 * d2,
+		b1 * c2 + d1 * d2,
+		a1 * tx2 + c1 * ty2 + tx1,
+		b1 * tx2 + d1 * ty2 + ty1
+	];
+}
+function invertMatrix(matrix) {
+	const [a, b, c, d, tx, ty] = matrix;
+	const det = a * d - b * c || 1e-12;
+	return [
+		d / det,
+		-b / det,
+		-c / det,
+		a / det,
+		(c * ty - d * tx) / det,
+		(b * tx - a * ty) / det
+	];
+}
+function applyMatrix(matrix, point) {
+	const [a, b, c, d, tx, ty] = matrix;
+	return {
+		x: a * point.x + c * point.y + tx,
+		y: b * point.x + d * point.y + ty
+	};
+}
+function scaleVector(scale) {
+	return typeof scale === "number" ? {
+		x: scale,
+		y: scale
+	} : scale;
+}
+function isWideCharacter(code) {
+	return code >= 4352 && code <= 4447 || code >= 11904 && code <= 42191 || code >= 44032 && code <= 55203 || code >= 63744 && code <= 64255 || code >= 65072 && code <= 65103 || code >= 65280 && code <= 65376 || code >= 65504 && code <= 65510 || code >= 127744 && code <= 129791 || code >= 131072 && code <= 262141;
+}
+function estimateTextWidth(text, fontSize) {
+	let ems = 0;
+	for (const character of text) {
+		const code = character.codePointAt(0) ?? 0;
+		if (character === " ") ems += .28;
+		else if (isWideCharacter(code)) ems += 1;
+		else if (/[il.,:;'|!]/.test(character)) ems += .3;
+		else if (/[mwMW@]/.test(character)) ems += .85;
+		else if (/[A-Z0-9]/.test(character)) ems += .64;
+		else ems += .55;
+	}
+	return ems * fontSize;
+}
+function measureLine(text, fontSize, fontWeight, font) {
+	return estimateTextWidth(text, fontSize);
+}
+function wrapParagraph(paragraph, width, measure) {
+	if (!paragraph) return [""];
+	const tokens = paragraph.match(/[\u1100-\u115f\u2e80-\ua4cf\uac00-\ud7a3\uf900-\ufaff\uff00-\uff60]|[^\s\u1100-\u115f\u2e80-\ua4cf\uac00-\ud7a3\uf900-\ufaff\uff00-\uff60]+|\s+/g) ?? [paragraph];
+	const lines = [];
+	let line = "";
+	for (const token of tokens) {
+		const candidate = line + token;
+		if (!line || measure(candidate.trimEnd()) <= width) {
+			line = candidate;
+			continue;
+		}
+		lines.push(line.trimEnd());
+		line = /^\s+$/.test(token) ? "" : token;
+	}
+	lines.push(line.trimEnd());
+	return lines;
+}
+const textSizeCache = /* @__PURE__ */ new Map();
+const TEXT_CACHE_LIMIT = 4096;
+function clampBoardFontSize(fontSize) {
+	return Math.min(512, Math.max(2, fontSize));
+}
+function layoutBoardText(props) {
+	const fontSize = clampBoardFontSize(props.fontSize ?? 24);
+	const key = `${fontSize}|${props.fontWeight}|${props.font}|${props.lineHeight}|${props.width ?? ""}|${props.text}`;
+	const cached = textSizeCache.get(key);
+	if (cached) return cached;
+	const measure = (text) => measureLine(text, fontSize, props.fontWeight ?? 500, props.font ?? "sans");
+	const paragraphs = (props.text || "").split("\n");
+	const lines = props.width ? paragraphs.flatMap((paragraph) => wrapParagraph(paragraph, props.width, measure)) : paragraphs;
+	const lineHeight = fontSize * (props.lineHeight ?? 4 / 3);
+	const widest = lines.reduce((max, line) => Math.max(max, measure(line)), 0);
+	const layout = {
+		width: Math.max(props.width ?? 0, widest, fontSize * .5),
+		height: Math.max(1, lines.length) * lineHeight,
+		lines,
+		lineHeight
+	};
+	if (textSizeCache.size >= TEXT_CACHE_LIMIT) textSizeCache.clear();
+	textSizeCache.set(key, layout);
+	return layout;
+}
+function drawSampleRadius(strokeWidth, pressure) {
+	const clamped = Math.min(1, Math.max(0, pressure));
+	return Math.max(.5, strokeWidth / 2 * (.5 + clamped));
+}
+function drawPointsBounds(points, strokeWidth) {
+	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 radius = drawSampleRadius(strokeWidth, 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);
+	}
+	return {
+		x: minX,
+		y: minY,
+		width: Math.max(1, maxX - minX),
+		height: Math.max(1, maxY - minY)
+	};
+}
+function pointsRect(points) {
+	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) {
+		minX = Math.min(minX, point.x);
+		minY = Math.min(minY, point.y);
+		maxX = Math.max(maxX, point.x);
+		maxY = Math.max(maxY, point.y);
+	}
+	if (!Number.isFinite(minX)) return {
+		x: 0,
+		y: 0,
+		width: 1,
+		height: 1
+	};
+	return {
+		x: minX,
+		y: minY,
+		width: Math.max(1, maxX - minX),
+		height: Math.max(1, maxY - minY)
+	};
+}
+function isArrowBinding(end) {
+	return typeof end.item === "string";
+}
+function arrowBindings(item) {
+	if (item.type !== "arrow") return [];
+	const props = item.props;
+	const ids = [props.start, props.end].filter(isArrowBinding).map((end) => end.item);
+	return [...new Set(ids)];
+}
+function bendControl(start, end, bend) {
+	const mid = {
+		x: (start.x + end.x) / 2,
+		y: (start.y + end.y) / 2
+	};
+	if (!bend) return mid;
+	const dx = end.x - start.x;
+	const dy = end.y - start.y;
+	const length = Math.hypot(dx, dy) || 1;
+	const offset = bend * length;
+	return {
+		x: mid.x + -dy / length * offset,
+		y: mid.y + dx / length * offset
+	};
+}
+const MAX_DEPTH = 64;
+function createBoardLayout(initialLookup, dependents) {
+	let lookup = initialLookup;
+	const boxes = /* @__PURE__ */ new Map();
+	const matrices = /* @__PURE__ */ new Map();
+	const bounds = /* @__PURE__ */ new Map();
+	function matrixOf(id, depth = 0) {
+		const cached = matrices.get(id);
+		if (cached) return cached;
+		const item = lookup(id);
+		if (!item) return IDENTITY_MATRIX;
+		const matrix = multiplyMatrix(item.parent && depth < MAX_DEPTH && lookup(item.parent) ? matrixOf(item.parent, depth + 1) : IDENTITY_MATRIX, localMatrixOf(id));
+		matrices.set(id, matrix);
+		return matrix;
+	}
+	function localMatrixOf(id) {
+		const item = lookup(id);
+		if (!item) return IDENTITY_MATRIX;
+		if (item.type === "arrow") return translate(item.position);
+		const box = boxOf(id);
+		const scale = scaleVector(item.scale);
+		const radians = item.rotation * Math.PI / 180;
+		const cos = Math.cos(radians);
+		const sin = Math.sin(radians);
+		const ox = box.x + item.origin.x * box.width;
+		const oy = box.y + item.origin.y * box.height;
+		const a = cos * scale.x;
+		const b = sin * scale.x;
+		const c = -sin * scale.y;
+		const d = cos * scale.y;
+		return [
+			a,
+			b,
+			c,
+			d,
+			item.position.x + ox - (a * ox + c * oy),
+			item.position.y + oy - (b * ox + d * oy)
+		];
+	}
+	function boxOf(id, depth = 0) {
+		const cached = boxes.get(id);
+		if (cached) return cached;
+		const item = lookup(id);
+		let box;
+		if (!item) box = {
+			x: 0,
+			y: 0,
+			width: 1,
+			height: 1
+		};
+		else if ("size" in item && item.size) box = {
+			x: 0,
+			y: 0,
+			width: item.size.width,
+			height: item.size.height
+		};
+		else if (item.type === "text") {
+			const layout = layoutBoardText(item.props);
+			box = {
+				x: 0,
+				y: 0,
+				width: layout.width,
+				height: layout.height
+			};
+		} else if (item.type === "draw") box = drawPointsBounds(item.props.points, item.style.strokeWidth ?? 4);
+		else if (item.type === "arrow") {
+			const props = item.props;
+			const toLocal = invertMatrix(multiplyMatrix(parentOf(item, depth), translate(item.position)));
+			const start = isArrowBinding(props.start) ? applyMatrix(toLocal, resolveBoundEnd(item, props.start, props.end, depth)) : props.start;
+			const end = isArrowBinding(props.end) ? applyMatrix(toLocal, resolveBoundEnd(item, props.end, props.start, depth)) : props.end;
+			const points = [
+				start,
+				end,
+				...props.waypoints
+			];
+			if (props.bend) points.push(bendControl(start, end, props.bend));
+			const rect = pointsRect(points);
+			const pad = Math.max(8, (item.style.strokeWidth ?? 2.5) * 2);
+			box = {
+				x: rect.x - pad,
+				y: rect.y - pad,
+				width: rect.width + pad * 2,
+				height: rect.height + pad * 2
+			};
+		} else box = {
+			x: 0,
+			y: 0,
+			width: 240,
+			height: 160
+		};
+		boxes.set(id, box);
+		return box;
+	}
+	function parentOf(item, depth) {
+		return item.parent && depth < MAX_DEPTH && lookup(item.parent) ? matrixOf(item.parent, depth + 1) : IDENTITY_MATRIX;
+	}
+	function resolveBoundEnd(arrow, end, other, depth) {
+		const target = lookup(end.item);
+		const arrowSpace = multiplyMatrix(parentOf(arrow, depth), translate(arrow.position));
+		if (!target || target.type === "arrow" || depth >= MAX_DEPTH) return applyMatrix(arrowSpace, {
+			x: 0,
+			y: 0
+		});
+		const frame = frameOf(end.item, depth + 1);
+		const toward = isArrowBinding(other) ? lookup(other.item) && lookup(other.item)?.type !== "arrow" ? center(frameOf(other.item, depth + 1)) : center(frame) : applyMatrix(arrowSpace, other);
+		return anchorPoint(frame, end.anchor, toward);
+	}
+	function frameOf(id, depth = 0) {
+		boxOf(id, depth);
+		const box = boxes.get(id);
+		const matrix = matrixOf(id, depth);
+		const [a, b, c, d] = matrix;
+		const centerPoint = applyMatrix(matrix, {
+			x: box.x + box.width / 2,
+			y: box.y + box.height / 2
+		});
+		const width = box.width * Math.hypot(a, b);
+		const height = box.height * Math.hypot(c, d);
+		return {
+			x: centerPoint.x - width / 2,
+			y: centerPoint.y - height / 2,
+			width,
+			height,
+			rotation: Math.atan2(b, a) * 180 / Math.PI
+		};
+	}
+	function boundsOf(id) {
+		const cached = bounds.get(id);
+		if (cached) return cached;
+		const box = boxOf(id);
+		const matrix = matrixOf(id);
+		const rect = pointsRect([
+			applyMatrix(matrix, {
+				x: box.x,
+				y: box.y
+			}),
+			applyMatrix(matrix, {
+				x: box.x + box.width,
+				y: box.y
+			}),
+			applyMatrix(matrix, {
+				x: box.x + box.width,
+				y: box.y + box.height
+			}),
+			applyMatrix(matrix, {
+				x: box.x,
+				y: box.y + box.height
+			})
+		]);
+		bounds.set(id, rect);
+		return rect;
+	}
+	function setLookup(nextLookup) {
+		lookup = nextLookup;
+	}
+	function invalidate(ids) {
+		if (!ids) {
+			boxes.clear();
+			matrices.clear();
+			bounds.clear();
+			return;
+		}
+		const queue = [...ids];
+		const seen = /* @__PURE__ */ new Set();
+		while (queue.length) {
+			const id = queue.pop();
+			if (seen.has(id)) continue;
+			seen.add(id);
+			boxes.delete(id);
+			matrices.delete(id);
+			bounds.delete(id);
+			if (dependents) for (const next of dependents(id)) queue.push(next);
+		}
+	}
+	return {
+		has: (id) => lookup(id) !== void 0,
+		box: (id) => boxOf(id),
+		matrix: (id) => matrixOf(id),
+		localMatrix: (id) => localMatrixOf(id),
+		parentMatrix: (id) => {
+			const item = lookup(id);
+			return item ? parentOf(item, 0) : IDENTITY_MATRIX;
+		},
+		bounds: boundsOf,
+		frame: (id) => frameOf(id),
+		arrowEnd: (id, which) => {
+			const item = lookup(id);
+			if (item?.type !== "arrow") return {
+				x: 0,
+				y: 0
+			};
+			const arrow = item;
+			const [end, other] = which === "start" ? [arrow.props.start, arrow.props.end] : [arrow.props.end, arrow.props.start];
+			return isArrowBinding(end) ? resolveBoundEnd(arrow, end, other, 0) : applyMatrix(matrixOf(id), end);
+		},
+		invalidate,
+		setLookup
+	};
+}
+function translate(point) {
+	return [
+		1,
+		0,
+		0,
+		1,
+		point.x,
+		point.y
+	];
+}
+function center(frame) {
+	return {
+		x: frame.x + frame.width / 2,
+		y: frame.y + frame.height / 2
+	};
+}
+function rotateAround(point, pivot, degrees) {
+	if (!degrees) return point;
+	const radians = degrees * Math.PI / 180;
+	const cos = Math.cos(radians);
+	const sin = Math.sin(radians);
+	const dx = point.x - pivot.x;
+	const dy = point.y - pivot.y;
+	return {
+		x: pivot.x + dx * cos - dy * sin,
+		y: pivot.y + dx * sin + dy * cos
+	};
+}
+function framePoint(frame, nx, ny) {
+	return rotateAround({
+		x: frame.x + nx * frame.width,
+		y: frame.y + ny * frame.height
+	}, center(frame), frame.rotation);
+}
+function autoAnchorSide(frame, toward) {
+	const local = rotateAround(toward, center(frame), -frame.rotation);
+	const c = center(frame);
+	const dx = (local.x - c.x) / Math.max(frame.width / 2, 1e-4);
+	const dy = (local.y - c.y) / Math.max(frame.height / 2, 1e-4);
+	if (Math.abs(dx) >= Math.abs(dy)) return dx >= 0 ? "right" : "left";
+	return dy >= 0 ? "bottom" : "top";
+}
+function sideAnchor(side, offset) {
+	switch (side) {
+		case "top": return {
+			x: offset,
+			y: 0
+		};
+		case "bottom": return {
+			x: offset,
+			y: 1
+		};
+		case "left": return {
+			x: 0,
+			y: offset
+		};
+		default: return {
+			x: 1,
+			y: offset
+		};
+	}
+}
+function anchorPoint(frame, anchor, toward) {
+	if (anchor === "auto") {
+		const normalized = sideAnchor(autoAnchorSide(frame, toward), .5);
+		return framePoint(frame, normalized.x, normalized.y);
+	}
+	if ("side" in anchor) {
+		const normalized = sideAnchor(anchor.side, anchor.offset);
+		return framePoint(frame, normalized.x, normalized.y);
+	}
+	return framePoint(frame, anchor.x, anchor.y);
+}
+//#endregion
+//#region ../protocol/dist/board-patch.js
+function slot(map, key) {
+	let value = map[key];
+	if (!value) {
+		value = {};
+		map[key] = value;
+	}
+	return value;
+}
+function emptyDelta() {
+	return {
+		items: {},
+		animations: {},
+		tracks: {}
+	};
+}
+function withoutEmpty(value) {
+	for (const [key, entry] of Object.entries(value)) if (entry === void 0 || isRecord$6(entry) && Object.keys(entry).length === 0) delete value[key];
+	return value;
+}
+function isRecord$6(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function mergePatch(target, patch) {
+	if (!isRecord$6(patch)) return patch;
+	const result = isRecord$6(target) ? { ...target } : {};
+	for (const [key, value] of Object.entries(patch)) if (value === null) delete result[key];
+	else result[key] = mergePatch(result[key], value);
+	return result;
+}
+function def(schema) {
+	return schema._zod.def;
+}
+function unwrap(schema) {
+	let current = schema;
+	for (let guard = 0; guard < 16; guard += 1) {
+		const d = def(current);
+		if (d.type === "optional" || d.type === "default" || d.type === "nullable" || d.type === "readonly" || d.type === "prefault") current = d.innerType;
+		else if (d.type === "pipe") current = d.in;
+		else return current;
+	}
+	return current;
+}
+function unwrapObjectShape(schema) {
+	const d = def(unwrap(schema));
+	return d.type === "object" ? d.shape : null;
+}
+function schemaAtPath(schema, path) {
+	let current = schema;
+	for (const segment of path) {
+		const d = def(unwrap(current));
+		if (d.type === "object") {
+			const shape = d.shape;
+			if (!Object.hasOwn(shape, segment)) return null;
+			current = shape[segment];
+		} else if (d.type === "record") current = d.valueType;
+		else if (d.type === "union") {
+			const branch = d.options.find((option) => unwrapObjectShape(option)?.[segment]);
+			if (!branch) return null;
+			current = unwrapObjectShape(branch)[segment];
+		} else return null;
+	}
+	return current;
+}
+const NOT_ANIMATABLE = /* @__PURE__ */ new Set([
+	"type",
+	"parent",
+	"z",
+	"locked",
+	"metadata"
+]);
+const CAMERA_PROPERTIES = {
+	focus: {
+		kind: "discrete",
+		schema: z.union([z.string().min(1), z.object({
+			x: z.number().finite(),
+			y: z.number().finite(),
+			width: z.number().finite().positive(),
+			height: z.number().finite().positive()
+		}).strict()])
+	},
+	zoom: {
+		kind: "number",
+		schema: z.number().finite().positive(),
+		multiplicative: true
+	},
+	center: {
+		kind: "vec2",
+		schema: BoardVec2Schema
+	},
+	shake: {
+		kind: "number",
+		schema: z.number().finite().nonnegative()
+	}
 };
-/**
-* 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;
+const ANIMATION_PROPERTIES = { time: {
+	kind: "number",
+	schema: z.number().finite().nonnegative()
+} };
+function kindOf(schema, path) {
+	const leaf = path[path.length - 1];
+	if (path.length === 1 && leaf === "scale") return "scale";
+	if (schema === BoardColorSchema || unwrap(schema) === BoardColorSchema) return "color";
+	if (def(unwrap(schema)).type === "number") return "number";
+	const shape = unwrapObjectShape(schema);
+	if (shape && Object.keys(shape).length === 2 && "x" in shape && "y" in shape) return "vec2";
+	return "discrete";
+}
+function resolveBoardProperty(targetType, property) {
+	if (targetType === "camera") {
+		const spec = CAMERA_PROPERTIES[property];
+		return spec ? {
+			ok: true,
+			spec
+		} : {
+			ok: false,
+			message: `camera has no property ${property}; expected ${Object.keys(CAMERA_PROPERTIES).join(", ")}`
+		};
+	}
+	if (targetType === "animation") {
+		const spec = ANIMATION_PROPERTIES[property];
+		return spec ? {
+			ok: true,
+			spec
+		} : {
+			ok: false,
+			message: `animations are driven through time`
+		};
+	}
+	const path = property.split(".");
+	if (path.some((segment) => !segment) || NOT_ANIMATABLE.has(path[0])) return {
+		ok: false,
+		message: `${property} cannot be animated`
+	};
+	const schema = boardItemSchema(targetType);
+	if (!schema) return {
+		ok: false,
+		message: `unknown item type ${targetType}`
+	};
+	if (!isBuiltinItemType(targetType) && path[0] === "props") return {
+		ok: true,
+		spec: {
+			kind: "discrete",
+			schema: z.unknown()
 		}
-	});
+	};
+	const leaf = schemaAtPath(schema, path);
+	if (!leaf) return {
+		ok: false,
+		message: `${targetType} has no property ${property}`
+	};
+	const kind = kindOf(leaf, path);
+	return {
+		ok: true,
+		spec: {
+			kind,
+			schema: unwrap(leaf),
+			...property === "opacity" || kind === "scale" ? { multiplicative: true } : {}
+		}
+	};
+}
+function lastKeyframeAt(trackPatches) {
+	let end = 0;
+	for (const track of trackPatches) {
+		const keyframes = track?.keyframes;
+		if (!Array.isArray(keyframes)) continue;
+		for (const keyframe of keyframes) {
+			const at = keyframe?.at;
+			if (typeof at === "number" && Number.isFinite(at)) end = Math.max(end, at);
+		}
+	}
+	return end > 0 ? end : void 0;
+}
+function trackReferences(track) {
+	const refs = /* @__PURE__ */ new Set([track.target]);
+	if (track.target === "camera" && track.property === "focus") {
+		for (const keyframe of track.keyframes) if (typeof keyframe.value === "string") refs.add(keyframe.value);
+	}
+	refs.delete(BOARD_CAMERA_TARGET);
+	return [...refs];
+}
+function pruneBoardTrack(track, deleted) {
+	if (deleted.has(track.target)) return null;
+	if (track.target !== "camera" || track.property !== "focus") return track;
+	const keyframes = track.keyframes.filter((entry) => typeof entry.value !== "string" || !deleted.has(entry.value));
+	if (keyframes.length === track.keyframes.length) return track;
+	return keyframes.length ? {
+		...track,
+		keyframes
+	} : null;
+}
+function error(path, code, message) {
+	return {
+		severity: "error",
+		code,
+		path,
+		message
+	};
 }
-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$1,
-		y: finiteSchema$1,
-		width: finiteSchema$1.positive(),
-		height: finiteSchema$1.positive()
-	}).optional()
-});
-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)
-});
-/** Persisted on `boards.metadata.playback`: how a Board plays when opened. */
-const BoardPlaybackPolicySchema = z.object({
-	compositionId: idSchema,
-	/** Delay before the first local playback after opening the Board, in milliseconds. */
-	delayMs: finiteSchema$1.nonnegative().default(0)
-});
-function parseBoardPlaybackPolicy(metadata) {
-	const parsed = BoardPlaybackPolicySchema.safeParse(metadata.playback);
-	return parsed.success ? parsed.data : null;
+function stripId(value) {
+	if (!("id" in value)) return value;
+	const { id: _id, ...rest } = value;
+	return rest;
 }
-z.discriminatedUnion("type", [
-	z.object({
-		commandId: idSchema,
-		type: z.literal("play"),
-		compositionId: idSchema,
-		position: finiteSchema$1.nonnegative().optional(),
-		timeScale: finiteSchema$1.positive().max(4).optional(),
-		shared: z.boolean().optional(),
-		seed: idSchema.optional()
-	}),
-	z.object({
-		commandId: idSchema,
-		type: z.literal("pause"),
-		playbackId: z.string().uuid()
-	}),
-	z.object({
-		commandId: idSchema,
-		type: z.literal("seek"),
-		playbackId: z.string().uuid(),
-		position: finiteSchema$1.nonnegative()
-	}),
-	z.object({
-		commandId: idSchema,
-		type: z.literal("stop"),
-		playbackId: z.string().uuid()
-	})
-]);
-//#endregion
-//#region ../protocol/dist/board-animation.js
-const extensionKindSchema = z.string().regex(/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)+$/).max(160);
-const jsonObjectSchema = z.record(z.string(), z.unknown());
-const finiteSchema = z.number().finite();
-/** Parameters shared by the built-in deal entrance preset. */
-const BoardDealParamsSchema = z.object({
-	lift: finiteSchema.nonnegative().max(2e3).optional(),
-	swing: finiteSchema.nonnegative().max(2e3).optional(),
-	curve: finiteSchema.nonnegative().max(2e3).optional(),
-	tilt: finiteSchema.nonnegative().max(180).optional(),
-	scale: finiteSchema.positive().max(2).optional(),
-	duration: finiteSchema.positive().max(1e4).optional(),
-	landing: finiteSchema.nonnegative().max(1e4).optional()
-}).strict();
-/** A versioned, reusable animation preset reference. */
-const BoardAnimationSpecSchema = z.object({
-	kind: extensionKindSchema,
-	kindVersion: z.number().int().positive().default(1),
-	params: jsonObjectSchema.default({})
-}).strict().superRefine((spec, context) => {
-	if (spec.kind !== "effects.deal" || spec.kindVersion !== 1) return;
-	const parsed = BoardDealParamsSchema.safeParse(spec.params);
-	if (parsed.success) return;
-	context.addIssue({
-		code: "custom",
-		message: parsed.error.issues[0]?.message ?? "invalid effects.deal parameters",
-		path: ["params", ...parsed.error.issues[0]?.path ?? []]
-	});
-});
-/** Board-wide default motion policies. Omitted policies mean no motion. */
-const BoardMotionSchema = z.object({ enter: BoardAnimationSpecSchema.optional() }).strict();
-//#endregion
-//#region ../protocol/dist/board-capability-registry.js
-const CLIPS = new Set(BOARD_BUILTIN_CLIP_KINDS);
-const EFFECTS = new Set(BOARD_BUILTIN_EFFECT_KINDS);
-const BUILTIN_VERSIONS = new Set(BOARD_BUILTIN_CAPABILITIES.map((c) => `${c.kind}:${c.id}@${c.version}`));
-/**
-* True when a built-in renderer exists for exactly this kind@version. A known
-* kind at an unknown version is not built-in: it must not pass as one.
-*/
-function isBuiltinBoardCapability(kind, id, version) {
-	return BUILTIN_VERSIONS.has(`${kind}:${id}@${version}`);
-}
-const record$1 = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
-const finite$1 = (value) => typeof value === "number" && Number.isFinite(value);
-function validateBuiltinBoardClip(clip, path = "clip") {
-	if (!CLIPS.has(clip.kind)) return [];
-	const errors = [];
-	const error = (message, suffix, coordinateSpace, code = "INVALID_BOARD_CLIP") => {
-		errors.push({
-			severity: "error",
-			code,
-			message,
-			path: `${path}.${suffix}`,
-			...coordinateSpace ? { coordinateSpace } : {}
-		});
+function applyBoardPatch(state, input, options = {}) {
+	const parsedPatch = BoardPatchSchema.safeParse(input);
+	if (!parsedPatch.success) return {
+		ok: false,
+		diagnostics: parsedPatch.error.issues.map((issue) => error(issue.path.map(String).join("."), "INVALID_PATCH", issue.message))
 	};
-	if ((clip.kind.startsWith("motion.") || clip.kind.startsWith("draw.") || clip.kind === "text.reveal" || clip.kind === "effects.trail") && clip.target.type !== "item") error(`${clip.kind} must target an item`, "target");
-	if (clip.kind.startsWith("camera.") && clip.target.type !== "camera") error(`${clip.kind} must target the camera`, "target");
-	if (clip.kind === "motion.path") {
-		const points = clip.params.points;
-		if (!Array.isArray(points) || points.length < 2 || points.length > 1e4) error("motion path must contain 2 to 10000 world-offset points", "params.points", "world-offset");
-		else for (const [index, point] of points.entries()) if (!record$1(point) || !finite$1(point.x) || !finite$1(point.y)) error("motion path point must contain finite x and y", `params.points.${index}`, "world-offset");
-	}
-	if (clip.kind === "effects.particles") {
-		const count = clip.params.count;
-		if (!Number.isSafeInteger(count) || count < 1 || count > DEFAULT_BOARD_RENDER_LIMITS.particles) error(`particle count must be an integer from 1 to ${DEFAULT_BOARD_RENDER_LIMITS.particles}`, "params.count", void 0, "INVALID_PARTICLE_COUNT");
-		const bounds = clip.params.bounds;
-		if (!record$1(bounds) || !finite$1(bounds.x) || !finite$1(bounds.y) || !finite$1(bounds.width) || !finite$1(bounds.height) || bounds.width <= 0 || bounds.height <= 0) error("particles require positive finite world bounds", "params.bounds", "world", "PARTICLE_BOUNDS_REQUIRED");
-	}
-	if (clip.kind === "camera.focus") {
-		const parsed = BoardCameraFocusParamsSchema.safeParse(clip.params);
-		if (!parsed.success) error(parsed.error.issues[0]?.message ?? "invalid camera focus", "params", "world");
-	}
-	return errors;
-}
-function validateBuiltinBoardEffect(effect, path = "effect") {
+	const patch = parsedPatch.data;
 	const diagnostics = [];
-	if (effect.lifecycle === "on-enter") {
-		if (effect.target.type !== "item") diagnostics.push({
-			severity: "error",
-			code: "INVALID_BOARD_EFFECT",
-			message: "on-enter effects must target an item",
-			path: `${path}.target`
-		});
-		if (effect.timeOrigin !== "activation") diagnostics.push({
-			severity: "error",
-			code: "INVALID_BOARD_EFFECT",
-			message: "on-enter effects must use activation time",
-			path: `${path}.timeOrigin`
-		});
-	} else if (EFFECTS.has(effect.kind) && effect.target.type !== "item") diagnostics.push({
-		severity: "error",
-		code: "INVALID_BOARD_EFFECT",
-		message: `${effect.kind} must target an item`,
-		path: `${path}.target`
-	});
-	if (effect.kind === "effects.deal" && effect.kindVersion === 1) {
-		if (effect.lifecycle !== "on-enter") diagnostics.push({
-			severity: "error",
-			code: "INVALID_BOARD_EFFECT",
-			message: "effects.deal must use the on-enter lifecycle",
-			path: `${path}.lifecycle`
-		});
-		const parsed = BoardDealParamsSchema.safeParse(effect.params);
-		if (!parsed.success) diagnostics.push({
-			severity: "error",
-			code: "INVALID_BOARD_EFFECT",
-			message: parsed.error.issues[0]?.message ?? "invalid effects.deal parameters",
-			path: `${path}.params`
-		});
+	const nextItems = /* @__PURE__ */ new Map();
+	const nextAnimations = /* @__PURE__ */ new Map();
+	const nextTracks = /* @__PURE__ */ new Map();
+	let nextSettings;
+	const item = (id) => nextItems.has(id) ? nextItems.get(id) ?? void 0 : state.item(id);
+	const animation = (id) => nextAnimations.has(id) ? nextAnimations.get(id) ?? void 0 : state.animation(id);
+	const setTrack = (animationId, trackId, value) => {
+		const tracks = nextTracks.get(animationId) ?? /* @__PURE__ */ new Map();
+		tracks.set(trackId, value);
+		nextTracks.set(animationId, tracks);
+	};
+	const track = (animationId, trackId) => {
+		const pending = nextTracks.get(animationId);
+		if (pending?.has(trackId)) return pending.get(trackId) ?? void 0;
+		return state.track(animationId, trackId);
+	};
+	if (patch.board !== void 0) {
+		const merged = patch.board === null ? {} : mergePatch(state.settings(), patch.board);
+		const parsed = BoardSettingsSchema.safeParse(merged);
+		if (parsed.success) nextSettings = parsed.data;
+		else for (const issue of parsed.error.issues) diagnostics.push(error(["board", ...issue.path.map(String)].join("."), "INVALID_BOARD", issue.message));
+	}
+	const zByParent = /* @__PURE__ */ new Map();
+	for (const [id, value] of Object.entries(patch.items ?? {})) {
+		if (value === null) {
+			if (state.item(id)) nextItems.set(id, null);
+			continue;
+		}
+		const current = state.item(id);
+		const body = stripId(value);
+		const candidate = !current || typeof body.type === "string" && body.type !== current.type ? { ...body } : mergePatch(current, body);
+		if (candidate.z === void 0) {
+			const parent = typeof candidate.parent === "string" ? candidate.parent : void 0;
+			const key = parent ?? "";
+			const top = zByParent.get(key) ?? state.maxZ(parent);
+			candidate.z = current?.z ?? top + 1;
+			if (!current) zByParent.set(key, top + 1);
+		}
+		const parsed = parseBoardItem(candidate, `items.${id}`);
+		if (!parsed.ok) {
+			diagnostics.push(...parsed.diagnostics);
+			continue;
+		}
+		if (current && boardJsonEquals(current, parsed.item)) continue;
+		nextItems.set(id, parsed.item);
+	}
+	for (const [id, value] of Object.entries(patch.animations ?? {})) {
+		if (value === null) {
+			if (!state.animation(id)) continue;
+			nextAnimations.set(id, null);
+			for (const trackId of state.trackIds(id)) setTrack(id, trackId, null);
+			continue;
+		}
+		const { tracks, ...headerPatch } = stripId(value);
+		if (state.item(id) || nextItems.get(id)) {
+			diagnostics.push(error(`animations.${id}`, "ID_CONFLICT", `${id} is already an item id`));
+			continue;
+		}
+		const current = state.animation(id);
+		if (!current || Object.keys(headerPatch).length > 0) {
+			const header = current ? mergePatch(current, headerPatch) : {
+				...headerPatch,
+				...headerPatch.duration === void 0 ? { duration: lastKeyframeAt([...Object.values(tracks ?? {}), ...state.trackIds(id).map((trackId) => state.track(id, trackId))]) } : {}
+			};
+			const parsed = BoardAnimationHeaderSchema.safeParse(header);
+			if (!parsed.success) {
+				for (const issue of parsed.error.issues) diagnostics.push(error([
+					"animations",
+					id,
+					...issue.path.map(String)
+				].join("."), "INVALID_ANIMATION", issue.message));
+				continue;
+			}
+			if (!current || !boardJsonEquals(current, parsed.data)) nextAnimations.set(id, parsed.data);
+		}
+		for (const [trackId, trackPatch] of Object.entries(tracks ?? {})) {
+			const existing = state.track(id, trackId);
+			if (trackPatch === null) {
+				if (existing) setTrack(id, trackId, null);
+				continue;
+			}
+			const parsed = BoardTrackSchema.safeParse(existing ? mergePatch(existing, trackPatch) : trackPatch);
+			if (!parsed.success) {
+				for (const issue of parsed.error.issues) diagnostics.push(error([
+					"animations",
+					id,
+					"tracks",
+					trackId,
+					...issue.path.map(String)
+				].join("."), "INVALID_TRACK", issue.message));
+				continue;
+			}
+			if (!existing || !boardJsonEquals(existing, parsed.data)) setTrack(id, trackId, parsed.data);
+		}
+	}
+	for (const id of nextItems.keys()) if (nextItems.get(id) && animation(id)) diagnostics.push(error(`items.${id}`, "ID_CONFLICT", `${id} is already an animation id`));
+	if (diagnostics.length) return {
+		ok: false,
+		diagnostics
+	};
+	const deletedItems = [...nextItems].filter(([, value]) => value === null).map(([id]) => id);
+	const deletionLayout = createBoardLayout((id) => item(id) ?? state.item(id));
+	const pendingDeletes = [...deletedItems];
+	while (pendingDeletes.length) {
+		const id = pendingDeletes.pop();
+		for (const child of state.children(id)) {
+			if (nextItems.has(child) && nextItems.get(child)?.parent !== id) continue;
+			if (options.cascade) {
+				if (nextItems.get(child) !== null) {
+					nextItems.set(child, null);
+					pendingDeletes.push(child);
+				}
+			} else diagnostics.push(error(`items.${id}`, "ITEM_REFERENCED", `${id} still has child ${child}; delete it too or use cascade`));
+		}
+		for (const arrowId of state.binders(id)) {
+			const arrow = item(arrowId);
+			if (arrow?.type !== "arrow") continue;
+			const props = { ...arrow.props };
+			for (const which of ["start", "end"]) {
+				const end = props[which];
+				if (!isArrowBinding(end) || end.item !== id) continue;
+				const world = options.resolveArrowEnd?.(arrowId, which) ?? deletionLayout.arrowEnd(arrowId, which);
+				props[which] = applyMatrix(invertMatrix(deletionLayout.matrix(arrowId)), world);
+			}
+			nextItems.set(arrowId, {
+				...arrow,
+				props
+			});
+		}
+		for (const ref of state.trackRefs(id)) {
+			const current = track(ref.animation, ref.track);
+			if (!current || !trackReferences(current).includes(id)) continue;
+			if (options.cascade) setTrack(ref.animation, ref.track, pruneBoardTrack(current, /* @__PURE__ */ new Set([id])));
+			else diagnostics.push(error(`items.${id}`, "ITEM_REFERENCED", `${id} is animated by ${ref.animation}.${ref.track}; delete the track or use cascade`));
+		}
+	}
+	for (const [id, value] of nextAnimations) {
+		if (value !== null) continue;
+		for (const ref of state.trackRefs(id)) {
+			if (ref.animation === id || track(ref.animation, ref.track) === void 0) continue;
+			if (options.cascade) setTrack(ref.animation, ref.track, null);
+			else diagnostics.push(error(`animations.${id}`, "ANIMATION_REFERENCED", `${id} is nested in ${ref.animation}.${ref.track}; delete the track or use cascade`));
+		}
+	}
+	const validationState = {
+		...state,
+		trackIds: (id) => [.../* @__PURE__ */ new Set([...state.trackIds(id), ...nextTracks.get(id)?.keys() ?? []])]
+	};
+	const validationItems = new Map(nextItems);
+	const descendants = [];
+	for (const [id, value] of nextItems) if (value && value.parent !== state.item(id)?.parent) descendants.push(...state.children(id));
+	const seenDescendants = /* @__PURE__ */ new Set();
+	while (descendants.length) {
+		const id = descendants.pop();
+		if (seenDescendants.has(id)) continue;
+		seenDescendants.add(id);
+		validationItems.set(id, item(id) ?? null);
+		descendants.push(...state.children(id));
+	}
+	for (const [id, value] of validationItems) {
+		if (!value) continue;
+		if (value.parent !== void 0) {
+			const parent = item(value.parent);
+			if (!parent) diagnostics.push(error(`items.${id}.parent`, "PARENT_NOT_FOUND", `parent ${value.parent} does not exist`));
+			else if (parent.type !== "frame") diagnostics.push(error(`items.${id}.parent`, "INVALID_PARENT", `parent ${value.parent} is a ${parent.type}; only frames contain items`));
+			else {
+				let cursor = value.parent;
+				for (let depth = 0; cursor; depth += 1) {
+					if (depth >= 64) {
+						diagnostics.push(error(`items.${id}.parent`, "PARENT_DEPTH", "parent hierarchy exceeds 64 levels"));
+						break;
+					}
+					if (cursor === id) {
+						diagnostics.push(error(`items.${id}.parent`, "PARENT_CYCLE", `${id} cannot be inside itself`));
+						break;
+					}
+					cursor = item(cursor)?.parent;
+				}
+			}
+		}
+		for (const bound of arrowBindings(value)) {
+			const target = item(bound);
+			if (!target) diagnostics.push(error(`items.${id}.props`, "BINDING_NOT_FOUND", `bound item ${bound} does not exist`));
+			else if (bound === id || target.type === "arrow") diagnostics.push(error(`items.${id}.props`, "INVALID_BINDING", "arrows bind to items other than arrows"));
+		}
+	}
+	for (const [id, value] of nextItems) {
+		if (!value || !state.item(id) || state.item(id)?.type === value.type) continue;
+		if (value.type !== "frame") {
+			for (const child of state.children(id)) if (item(child)?.parent === id) diagnostics.push(error(`items.${child}.parent`, "INVALID_PARENT", `${id} is not a frame`));
+		}
+		if (value.type === "arrow") for (const binder of state.binders(id)) {
+			const arrow = item(binder);
+			if (arrow && arrowBindings(arrow).includes(id)) diagnostics.push(error(`items.${binder}.props`, "INVALID_BINDING", "arrows cannot bind to arrows"));
+		}
+		for (const ref of state.trackRefs(id)) {
+			const current = track(ref.animation, ref.track);
+			if (current) diagnostics.push(...validateTrack(`animations.${ref.animation}.tracks.${ref.track}`, ref.animation, current, item, animation, track, validationState));
+		}
+	}
+	for (const [animationId, tracks] of nextTracks) {
+		if (!animation(animationId)) {
+			for (const [trackId, value] of tracks) if (value) diagnostics.push(error(`animations.${animationId}.tracks.${trackId}`, "ANIMATION_NOT_FOUND", `animation ${animationId} does not exist`));
+			continue;
+		}
+		for (const [trackId, value] of tracks) {
+			if (!value) continue;
+			diagnostics.push(...validateTrack(`animations.${animationId}.tracks.${trackId}`, animationId, value, item, animation, track, validationState));
+		}
+	}
+	if (diagnostics.length) return {
+		ok: false,
+		diagnostics
+	};
+	const before = emptyDelta();
+	const after = emptyDelta();
+	if (nextSettings && !boardJsonEquals(nextSettings, state.settings())) {
+		before.board = state.settings();
+		after.board = nextSettings;
+	}
+	for (const [id, value] of nextItems) {
+		const previous = state.item(id) ?? null;
+		if (boardJsonEquals(previous, value)) continue;
+		before.items[id] = previous;
+		after.items[id] = value;
+	}
+	for (const [id, value] of nextAnimations) {
+		before.animations[id] = state.animation(id) ?? null;
+		after.animations[id] = value;
+	}
+	for (const [animationId, tracks] of nextTracks) for (const [trackId, value] of tracks) {
+		const previous = state.track(animationId, trackId) ?? null;
+		if (boardJsonEquals(previous, value)) continue;
+		slot(before.tracks, animationId)[trackId] = previous;
+		slot(after.tracks, animationId)[trackId] = value;
+	}
+	return {
+		ok: true,
+		before: withoutEmpty(before),
+		after: withoutEmpty(after),
+		diagnostics: []
+	};
+}
+function validateTrack(path, animationId, value, item, animation, track, state) {
+	const diagnostics = [];
+	let targetType;
+	if (value.target === "camera") targetType = BOARD_CAMERA_TARGET;
+	else if (item(value.target)) targetType = item(value.target).type;
+	else if (animation(value.target)) {
+		targetType = "animation";
+		if (value.target === animationId || nestsInto(value.target, animationId, animation, track, state)) return [error(`${path}.target`, "ANIMATION_CYCLE", `${animationId} cannot contain itself through ${value.target}`)];
+	} else return [error(`${path}.target`, "TARGET_NOT_FOUND", `target ${value.target} is not an item, animation or camera`)];
+	const resolved = resolveBoardProperty(targetType, value.property);
+	if (!resolved.ok) return [error(`${path}.property`, "INVALID_PROPERTY", resolved.message)];
+	for (const [index, keyframe] of value.keyframes.entries()) {
+		const parsed = resolved.spec.schema.safeParse(keyframe.value);
+		if (!parsed.success) {
+			diagnostics.push(error(`${path}.keyframes.${index}.value`, "INVALID_KEYFRAME", parsed.error.issues[0]?.message ?? "invalid value"));
+			continue;
+		}
+		if (value.property === "focus" && typeof keyframe.value === "string" && !item(keyframe.value)) diagnostics.push(error(`${path}.keyframes.${index}.value`, "TARGET_NOT_FOUND", `focus item ${keyframe.value} does not exist`));
 	}
+	if (value.interpolation === "spline" && resolved.spec.kind !== "vec2") diagnostics.push(error(`${path}.interpolation`, "INVALID_TRACK", "spline interpolation needs a position-like property"));
 	return diagnostics;
 }
-function estimateBuiltinBoardEffectCost(effect) {
-	return isBuiltinBoardCapability("effect", effect.kind, effect.kindVersion) ? { drawCalls: 1 } : {};
+function nestsInto(from, into, animation, track, state) {
+	const seen = /* @__PURE__ */ new Set();
+	const stack = [from];
+	while (stack.length) {
+		const current = stack.pop();
+		if (current === into) return true;
+		if (seen.has(current) || !animation(current)) continue;
+		seen.add(current);
+		for (const trackId of state.trackIds(current)) {
+			const value = track(current, trackId);
+			if (value && value.property === "time" && animation(value.target)) stack.push(value.target);
+		}
+	}
+	return false;
 }
-function estimateBuiltinBoardClipCost(clip) {
-	switch (clip.kind) {
-		case "effects.particles": {
-			const count = Number.isSafeInteger(clip.params.count) ? Math.max(0, clip.params.count) : 0;
-			return {
-				particles: count,
-				vertices: count * 4,
-				dynamicVertices: count * 4,
-				drawCalls: 1,
-				bufferBytes: count * 48,
-				simulationSteps: count
-			};
+function createDocumentState(document) {
+	let children = null;
+	let binders = null;
+	let refs = null;
+	const index = () => {
+		if (children) return;
+		children = /* @__PURE__ */ new Map();
+		binders = /* @__PURE__ */ new Map();
+		refs = /* @__PURE__ */ new Map();
+		for (const [id, value] of Object.entries(document.items)) {
+			if (value.parent) children.set(value.parent, [...children.get(value.parent) ?? [], id]);
+			for (const bound of arrowBindings(value)) binders.set(bound, [...binders.get(bound) ?? [], id]);
 		}
-		case "effects.trail": return {
-			vertices: 32,
-			dynamicVertices: 32,
-			drawCalls: 1,
-			bufferBytes: 1024,
-			simulationSteps: 16
-		};
-		case "effects.impact":
-		case "effects.flash": return {
-			vertices: 64,
-			drawCalls: 1
-		};
-		case "draw.reveal": return {
-			drawCalls: 1,
-			dynamicVertices: 1
+		for (const [animationId, value] of Object.entries(document.animations)) for (const [trackId, track] of Object.entries(value.tracks)) for (const ref of trackReferences(track)) refs.set(ref, [...refs.get(ref) ?? [], {
+			animation: animationId,
+			track: trackId
+		}]);
+	};
+	return {
+		settings: () => document.board,
+		item: (id) => document.items[id],
+		animation: (id) => {
+			const value = document.animations[id];
+			if (!value) return void 0;
+			const { tracks: _tracks, ...header } = value;
+			return header;
+		},
+		track: (animationId, trackId) => document.animations[animationId]?.tracks[trackId],
+		trackIds: (animationId) => Object.keys(document.animations[animationId]?.tracks ?? {}),
+		children: (id) => {
+			index();
+			return children?.get(id) ?? [];
+		},
+		binders: (id) => {
+			index();
+			return binders?.get(id) ?? [];
+		},
+		trackRefs: (id) => {
+			index();
+			return refs?.get(id) ?? [];
+		},
+		maxZ: (parent) => {
+			let max = 0;
+			for (const value of Object.values(document.items)) if (value.parent === parent && (value.z ?? 0) > max) max = value.z ?? 0;
+			return max;
+		}
+	};
+}
+function applyBoardDelta(document, delta) {
+	const items = delta.items ? { ...document.items } : document.items;
+	for (const [id, value] of Object.entries(delta.items ?? {})) if (value) items[id] = value;
+	else delete items[id];
+	const animations = delta.animations || delta.tracks ? { ...document.animations } : document.animations;
+	for (const [id, value] of Object.entries(delta.animations ?? {})) if (value) animations[id] = {
+		...value,
+		tracks: animations[id]?.tracks ?? {}
+	};
+	else delete animations[id];
+	for (const [animationId, tracks] of Object.entries(delta.tracks ?? {})) {
+		const current = animations[animationId];
+		if (!current) continue;
+		const nextTracks = { ...current.tracks };
+		for (const [trackId, value] of Object.entries(tracks)) if (value) nextTracks[trackId] = value;
+		else delete nextTracks[trackId];
+		animations[animationId] = {
+			...current,
+			tracks: nextTracks
 		};
-		case "motion.path": return { simulationSteps: Array.isArray(clip.params.points) ? clip.params.points.length : 0 };
-		default: return {};
 	}
+	return {
+		board: delta.board ?? document.board,
+		items,
+		animations
+	};
+}
+function applyBoardPatchToDocument(document, patch, options = {}) {
+	const result = applyBoardPatch(createDocumentState(document), patch, options);
+	return result.ok ? {
+		ok: true,
+		document: applyBoardDelta(document, result.after),
+		before: result.before,
+		after: result.after
+	} : result;
+}
+function parseBoardDocument(input) {
+	if (!isRecord$6(input)) return {
+		ok: false,
+		diagnostics: [error("", "INVALID_DOCUMENT", "expected an object")]
+	};
+	const result = applyBoardPatchToDocument({
+		board: BoardSettingsSchema.parse({}),
+		items: {},
+		animations: {}
+	}, {
+		...isRecord$6(input.board) ? { board: input.board } : {},
+		...isRecord$6(input.items) ? { items: input.items } : {},
+		...isRecord$6(input.animations) ? { animations: input.animations } : {}
+	});
+	return result.ok ? {
+		ok: true,
+		document: result.document
+	} : result;
 }
 //#endregion
 //#region ../protocol/dist/board-url.js
@@ -449,588 +1693,343 @@ function isBlockedIpv6(host) {
 		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({
-	/** Legacy field retained when reading older Board documents; not used for rendering. */
-	theme: z.string().min(1).optional(),
-	/** Board-wide motion policies. Omitted policies mean no motion. */
-	motion: BoardMotionSchema.optional(),
-	/** Legacy field retained when reading older Board documents; not used for rendering. */
-	mood: z.enum([
-		"clean",
-		"playful",
-		"arcane",
-		"cyber",
-		"natural"
-	]).optional(),
-	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
-	})
-});
-/** 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,
-	parentId: z.string().min(1).nullable().optional(),
-	/** 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));
+	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;
+}
 /**
-* 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.
+* 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 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 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;
 	}
 }
-function makeUnknownItem(raw) {
-	const record = raw && typeof raw === "object" ? raw : {};
-	const frameParsed = BoardFrameSchema.safeParse(record.frame);
-	const styleParsed = BoardItemStyleSchema.safeParse(record.style);
+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/turn-origin.js
+const record$2 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
+const normalizeSessionTurnOrigin = (value) => {
+	const input = record$2(value);
+	if (!input || ![
+		"prompt",
+		"scheduled_prompt",
+		"background_task",
+		"hook"
+	].includes(String(input.kind))) return null;
+	const source = normalizeRequestSource(input);
+	if (!source?.spaceId || !source.sessionId || !source.turnId) return null;
 	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
-		},
-		...typeof record.parentId === "string" || record.parentId === null ? { parentId: record.parentId } : {},
-		...record.locked === true ? { locked: true } : {},
-		...styleParsed.success && record.style ? { style: styleParsed.data } : {},
-		...record.metadata && typeof record.metadata === "object" ? { metadata: record.metadata } : {},
-		raw: record
+		kind: input.kind,
+		spaceId: source.spaceId,
+		sessionId: source.sessionId,
+		turnId: source.turnId,
+		...source.toolCallId ? { toolCallId: source.toolCallId } : {},
+		...typeof input.depth === "number" && Number.isSafeInteger(input.depth) && input.depth > 0 ? { depth: input.depth } : {}
 	};
-}
-z.object({
-	kind: z.literal(BOARD_DOCUMENT_KIND),
-	version: z.literal(1),
-	appearance: BoardAppearanceSchema.default({
-		background: { kind: "solid" },
-		grid: {
-			visible: false,
-			size: 24,
-			opacity: .12
-		}
-	}),
-	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([])
-});
+};
+/** Reads durable provenance; legacy background tasks only knew their caller's Session/Turn. */
+const readSessionTurnOrigin = (meta, spaceId) => {
+	const input = record$2(meta);
+	const origin = normalizeSessionTurnOrigin(input?.origin);
+	if (origin) return origin;
+	const context = record$2(input?.context);
+	if (context?.kind !== "background_bash_task" || !isUuidLike(spaceId)) return null;
+	const legacy = record$2(context.origin);
+	return normalizeSessionTurnOrigin({
+		...legacy,
+		spaceId,
+		kind: "background_task"
+	});
+};
 //#endregion
-//#region ../protocol/dist/board-node.js
-const BOARD_COLOR_IDS = [
-	"brand",
-	"neutral",
-	"black",
-	"white",
-	"blue",
-	"green",
-	"amber",
-	"violet",
-	"rose"
-];
-const BoardColorIdSchema = z.enum(BOARD_COLOR_IDS);
-const BOARD_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"
+//#region ../protocol/dist/sent-turns.js
+const KINDS = [
+	"prompt",
+	"scheduled_prompt",
+	"background_task",
+	"hook"
 ];
-const metadataSchema = z.record(z.string(), z.unknown());
-const commonData = {
-	locked: z.boolean().optional(),
-	metadata: metadataSchema.optional()
+const record$1 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
+const normalizeSentTurnRef = (value) => {
+	const input = record$1(value);
+	if (!input) return null;
+	if (!isUuidLike(input.sessionId) || !isUuidLike(input.turnId)) return null;
+	const kind = String(input.kind);
+	if (!KINDS.includes(kind)) return null;
+	const source = normalizeRequestSource({
+		spaceId: input.spaceId,
+		toolCallId: input.toolCallId
+	});
+	return {
+		...source?.spaceId ? { spaceId: source.spaceId } : {},
+		sessionId: input.sessionId,
+		turnId: input.turnId,
+		kind,
+		...source?.toolCallId ? { toolCallId: source.toolCallId } : {}
+	};
 };
-const pointSchema = z.object({
-	x: z.number().finite(),
-	y: z.number().finite(),
-	p: z.number().finite().min(0).max(1).default(.5)
-}).strict();
-const worldPointSchema = z.object({
-	x: z.number().finite(),
-	y: z.number().finite()
-}).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()
-}).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"),
-		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,
-		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),
-		arrowStart: z.boolean().default(false),
-		arrowEnd: z.boolean().default(true),
-		label: z.string().default("")
-	}).strict(),
-	frame: z.object({
-		...commonData,
-		label: z.string().default("Frame"),
-		color: BoardColorIdSchema.default("neutral")
-	}).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()
-	}).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)
-	}).strict()
+/** Deduplicates by child Turn, so a retried request cannot render one twice. */
+const readSentTurns = (meta) => {
+	const raw = record$1(meta)?.messagesSent;
+	if (!Array.isArray(raw)) return [];
+	const seen = /* @__PURE__ */ new Set();
+	const refs = [];
+	for (const value of raw) {
+		const ref = normalizeSentTurnRef(value);
+		if (!ref || seen.has(ref.turnId)) continue;
+		seen.add(ref.turnId);
+		refs.push(ref);
+	}
+	return refs;
 };
-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()
-}).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
+//#endregion
+//#region ../protocol/dist/display/actions.js
+const DISPLAY_ACTION_TYPES = [
+	"tap",
+	"long_press",
+	"swipe",
+	"scroll",
+	"type",
+	"key",
+	"system",
+	"wait"
+];
+const ACTION_GAP_MS = 150;
+const TAP_MS = 60;
+const MULTI_TAP_GAP_MS = 80;
+const LONG_PRESS_MS = 800;
+const SWIPE_MS = 300;
+const SCROLL_MS = 400;
+const WAIT_MS = 500;
+const MAX_STEP_MS = 1e4;
+var DisplayActionError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "DisplayActionError";
+	}
 };
-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())
-}).strict();
-function jsonSchema(schema) {
-	return z.toJSONSchema(schema);
+const MODIFIER_ALIASES = {
+	control: "Control",
+	ctrl: "Control",
+	alt: "Alt",
+	option: "Alt",
+	shift: "Shift",
+	meta: "Meta",
+	cmd: "Meta",
+	command: "Meta",
+	super: "Meta",
+	win: "Meta"
+};
+function displayKeyEvents(key, modifiers = [], t) {
+	const at = t === void 0 ? {} : { t };
+	return [
+		...modifiers.map((modifier) => ({
+			type: "key",
+			action: "down",
+			key: modifier,
+			...at
+		})),
+		{
+			type: "key",
+			action: "press",
+			key,
+			...at
+		},
+		...[...modifiers].reverse().map((modifier) => ({
+			type: "key",
+			action: "up",
+			key: modifier,
+			...at
+		}))
+	];
+}
+function parseDisplayKeyCombo(combo) {
+	const parts = combo.length > 1 && combo.endsWith("++") ? [...combo.slice(0, -2).split("+"), "+"] : combo.length > 1 ? combo.split("+") : [combo];
+	const key = parts.pop() ?? "";
+	const modifiers = parts.map((part) => MODIFIER_ALIASES[part.trim().toLowerCase()]);
+	if (!key || modifiers.some((modifier) => !modifier)) throw new DisplayActionError(`unknown key combo "${combo}"`);
+	return {
+		key: MODIFIER_ALIASES[key.toLowerCase()] ?? key,
+		modifiers: [...new Set(modifiers)]
+	};
+}
+function compileDisplayActions(actions, width, height) {
+	const events = [];
+	let t = 0;
+	const point = (action, xKey = "x", yKey = "y") => {
+		const x = action[xKey];
+		const y = action[yKey];
+		if (typeof x !== "number" || typeof y !== "number" || !Number.isFinite(x) || !Number.isFinite(y)) throw new DisplayActionError(`${action.type} needs ${xKey} and ${yKey}`);
+		if (x < 0 || y < 0 || x >= width || y >= height) throw new DisplayActionError(`${action.type} at (${x}, ${y}) is outside the ${width}×${height} image`);
+		return normalizeDisplayPoint(x, y, width, height);
+	};
+	const duration = (action, fallback) => Math.round(Math.min(MAX_STEP_MS, Math.max(1, action.duration_ms ?? fallback)));
+	const element = (ref, elementAction, text) => {
+		if (!DISPLAY_ELEMENT_REF_PATTERN.test(ref)) throw new DisplayActionError(`"${ref}" is not an element ref such as e3.12`);
+		events.push({
+			type: "element",
+			ref,
+			action: elementAction,
+			...text === void 0 ? {} : { text },
+			t
+		});
+		t += TAP_MS;
+	};
+	for (const action of actions) {
+		if (action.ref !== void 0) {
+			if (action.type === "tap" && (action.count ?? 1) === 1 && (action.button ?? "primary") === "primary") element(action.ref, "click");
+			else if (action.type === "long_press") element(action.ref, "longPress");
+			else if (action.type === "type") {
+				if (action.text === void 0 || action.text.length > 4096) throw new DisplayActionError(`type into an element needs text of at most ${DISPLAY_INPUT_MAX_TEXT} characters`);
+				element(action.ref, "setText", action.text);
+			} else if (action.type === "scroll") element(action.ref, action.direction === "up" || action.direction === "left" ? "scrollBackward" : "scrollForward");
+			else throw new DisplayActionError(`${action.type} cannot take a ref; use coordinates`);
+			t += ACTION_GAP_MS;
+			continue;
+		}
+		switch (action.type) {
+			case "tap": {
+				const at = {
+					...point(action),
+					...action.button && action.button !== "primary" ? { button: action.button } : {}
+				};
+				const count = Math.round(Math.min(3, Math.max(1, action.count ?? 1)));
+				for (let tap = 0; tap < count; tap++) {
+					if (tap > 0) t += MULTI_TAP_GAP_MS;
+					events.push({
+						type: "pointer",
+						action: "down",
+						...at,
+						t
+					}, {
+						type: "pointer",
+						action: "up",
+						...at,
+						t: t + TAP_MS
+					});
+					t += TAP_MS;
+				}
+				break;
+			}
+			case "long_press": {
+				const at = point(action);
+				const hold = duration(action, LONG_PRESS_MS);
+				events.push({
+					type: "pointer",
+					action: "down",
+					...at,
+					t
+				}, {
+					type: "pointer",
+					action: "up",
+					...at,
+					t: t + hold
+				});
+				t += hold;
+				break;
+			}
+			case "swipe": {
+				const from = point(action);
+				const to = point(action, "to_x", "to_y");
+				const length = duration(action, SWIPE_MS);
+				events.push({
+					type: "pointer",
+					action: "down",
+					...from,
+					t
+				}, {
+					type: "pointer",
+					action: "move",
+					x: (from.x + to.x) / 2,
+					y: (from.y + to.y) / 2,
+					t: t + Math.round(length / 2)
+				}, {
+					type: "pointer",
+					action: "up",
+					...to,
+					t: t + length
+				});
+				t += length;
+				break;
+			}
+			case "scroll": {
+				const at = typeof action.x === "number" || typeof action.y === "number" ? point(action) : {
+					x: .5,
+					y: .5
+				};
+				const amount = Math.min(1, Math.max(.1, action.amount ?? .5));
+				const direction = action.direction ?? "down";
+				const dx = direction === "right" ? amount : direction === "left" ? -amount : 0;
+				const dy = direction === "down" ? amount : direction === "up" ? -amount : 0;
+				events.push({
+					type: "scroll",
+					...at,
+					dx,
+					dy,
+					t
+				});
+				t += SCROLL_MS;
+				break;
+			}
+			case "type":
+				if (!action.text) throw new DisplayActionError("type needs text");
+				for (const text of splitDisplayText(action.text)) events.push({
+					type: "text",
+					text,
+					t
+				});
+				break;
+			case "key": {
+				if (!action.key) throw new DisplayActionError("key needs a key");
+				const { key, modifiers } = parseDisplayKeyCombo(action.key);
+				events.push(...displayKeyEvents(key, modifiers, t));
+				break;
+			}
+			case "system":
+				if (!action.action) throw new DisplayActionError("system needs an action");
+				events.push({
+					type: "system",
+					action: action.action,
+					t
+				});
+				break;
+			case "wait":
+				t += duration(action, WAIT_MS);
+				break;
+			default: throw new DisplayActionError(`unknown action ${String(action.type)}`);
+		}
+		t += ACTION_GAP_MS;
+		if (t > 6e4) throw new DisplayActionError("the actions take longer than a minute; split them up");
+	}
+	if (events.length === 0) throw new DisplayActionError("no action touches the display");
+	return events;
 }
-jsonSchema(nodeEnvelopeSchema), Object.fromEntries(BOARD_NATIVE_NODE_TYPES.map((type) => [type, jsonSchema(dataSchemas[type])])), Object.fromEntries(BOARD_NATIVE_NODE_TYPES.map((type) => [type, jsonSchema(viewSchemas[type])]));
 //#endregion
 //#region ../protocol/dist/generation/catalog.js
 function isGenerationModelHidden(model) {
@@ -1936,6 +2935,54 @@ function fingerprintProjectionTurns(turns) {
 	return `${turns.length}:${fingerprint(turns)}`;
 }
 //#endregion
+//#region ../protocol/dist/core/image.js
+/** Pi only models inline image bytes; remote images travel through it under this MIME type with the URL as `data`. */
+const IMAGE_URL_MIME_TYPE = "application/x-cohub-image-url";
+const imageUrlContent = (url) => ({
+	type: "image",
+	data: url,
+	mimeType: IMAGE_URL_MIME_TYPE
+});
+const DATA_URL_PATTERN = /^data:([^;,]*)((?:;[^;,]*)*);base64,/i;
+function parseBase64DataUrl(value) {
+	const match = DATA_URL_PATTERN.exec(value.trimStart());
+	if (!match) return null;
+	return {
+		mediaType: match[1]?.trim().toLowerCase() || null,
+		data: value.trimStart().slice(match[0].length).trim()
+	};
+}
+const stripDataUrlPrefix = (data) => parseBase64DataUrl(data)?.data ?? data.trim();
+const IMAGE_SIGNATURES = [
+	["image/png", (b) => b[0] === 137 && b[1] === 80 && b[2] === 78 && b[3] === 71],
+	["image/jpeg", (b) => b[0] === 255 && b[1] === 216 && b[2] === 255],
+	["image/gif", (b) => b[0] === 71 && b[1] === 73 && b[2] === 70],
+	["image/webp", (b) => b[0] === 82 && b[1] === 73 && b[2] === 70 && b[3] === 70 && b[8] === 87 && b[9] === 69 && b[10] === 66 && b[11] === 80]
+];
+function sniffImageMimeType(bytes) {
+	return IMAGE_SIGNATURES.find(([, matches]) => matches(bytes))?.[0] ?? null;
+}
+function sniffBase64ImageMimeType(data) {
+	try {
+		return sniffImageMimeType(Uint8Array.from(atob(stripDataUrlPrefix(data).slice(0, 16)), (char) => char.charCodeAt(0)));
+	} catch {
+		return null;
+	}
+}
+function imageBlockToPi(block) {
+	if (block.source.type === "url") {
+		const url = block.source.url.trim();
+		return url ? imageUrlContent(url) : null;
+	}
+	const data = stripDataUrlPrefix(block.source.data);
+	if (!data) return null;
+	return {
+		type: "image",
+		data,
+		mimeType: block.source.media_type && block.source.media_type !== "application/octet-stream" ? block.source.media_type : sniffBase64ImageMimeType(data) ?? "application/octet-stream"
+	};
+}
+//#endregion
 //#region ../protocol/dist/runtime/context.js
 const createEmptyUsage = () => ({
 	input: 0,
@@ -1953,19 +3000,15 @@ const createEmptyUsage = () => ({
 });
 /**
 * Project one block as itself, or drop it. Nothing is ever rewritten into prompt text.
-* URL images, system notes and unknown blocks have no native representation here; the
-* durable copy stays in the database and is not faked into the model's input.
+* Remote images stay URLs for the model runtime to resolve; system notes and unknown blocks
+* have no native representation here, and the durable copy stays in the database.
 */
-function projectBlock(block) {
+function projectBlock(block, remoteImages = true) {
 	if (block.type === "text") return {
 		type: "text",
 		text: block.text
 	};
-	if (block.type === "image") return block.source.type === "base64" ? {
-		type: "image",
-		data: block.source.data,
-		mimeType: block.source.media_type
-	} : null;
+	if (block.type === "image") return remoteImages || block.source.type === "base64" ? imageBlockToPi(block) : null;
 	if (block.type === "thinking") return {
 		type: "thinking",
 		thinking: block.thinking,
@@ -1973,7 +3016,7 @@ function projectBlock(block) {
 	};
 	return null;
 }
-const projectContent = (content) => content.map(projectBlock).filter((block) => block !== null);
+const projectContent = (content) => content.map((block) => projectBlock(block)).filter((block) => block !== null);
 const isCompaction = (message) => message.role === "system" && message.content.some((block) => block.type === "system_note" && block.note_type === "compacted");
 /** A generation placeholder must never be projected as if it were a finished result. */
 const isPendingGenerationResult = (message) => message.role === "assistant" && message.meta?.messageKind === "generation_result" && message.meta?.generationStatus !== "completed" && message.meta?.generationStatus !== "failed";
@@ -2030,7 +3073,7 @@ function contextToPiMessages(messages, options = {}) {
 				name: block.name,
 				arguments: block.input
 			}];
-			const projected = projectBlock(block);
+			const projected = projectBlock(block, false);
 			return projected ? [projected] : [];
 		});
 		if (content.length) result.push({
@@ -2092,7 +3135,7 @@ const resolveHarness = (meta) => {
 	return isLocalHarness(value) ? value : "cohub";
 };
 const runtimeCapabilitiesSchema = z.object({
-	harnesses: z.array(z.enum(["pi", "codex"])).min(1).max(2),
+	harnesses: z.array(z.enum(["pi", "codex"])).max(2),
 	models: z.array(z.object({
 		harness: z.enum(["pi", "codex"]),
 		provider: z.string().max(100),
@@ -2334,6 +3377,7 @@ const runtimeCommandSchema = z.discriminatedUnion("type", [
 ]);
 //#endregion
 //#region ../protocol/dist/public-identifiers.js
+const HOME_SPACE_SLUG = "home";
 const USERNAME_PATTERN = /^(?!-)(?!.*--)[a-z0-9-]{1,39}(?<!-)$/;
 const SPACE_SLUG_PATTERN = /^[a-z0-9](?:[a-z0-9_-]{0,78}[a-z0-9])?$/;
 /**
@@ -4888,6 +5932,10 @@ attach: attachAppEmbed },
 		ensureRealtimeConnected(this.websocketClient);
 		return this.websocketClient.on("event", handler);
 	}
+	/** Current realtime transport state; pair with {@link onConnection} for changes. */
+	get connectionState() {
+		return this.websocketClient.state;
+	}
 	onConnection(handler) {
 		const connectingCleanup = this.websocketClient.on("connecting", (payload) => {
 			handler({
@@ -5027,6 +6075,34 @@ const parseWorkRef = parseAppRef;
 /** @deprecated Use `formatAppRef`. */
 const formatWorkRef = formatAppRef;
 //#endregion
+//#region src/space-ref.ts
+const canonicalUuid = (value) => {
+	const hex = value.replaceAll("-", "").toLowerCase();
+	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+};
+function parseSpaceRef(value) {
+	const trimmed = value.trim();
+	if (isUuidOrShortUuid(trimmed)) return {
+		kind: "id",
+		id: canonicalUuid(trimmed)
+	};
+	const parts = trimmed.split("/");
+	if (parts.length === 2) {
+		const username = parseUsername(parts[0]);
+		const slug = parseSpaceSlug(parts[1]);
+		return username && slug ? {
+			kind: "public",
+			username,
+			slug
+		} : null;
+	}
+	const slug = parts.length === 1 ? parseSpaceSlug(trimmed) : null;
+	return slug ? {
+		kind: "owned",
+		slug
+	} : null;
+}
+//#endregion
 //#region src/app-grant-cache.ts
 const STORAGE_PREFIX = "cohub:work-grants";
 const CACHE_VERSION = 1;
@@ -5236,6 +6312,7 @@ const AUTHORIZE_TIMEOUT_MS = 3e4;
 const MAX_SILENT_SPACE_ATTEMPTS = 4;
 const timeoutSignal = (ms) => typeof AbortSignal !== "undefined" && typeof AbortSignal.timeout === "function" ? AbortSignal.timeout(ms) : void 0;
 const spaceListSignal = () => timeoutSignal(SPACE_LIST_TIMEOUT_MS);
+const SPACE_LIST_PAGE_SIZE = 100;
 var AppAuthorizationError = class extends Error {
 	status;
 	code;
@@ -5848,58 +6925,67 @@ function createAppBridgeCore(config) {
 			...typeof value.isPinned === "boolean" ? { isPinned: value.isPinned } : {}
 		};
 	}
-	/**
-	* Lists the viewer's spaces for the consent dialog picker. Fetched by the
-	* host with the viewer's own token — the app only ever learns the space
-	* the viewer picks, never the list.
-	*/
-	async function listViewerSpaces() {
-		const request = async (forceRefresh = false) => {
+	async function viewerFetch(path, init = {}) {
+		const send = async (forceRefresh) => {
 			const userToken = await getAccessToken({ forceRefresh });
-			if (!userToken) {
-				await startSignIn();
-				throw new AppLoginRedirect();
-			}
-			return fetch(`${apiOrigin}/api/spaces`, {
-				headers: { Authorization: `Bearer ${userToken}` },
+			if (!userToken) return null;
+			return fetch(`${apiOrigin}${path}`, {
+				...init,
+				headers: {
+					...init.headers,
+					Authorization: `Bearer ${userToken}`
+				},
 				signal: spaceListSignal()
 			});
 		};
+		const response = await send(false);
+		return response?.status === 401 ? send(true) : response;
+	}
+	/** Owned or joined Spaces only; a public Space the viewer can merely view is not theirs to grant. */
+	async function lookupViewerSpace(spaceId) {
+		const response = await viewerFetch(`/api/spaces/${encodeURIComponent(spaceId)}`);
+		if (response?.status === 403 || response?.status === 404) return null;
+		if (!response?.ok) throw new Error("Space lookup failed.");
+		const space = await response.json();
+		return space?.relation === "owner" || space?.relation === "member" ? toSpaceOption(space) : null;
+	}
+	/** The first page seeds the picker; named Spaces are looked up one by one. */
+	async function listViewerSpaces(requested, hints) {
 		try {
-			let response = await request();
-			if (response?.status === 401) response = await request(true);
-			if (!response?.ok) return null;
-			const spaces = await response.json();
-			if (!Array.isArray(spaces)) return null;
-			return spaces.flatMap((space) => {
+			const response = await viewerFetch(`/api/spaces?limit=${SPACE_LIST_PAGE_SIZE}`);
+			if (!response) {
+				await startSignIn();
+				throw new AppLoginRedirect();
+			}
+			if (!response.ok) return null;
+			const body = await response.json();
+			if (!Array.isArray(body?.items)) return null;
+			const spaces = body.items.flatMap((space) => {
 				const option = toSpaceOption(space);
 				return option ? [option] : [];
 			});
+			const missing = [.../* @__PURE__ */ new Set([requested, ...hints])].filter((id) => Boolean(id) && !spaces.some((space) => space.id === id));
+			const found = await Promise.all(missing.map((id) => id === requested ? lookupViewerSpace(id) : lookupViewerSpace(id).catch(() => null)));
+			return [...spaces, ...found.filter((space) => space !== null)];
 		} catch (error) {
 			if (error instanceof AppLoginRedirect) throw error;
 			return null;
 		}
 	}
-	/**
-	* Ensures the viewer has a Space to target when their accessible list is
-	* empty. `GET /api/spaces/default` returns their home Space, creating it on
-	* first use — the same path taken when they first enter Cohub.
-	*/
-	async function ensureDefaultSpace() {
-		const request = async (forceRefresh = false) => {
-			const userToken = await getAccessToken({ forceRefresh });
-			if (!userToken) return null;
-			return fetch(`${apiOrigin}/api/spaces/default`, {
-				headers: { Authorization: `Bearer ${userToken}` },
-				signal: spaceListSignal()
-			});
-		};
+	/** The viewer's own Home, created on first use when they have no Space. */
+	async function ensureHomeSpace() {
 		try {
-			let response = await request();
-			if (response?.status === 401) response = await request(true);
+			const response = await viewerFetch("/api/me/spaces/home", {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					[COHUB_SOURCE_HEADER.via]: "app"
+				},
+				body: JSON.stringify({ appId: app.id })
+			});
 			if (!response?.ok) return null;
-			const payload = await response.json();
-			return payload?.space ? toSpaceOption(payload.space) : null;
+			const space = await response.json();
+			return space ? toSpaceOption(space) : null;
 		} catch {
 			return null;
 		}
@@ -5917,6 +7003,11 @@ function createAppBridgeCore(config) {
 			localStorage.setItem(pickedSpaceStorageKey, spaceId);
 		} catch {}
 	}
+	function contextSpaceIds() {
+		const invocation = activeInvocation !== void 0 ? activeInvocation : config.getInvocation?.() ?? config.invocation;
+		const shell = config.getShell?.() ?? config.shell;
+		return [invocation?.spaceId ?? void 0, shell?.space?.id ?? void 0];
+	}
 	/**
 	* Resolves the default target for a Space-bound request to a Space the
 	* viewer controls — preferring wherever the app was invoked, then the last
@@ -5924,19 +7015,14 @@ function createAppBridgeCore(config) {
 	*/
 	function resolveDefaultSpaceId(candidates) {
 		if (!candidates?.length) return void 0;
-		const accessible = (id) => id && candidates.some((space) => space.id === id) ? id : void 0;
-		const invocation = activeInvocation !== void 0 ? activeInvocation : config.getInvocation?.() ?? config.invocation;
-		const shell = config.getShell?.() ?? config.shell;
-		return accessible(invocation?.spaceId) ?? accessible(shell?.space?.id) ?? accessible(readLastPickedSpace()) ?? candidates[0]?.id;
+		return [...contextSpaceIds(), readLastPickedSpace()].find((id) => id && candidates.some((space) => space.id === id)) ?? candidates[0]?.id;
 	}
 	/**
 	* The Space the app is currently in, from trusted host context only (no
 	* network). Used to attempt silent renewal before loading the Space list.
 	*/
 	function resolveContextSpaceId() {
-		const invocation = activeInvocation !== void 0 ? activeInvocation : config.getInvocation?.() ?? config.invocation;
-		const shell = config.getShell?.() ?? config.shell;
-		return invocation?.spaceId ?? shell?.space?.id ?? void 0;
+		return contextSpaceIds().find(Boolean);
 	}
 	/**
 	* Creates the Space with the viewer's own token — the same `POST /api/spaces`
@@ -6288,10 +7374,10 @@ function createAppBridgeCore(config) {
 				const preListTargets = !spaceLevel ? listGrantedAppSpacesForScopes(viewerUuid, app.id, scopes, app.spaceId) : spaceId === void 0 && !selectSpace && contextSpaceId && hasGrantedAppScopes(viewerUuid, app.id, scopes, contextSpaceId) ? [contextSpaceId] : [];
 				if (!alwaysAsk && await attemptSilentRenewal(reserved, viewerUuid, scopes, preListTargets)) return;
 				if (state.pendingAuth !== reserved) return;
-				let spaces = spaceLevel ? await listViewerSpaces() : void 0;
+				let spaces = spaceLevel ? await listViewerSpaces(spaceId, [...contextSpaceIds(), lastPicked]) : void 0;
 				if (state.pendingAuth !== reserved) return;
 				if (spaces && spaces.length === 0) {
-					const fallback = await ensureDefaultSpace();
+					const fallback = await ensureHomeSpace();
 					if (state.pendingAuth !== reserved) return;
 					if (fallback) spaces = [fallback];
 				}
@@ -6402,9 +7488,14 @@ function createAppBridgeCore(config) {
 	* Only a Space the host actually loaded may become the target, so a UI bug
 	* cannot mint a grant against an arbitrary id.
 	*/
-	function setSelectedSpace(spaceId) {
-		if (!state.pendingAuth || state.authSaving || !state.canChangeSpace) return;
-		if (!state.pendingAuth.spaces?.some((space) => space.id === spaceId)) return;
+	function setSelectedSpace(space) {
+		const pending = state.pendingAuth;
+		if (!pending || state.authSaving || !state.canChangeSpace || !pending.spaces) return;
+		const spaceId = typeof space === "string" ? space : space.id;
+		if (!pending.spaces.some((candidate) => candidate.id === spaceId)) {
+			if (typeof space === "string") return;
+			pending.spaces = [...pending.spaces, space];
+		}
 		if (state.selectedSpaceId === spaceId) return;
 		state.selectedSpaceId = spaceId;
 		notify();
@@ -6655,9 +7746,12 @@ const DEFAULT_MEDIA_TYPES = {
 	audio: "audio/mpeg"
 };
 function outputType(value) {
-	return value === "image" || value === "video" || value === "audio" || value === "text" ? value : null;
+	return value === "image" || value === "video" || value === "audio" ? value : null;
 }
-/** Covers fold into the media they depict instead of listing as images. */
+/**
+* Only media blocks become outputs; text such as a revised prompt or a refusal
+* stays in the raw result. Covers fold into the media they depict.
+*/
 function projectOutputs(run) {
 	const blocks = generationOutput(run);
 	const covers = generationCovers(blocks);
@@ -6670,20 +7764,17 @@ function projectOutputs(run) {
 		const type = outputType(block.type);
 		if (!type || coverIndexes.has(index)) return [];
 		const size = blockNaturalSize(block);
-		const text = type === "text" ? blockText(block) ?? null : null;
-		if (type === "text" && !text) return [];
 		return [{
 			index,
 			type,
-			url: type === "text" ? null : blockUrl(block) ?? null,
+			url: blockUrl(block) ?? null,
 			previewUrl: blockPreviewUrl(block) ?? coverUrl(index) ?? null,
 			title: blockTitle(block) ?? null,
 			mimeType: blockMimeType(block) ?? null,
-			text,
 			width: size.naturalWidth ?? null,
 			height: size.naturalHeight ?? null,
 			durationMs: blockDurationMs(block) ?? null,
-			deferred: type !== "text" && isDeferred(block)
+			deferred: isDeferred(block)
 		}];
 	});
 }
@@ -6723,249 +7814,4 @@ function generationOutputSource(result, outputIndex) {
 	return `data:${declared && MEDIA_TYPE_PATTERN.test(declared) ? declared : DEFAULT_MEDIA_TYPES[String(block.type)] ?? "application/octet-stream"};base64,${data}`;
 }
 //#endregion
-//#region src/board/animation.ts
-function track(input) {
-	return BoardTrackSchema.parse(input);
-}
-function proceduralClip(input) {
-	return BoardProceduralClipSchema.parse({
-		...input,
-		kindVersion: input.kindVersion ?? 1
-	});
-}
-function composition(input) {
-	return BoardCompositionSchema.parse(input);
-}
-function compileComposition(input) {
-	return composition({
-		id: input.id,
-		name: input.name,
-		timeline: {
-			duration: input.duration,
-			tracks: (input.tracks ?? []).map(track),
-			clips: (input.clips ?? []).map(proceduralClip),
-			markers: input.markers ?? []
-		},
-		playback: input.playback ?? {
-			loop: false,
-			endBehavior: "hold",
-			reducedMotion: { mode: "base" }
-		},
-		metadata: input.metadata ?? {},
-		revision: 0
-	});
-}
-const clamp01 = (value) => Math.max(0, Math.min(1, value));
-function sampleEasing(easing, value) {
-	const t = clamp01(value);
-	switch (easing) {
-		case "ease-in-quad": return t * t;
-		case "ease-out-quad": return 1 - (1 - t) ** 2;
-		case "ease-in-out-quad": return t < .5 ? 2 * t * t : 1 - (-2 * t + 2) ** 2 / 2;
-		case "ease-in-cubic": return t ** 3;
-		case "ease-out-cubic": return 1 - (1 - t) ** 3;
-		case "ease-in-out-cubic": return t < .5 ? 4 * t ** 3 : 1 - (-2 * t + 2) ** 3 / 2;
-		case "ease-out-quart": return 1 - (1 - t) ** 4;
-		case "ease-out-expo": return t === 1 ? 1 : 1 - 2 ** (-10 * t);
-		default: return t;
-	}
-}
-function interpolate(left, right, progress) {
-	if (typeof left === "number" && typeof right === "number") return left + (right - left) * progress;
-	if (left && right && typeof left === "object" && typeof right === "object" && !Array.isArray(left) && !Array.isArray(right)) {
-		const a = left;
-		const b = right;
-		const result = {};
-		for (const key of /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)])) result[key] = interpolate(a[key], b[key], progress);
-		return result;
-	}
-	return progress < 1 ? left : right;
-}
-/** Deterministically sample one validated Track without touching scene state. */
-function sampleTrack(trackValue, time) {
-	const frames = trackValue.keyframes;
-	const first = frames[0];
-	const last = frames.at(-1);
-	if (!first || !last) return null;
-	if (time < first.time) {
-		if (trackValue.fill !== "backwards" && trackValue.fill !== "both") return null;
-		return {
-			target: trackValue.target,
-			channel: trackValue.channel,
-			value: first.value
-		};
-	}
-	if (time > last.time) {
-		if (trackValue.fill !== "forwards" && trackValue.fill !== "both") return null;
-		return {
-			target: trackValue.target,
-			channel: trackValue.channel,
-			value: last.value
-		};
-	}
-	let low = 0;
-	let high = frames.length;
-	while (low < high) {
-		const middle = low + high >>> 1;
-		if ((frames[middle]?.time ?? Number.POSITIVE_INFINITY) <= time) low = middle + 1;
-		else high = middle;
-	}
-	const left = frames[Math.max(0, low - 1)] ?? first;
-	const right = frames[Math.min(frames.length - 1, low)] ?? last;
-	if (left === right || trackValue.interpolation === "step") return {
-		target: trackValue.target,
-		channel: trackValue.channel,
-		value: left.value
-	};
-	const span = Math.max(Number.EPSILON, right.time - left.time);
-	const progress = sampleEasing(right.easing ?? "linear", (time - left.time) / span);
-	return {
-		target: trackValue.target,
-		channel: trackValue.channel,
-		value: interpolate(left.value, right.value, progress)
-	};
-}
-function sampleCompositionTracks(value, time) {
-	const position = Math.max(0, Math.min(value.timeline.duration, time));
-	return value.timeline.tracks.flatMap((item) => {
-		const sampled = sampleTrack(item, position);
-		return sampled ? [sampled] : [];
-	});
-}
-const ZERO_COST = {
-	particles: 0,
-	vertices: 0,
-	dynamicVertices: 0,
-	drawCalls: 0,
-	filterPasses: 0,
-	renderTexturePixels: 0,
-	textureBytes: 0,
-	bufferBytes: 0,
-	simulationSteps: 0
-};
-const DEFAULT_BOARD_LIMITS = DEFAULT_BOARD_RENDER_LIMITS;
-function builtinDefinition(capability) {
-	return {
-		...capability,
-		validate() {
-			return [];
-		},
-		estimateCost(params) {
-			return estimateBuiltinBoardClipCost({
-				kind: capability.id,
-				params
-			});
-		}
-	};
-}
-var BoardExtensionRegistry = class {
-	#extensions = /* @__PURE__ */ new Map();
-	#presets = /* @__PURE__ */ new Map();
-	constructor() {
-		for (const capability of BOARD_BUILTIN_CAPABILITIES) this.register(builtinDefinition(capability));
-	}
-	register(definition) {
-		const key = `${definition.kind}:${definition.id}@${definition.version}`;
-		const target = definition.kind === "preset" ? this.#presets : this.#extensions;
-		if (target.has(key)) throw new Error(`Board extension is already registered: ${key}`);
-		target.set(key, definition);
-		return this;
-	}
-	capabilities() {
-		return [...this.#extensions.values(), ...this.#presets.values()].map((definition) => ({
-			kind: definition.kind,
-			id: definition.id,
-			version: definition.version,
-			...definition.digest ? { digest: definition.digest } : {},
-			...definition.renderers ? { renderers: definition.renderers } : {},
-			...definition.fallbackId ? { fallbackId: definition.fallbackId } : {},
-			...definition.schema ? { schema: definition.schema } : {}
-		}));
-	}
-	compilePreset(id, version, params) {
-		const preset = this.#presets.get(`preset:${id}@${version}`);
-		if (!preset) throw new Error(`Unknown Board preset: ${id}@${version}`);
-		return preset.compile(params);
-	}
-	validate(input) {
-		const parsed = BoardCompositionSchema.safeParse(input.composition);
-		if (!parsed.success) return {
-			valid: false,
-			diagnostics: parsed.error.issues.map((issue) => ({
-				severity: "error",
-				code: "INVALID_COMPOSITION",
-				message: issue.message,
-				path: issue.path.join(".")
-			})),
-			peakCost: { ...ZERO_COST }
-		};
-		const diagnostics = [];
-		const composition = parsed.data;
-		const cost = { ...ZERO_COST };
-		for (const effect of input.effects ?? []) {
-			diagnostics.push(...validateBuiltinBoardEffect(effect, `effects.${effect.id}`));
-			if (!this.#extensions.has(`effect:${effect.kind}@${effect.kindVersion}`)) diagnostics.push({
-				severity: "warning",
-				code: "UNKNOWN_EFFECT",
-				message: `No renderer is registered for ${effect.kind}@${effect.kindVersion}`,
-				path: `effects.${effect.id}`
-			});
-		}
-		const events = [];
-		for (const clip of composition.timeline.clips) {
-			const definition = this.#extensions.get(`clip:${clip.kind}@${clip.kindVersion}`);
-			if (!definition) {
-				diagnostics.push({
-					severity: "warning",
-					code: "UNKNOWN_CLIP",
-					message: `No renderer is registered for ${clip.kind}@${clip.kindVersion}`
-				});
-				continue;
-			}
-			diagnostics.push(...validateBuiltinBoardClip(clip, `composition.timeline.clips.${clip.id}`));
-			diagnostics.push(...definition.validate?.(clip.params) ?? []);
-			const estimate = definition.estimateCost(clip.params, input.profile ?? "high");
-			const clipCost = { ...ZERO_COST };
-			for (const key of Object.keys(clipCost)) clipCost[key] = estimate[key] ?? 0;
-			events.push({
-				at: clip.start,
-				direction: 1,
-				cost: clipCost
-			});
-			events.push({
-				at: clip.start + clip.duration,
-				direction: -1,
-				cost: clipCost
-			});
-		}
-		events.sort((left, right) => left.at - right.at || left.direction - right.direction);
-		const active = { ...ZERO_COST };
-		for (const event of events) for (const key of Object.keys(active)) {
-			active[key] += event.cost[key] * event.direction;
-			cost[key] = Math.max(cost[key], active[key]);
-		}
-		for (const effect of input.effects ?? []) {
-			const estimate = estimateBuiltinBoardEffectCost(effect);
-			for (const key of Object.keys(cost)) cost[key] += estimate[key] ?? 0;
-		}
-		const limits = input.limits ?? DEFAULT_BOARD_LIMITS;
-		for (const key of Object.keys(cost)) if (cost[key] > limits[key]) diagnostics.push({
-			severity: "warning",
-			code: "RENDER_BUDGET_EXCEEDED",
-			message: `${key} peaks at ${cost[key]}, above ${limits[key]}`,
-			path: key,
-			adaptation: { quality: "lower" }
-		});
-		return {
-			valid: !diagnostics.some((item) => item.severity === "error"),
-			diagnostics,
-			peakCost: cost
-		};
-	}
-};
-function createBoardExtensionRegistry() {
-	return new BoardExtensionRegistry();
-}
-const BOARD_CHANNELS = BOARD_ANIMATION_CHANNELS;
-//#endregion
-export { APP_APPEARANCE_TOKENS, APP_COMPOSER_CHIP_CONTENT_MAX_BYTES, APP_COMPOSER_CHIP_KEY_MAX_LENGTH, APP_COMPOSER_CHIP_LABEL_MAX_LENGTH, APP_SURFACE_READY_TIMEOUT_MS, APP_SURFACE_REQUEST_TIMEOUT_MS, AppCommerceApi, AppRealtimeApi, AppRefParseError, AppRoom, AppRuntimeApi, AppRuntimeApi as WorkRuntimeApi, AppRuntimeError, AppSurfaceApi, AppWindowApi, AppsApi, BILLING_ACCESS_BLOCKED_ERROR_CODE, BOARD_ANIMATION_CHANNEL_CAPABILITIES, BOARD_CHANNELS, BOARD_COLOR_IDS, BOARD_GEO_KINDS, BillingApi, BoardAnimationSpecSchema, BoardAuthoringItemSchema, BoardClient, BoardCompositionInputSchema, BoardCompositionSchema, BoardDealParamsSchema, BoardEffectInputSchema, BoardEffectSchema, BoardExtensionRegistry, BoardItemPatchSchema, BoardPlaybackPolicySchema, BoardSemanticCommandSchema, COHUB_ENVIRONMENTS, COHUB_SOURCE_HEADER, COHUB_SOURCE_HEADER_NAMES, CohubClient, CohubHttpClient, DEFAULT_BOARD_LIMITS, DESKTOP_COMMAND_DEFAULT_TIMEOUT_MS, DESKTOP_COMMAND_MAX_TIMEOUT_MS, DESKTOP_COMMAND_PAYLOAD_MAX_BYTES, DESKTOP_COMMAND_PENDING_TTL_SECONDS, DESKTOP_COMMAND_SETTLEMENT_GRACE_SECONDS, DESKTOP_COMMAND_TERMINAL_TTL_SECONDS, DESKTOP_COMMAND_VERSION, DesktopCommandsApi, FEATURE_NOT_ENTITLED_ERROR_CODE, GenerationPolicyError, HttpError, NATIVE_INGEST_MAX_TURNS, NATIVE_SYNC_SOURCE, OriginBrokerTransport, PERMISSIONS, ParentBridgeTransport, PopupBrokerTransport, REQUEST_SOURCE_VIA_MAX_LENGTH, RUNTIME_ARCHIVE_SEGMENT_BYTES, RUNTIME_MAX_FRAME_BYTES, RUNTIME_PROTOCOL_VERSION, RUNTIME_RECOVERY_BATCH_SIZE, ReferencesApi, ReferralsApi, SETTLED_TURN_STATUSES, SessionGenerationStreamClient, SessionPatchReducer, SpacePublicFilesApi, SpaceWebhooksApi, USER_LEVEL_PERMISSIONS, UiCommandsApi, UsersApi, VoiceApi, VoiceInputClient, WebsocketClient, WorkCommerceApi, WorkRealtimeApi, WorkRefParseError, WorkRoom, WorkSurfaceApi, appAppearanceVar, applyAppAppearance, assertGenerationRequestAllowedByPolicy, attachAppEmbed, buildAppSurfaceRequest, buildSpaceInvitePath, buildSpacePath, clearGrantedAppScopes, compileComposition, composition, contextToPiMessages, createAppBridgeCore, createAppBridgeCore as createWorkBridgeCore, createAppRuntime, createAppRuntime as createWorkRuntime, createBoardExtensionRegistry, createCohubClient, createHttpClient, createOriginAppResolver, createSessionGenerationStreamClient, createSessionPatchReducer, createSlugAppIdResolver, createSlugAppIdResolver as createSlugWorkIdResolver, createVoiceInputClient, createWebsocketClient, decodeGenerationPolicy, encodeGenerationPolicy, extractBillingPayload, filterDiscoverableGenerationModels, filterGenerationDeclarationsByPolicy, filterSpacePickerItems, findGenerationModelPolicy, fingerprintProjectionTurns, formatAppRef, formatWorkRef, generationOutputSource, getAllowedGenerationModelIds, getCohubContext, harnessArchiveIndexSchema, hasGrantedAppScopes, hasRequestSourceIdentity, isActiveGenerationTask, isAppId, isBillingAccessBlockedCode, isBillingAccessBlockedError, isDesktopCallMethod, isFeatureNotEntitledError, isGenerationModelHidden, isHttpErrorCode, isLocalHarness, isNativeClientTurn, isProjectionCompaction, isRequestSourceClientId, isRequestSourceEmpty, isRequestSourceUuid, isTerminalDesktopCommandStatus, isUserLevelPermission, isUuid, isWorkId, joinApiUrl, matchesUnauthorizedErrorToken, mergeRequestSourceIntoMeta, nativeIngestTurnSchema, nativeRuntimeEventSchema, nativeTurnCompleteSchema, nativeTurnProgressSchema, normalizeBaseUrl, normalizeGenerationPolicy, normalizeRequestSource, normalizeSpacePickerQuery, normalizeVoiceInputWebsocketUrl, normalizeWebsocketUrl, orderSpacePickerItems, parseAppRef, parseAppSurfaceReady, parseAppSurfaceResponse, parseAssistantMessageCommit, parseBoardCompositionInput, parseBoardEffectInput, parseBoardPlaybackPolicy, parseDesktopCommand, parseGenerationPolicyFromEnv, parseRequestSourceFromHeaders, parseWorkRef, proceduralClip, projectNativeMessageMeta, projectNativeSession, readRequestSourceFromEnv, requestSourceToHeaders, resolveApiBaseUrl, resolveAppTransport, resolveAppTransport as resolveWorkTransport, resolveCohubEnvironment, resolveExecutionAppId, resolveExecutionToken, resolveHarness, resolveOpenSurface, resolveRequestSourceChannel, resolveVoiceInputWebsocketUrl, resolveWebBaseUrl, resolveWebsocketUrl, runtimeCommandSchema, runtimeEventSchema, runtimeNativeStopSchema, runtimeReadySchema, sampleCompositionTracks, sampleEasing, sampleTrack, sanitizeAccessToken, scopeListHasPermission, selectRuntimeContextMessages, selectSpacePickerItems, serializeProjection, serializeProjectionRecords, setGrantedAppScopes, toGenerationTaskView, track, trimProjectionTurnsToCompaction, validateArchiveBoundary };
+export { APP_APPEARANCE_TOKENS, APP_COMPOSER_CHIP_CONTENT_MAX_BYTES, APP_COMPOSER_CHIP_KEY_MAX_LENGTH, APP_COMPOSER_CHIP_LABEL_MAX_LENGTH, APP_SURFACE_READY_TIMEOUT_MS, APP_SURFACE_REQUEST_TIMEOUT_MS, AppCommerceApi, AppRealtimeApi, AppRefParseError, AppRoom, AppRuntimeApi, AppRuntimeApi as WorkRuntimeApi, AppRuntimeError, AppSurfaceApi, AppWindowApi, AppsApi, BILLING_ACCESS_BLOCKED_ERROR_CODE, BOARD_COLOR_TOKENS, BOARD_ITEM_TYPES, BillingApi, BoardAnimationSchema, BoardClient, BoardPatchSchema, BoardTrackSchema, COHUB_ENVIRONMENTS, COHUB_SOURCE_HEADER, COHUB_SOURCE_HEADER_NAMES, CohubClient, CohubHttpClient, DESKTOP_COMMAND_ACCEPT_TIMEOUT_MS, DESKTOP_COMMAND_DEFAULT_TIMEOUT_MS, DESKTOP_COMMAND_MAX_TIMEOUT_MS, DESKTOP_COMMAND_OPEN_TIMEOUT_MS, DESKTOP_COMMAND_PAYLOAD_MAX_BYTES, DESKTOP_COMMAND_PENDING_TTL_SECONDS, DESKTOP_COMMAND_SETTLEMENT_GRACE_SECONDS, DESKTOP_COMMAND_TERMINAL_TTL_SECONDS, DESKTOP_COMMAND_VERSION, DISPLAY_ACTION_TYPES, DISPLAY_ELEMENT_REF_PATTERN, DISPLAY_SYSTEM_ACTIONS, DesktopCommandsApi, DisplayActionError, DisplayConnection, FEATURE_NOT_ENTITLED_ERROR_CODE, GenerationPolicyError, HOME_SPACE_SLUG, HttpError, NATIVE_INGEST_MAX_TURNS, NATIVE_SYNC_SOURCE, OriginBrokerTransport, PERMISSIONS, ParentBridgeTransport, PopupBrokerTransport, REQUEST_SOURCE_VIA_MAX_LENGTH, RUNTIME_ARCHIVE_SEGMENT_BYTES, RUNTIME_MAX_FRAME_BYTES, RUNTIME_PROTOCOL_VERSION, RUNTIME_RECOVERY_BATCH_SIZE, ReferencesApi, ReferralsApi, SETTLED_TURN_STATUSES, SessionGenerationStreamClient, SessionPatchReducer, SpaceDisplaysApi, SpacePublicFilesApi, SpaceWebhooksApi, UPLOAD_MAX_BATCH_BYTES, UPLOAD_MAX_BATCH_FILES, UPLOAD_MAX_FILE_BYTES, USER_LEVEL_PERMISSIONS, UiCommandsApi, UsersApi, VoiceApi, VoiceInputClient, WebsocketClient, WorkCommerceApi, WorkRealtimeApi, WorkRefParseError, WorkRoom, WorkSurfaceApi, appAppearanceVar, applyAppAppearance, assertGenerationRequestAllowedByPolicy, attachAppEmbed, buildAppSurfaceRequest, buildSpaceInvitePath, buildSpacePath, clearGrantedAppScopes, compileDisplayActions, connectDisplay, contextToPiMessages, createAppBridgeCore, createAppBridgeCore as createWorkBridgeCore, createAppRuntime, createAppRuntime as createWorkRuntime, createCohubClient, createHttpClient, createOriginAppResolver, createSessionGenerationStreamClient, createSessionPatchReducer, createSlugAppIdResolver, createSlugAppIdResolver as createSlugWorkIdResolver, createVoiceInputClient, createWebsocketClient, decodeGenerationPolicy, defaultDesktopCommandTimeoutMs, encodeGenerationPolicy, extractBillingPayload, filterDiscoverableGenerationModels, filterGenerationDeclarationsByPolicy, filterSpacePickerItems, findGenerationModelPolicy, fingerprintProjectionTurns, formatAppRef, formatWorkRef, generationOutputSource, getAllowedGenerationModelIds, getCohubContext, harnessArchiveIndexSchema, hasGrantedAppScopes, hasRequestSourceIdentity, isActiveGenerationTask, isAppId, isBillingAccessBlockedCode, isBillingAccessBlockedError, isDesktopCallMethod, isFeatureNotEntitledError, isGenerationModelHidden, isHttpErrorCode, isLocalHarness, isNativeClientTurn, isProjectionCompaction, isRequestSourceClientId, isRequestSourceEmpty, isRequestSourceUuid, isTerminalDesktopCommandStatus, isUserLevelPermission, isUuid, isWorkId, joinApiUrl, matchesUnauthorizedErrorToken, mergeRequestSourceIntoMeta, nativeIngestTurnSchema, nativeRuntimeEventSchema, nativeTurnCompleteSchema, nativeTurnProgressSchema, normalizeBaseUrl, normalizeDisplayPoint, normalizeGenerationPolicy, normalizeRequestSource, normalizeSessionTurnOrigin, normalizeSpacePickerQuery, normalizeVoiceInputWebsocketUrl, normalizeWebsocketUrl, orderSpacePickerItems, parseAppRef, parseAppSurfaceReady, parseAppSurfaceResponse, parseAssistantMessageCommit, parseBoardDocument, parseBoardItem, parseDesktopCommand, parseGenerationPolicyFromEnv, parseRequestSourceFromHeaders, parseSpaceRef, parseWorkRef, projectNativeMessageMeta, projectNativeSession, readRequestSourceFromEnv, readSentTurns, readSessionTurnOrigin, requestSourceToHeaders, resolveApiBaseUrl, resolveAppTransport, resolveAppTransport as resolveWorkTransport, resolveCohubEnvironment, resolveExecutionAppId, resolveExecutionToken, resolveHarness, resolveOpenSurface, resolveRequestSourceChannel, resolveVoiceInputWebsocketUrl, resolveWebBaseUrl, resolveWebsocketUrl, runtimeCommandSchema, runtimeEventSchema, runtimeNativeStopSchema, runtimeReadySchema, sanitizeAccessToken, scopeListHasPermission, selectRuntimeContextMessages, selectSpacePickerItems, serializeProjection, serializeProjectionRecords, setGrantedAppScopes, toGenerationTaskView, trimProjectionTurnsToCompaction, validateArchiveBoundary };