@neta-art/cohub 12.5.0 → 13.0.0

package/dist/chunks/http.js

@@ -1,8 +1,6 @@
 import { S as getRealtimeSpaceRoom, c as HttpError, l as HttpTransport, s as isHttpErrorCode, x as getRealtimeBoardRoom, z as isUuid } from "./http-error.js";
-import { l as resolveExecutionToken, o as resolveApiBaseUrl } from "./environment.js";
+import { s as resolveApiBaseUrl, u as resolveExecutionToken } from "./environment.js";
 import { z } from "zod";
-//#region ../protocol/dist/board-constants.js
-const BOARD_ARROW_STROKE_SIZE = 2.5;
 const BOARD_DEFAULT_ITEM_SIZE = {
 	width: 240,
 	height: 160
@@ -628,27 +626,28 @@ const BOARD_ENTER_PRESETS = [
 	"deal"
 ];
 const BoardBackgroundSchema = z.object({
-	kind: z.enum([
-		"solid",
-		"dots",
-		"grid",
-		"image"
-	]).default("dots"),
 	color: BoardColorSchema.optional(),
-	imageUrl: z.string().url().max(4096).optional().describe("Background image for kind image."),
-	fit: z.enum([
-		"cover",
-		"contain",
-		"repeat"
-	]).optional(),
-	opacity: ratio.optional()
-}).strict();
+	pattern: z.enum([
+		"none",
+		"dots",
+		"grid"
+	]).optional().describe("Spaced by grid.size; omit to follow the theme."),
+	image: z.object({
+		src: BoardMediaSourceSchema,
+		fit: z.enum([
+			"cover",
+			"contain",
+			"repeat"
+		]).default("cover").describe("cover and contain fill the view; repeat tiles the Board at one board unit per image pixel."),
+		opacity: ratio.optional()
+	}).strict().optional()
+}).strict().describe("Layers drawn under every item: color, then image, then pattern. Without a color or image the theme's backdrop shows.");
 const BoardSettingsSchema = z.object({
 	title: z.string().min(1).max(255).optional(),
-	background: BoardBackgroundSchema.default({ kind: "dots" }),
+	background: BoardBackgroundSchema.default({}),
 	grid: z.object({
-		visible: z.boolean().default(false).describe("Show the grid overlay."),
-		size: finite.min(4).max(512).default(24)
+		size: finite.min(4).max(512).default(24).describe("Pattern spacing and snap step, in board units."),
+		snap: z.boolean().default(false).describe("Snap moved and resized items to the grid.")
 	}).strict().optional(),
 	enter: z.object({
 		preset: z.enum(BOARD_ENTER_PRESETS),
@@ -706,10 +705,14 @@ z.object({
 	items: z.array(z.string().min(1)).max(5e4).optional(),
 	animations: z.array(z.string().min(1)).max(1e4).optional(),
 	limit: z.number().int().min(1).max(5e4).optional(),
-	cursor: z.string().min(1).optional()
+	cursor: z.string().min(1).optional(),
+	since: z.number().int().nonnegative().optional()
 }).strict().refine((read) => !(read.cursor && (read.rect || read.within)), {
 	path: ["cursor"],
 	message: "cursor pages by id, so it cannot be combined with rect or within"
+}).refine((read) => read.since === void 0 || Object.entries(read).every(([key, value]) => key === "since" || value === void 0), {
+	path: ["since"],
+	message: "since syncs the whole Board, so it cannot be combined with other read options"
 });
 z.object({
 	patch: BoardPatchSchema,
@@ -763,6 +766,1082 @@ z.discriminatedUnion("type", [
 	}).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 estimateLines(text, { fontSize }, maxWidth) {
+	const measure = (line) => estimateTextWidth(line, fontSize);
+	const paragraphs = text.split("\n");
+	const lines = maxWidth ? paragraphs.flatMap((paragraph) => wrapParagraph(paragraph, maxWidth, measure)) : paragraphs;
+	return {
+		lines,
+		width: lines.reduce((max, line) => Math.max(max, measure(line)), 0)
+	};
+}
+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 font = {
+		fontSize,
+		fontWeight: props.fontWeight ?? 500,
+		font: props.font ?? "sans"
+	};
+	const { lines, width } = estimateLines(props.text || "", font, props.width || void 0);
+	const lineHeight = fontSize * (props.lineHeight ?? 4 / 3);
+	const layout = {
+		width: Math.max(props.width ?? 0, width, 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,
+			...boardDefaultSize(item.type)
+		};
+		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$2(entry) && Object.keys(entry).length === 0) delete value[key];
+	return value;
+}
+function isRecord$2(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function mergePatch(target, patch) {
+	if (!isRecord$2(patch)) return patch;
+	const result = isRecord$2(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",
+	"script"
+]);
+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()]).describe("Item id or world-space rect to fit with 48 px padding; holds until the next focus keyframe.")
+	},
+	zoom: {
+		kind: "number",
+		schema: z.number().finite().positive().describe("Pixels per world unit; overrides the zoom computed by focus."),
+		multiplicative: true
+	},
+	center: {
+		kind: "vec2",
+		schema: BoardVec2Schema.describe("World-space viewport center; overrides focus positioning using the resolved zoom.")
+	},
+	shake: {
+		kind: "number",
+		schema: z.number().finite().nonnegative().describe("Shake amplitude in screen pixels, applied after focus, zoom and center.")
+	}
+};
+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
+	};
+}
+function stripId(value) {
+	if (!("id" in value)) return value;
+	const { id: _id, ...rest } = value;
+	return rest;
+}
+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))
+	};
+	const patch = parsedPatch.data;
+	const diagnostics = [];
+	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 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 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]);
+		}
+		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
+		};
+	}
+	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$2(input)) return {
+		ok: false,
+		diagnostics: [error("", "INVALID_DOCUMENT", "expected an object")]
+	};
+	const result = applyBoardPatchToDocument({
+		board: BoardSettingsSchema.parse({}),
+		items: {},
+		animations: {}
+	}, {
+		...isRecord$2(input.board) ? { board: input.board } : {},
+		...isRecord$2(input.items) ? { items: input.items } : {},
+		...isRecord$2(input.animations) ? { animations: input.animations } : {}
+	});
+	return result.ok ? {
+		ok: true,
+		document: result.document
+	} : result;
+}
+//#endregion
 //#region ../protocol/dist/model/metrics.js
 const count = z.number().finite().nonnegative();
 const usageSchema = z.object({
@@ -1447,7 +2526,7 @@ var CronJobsApi = class {
 //#region src/apis/generations.ts
 const DEFAULT_INTERVAL_MS = 1500;
 const DEFAULT_TIMEOUT_MS = 18e5;
-function sleep$1(ms, signal) {
+function sleep$2(ms, signal) {
 	if (signal?.aborted) return Promise.reject(signal.reason ?? /* @__PURE__ */ new Error("Generation wait aborted"));
 	return new Promise((resolve, reject) => {
 		const cleanup = () => signal?.removeEventListener("abort", onAbort);
@@ -1512,7 +2591,7 @@ var GenerationsApi = class {
 			}
 			const remainingMs = timeoutMs - (Date.now() - startedAt);
 			if (remainingMs <= 0) throw new Error(`Generation task timed out after ${timeoutMs}ms`);
-			await sleep$1(Math.min(intervalMs, remainingMs), options.signal);
+			await sleep$2(Math.min(intervalMs, remainingMs), options.signal);
 		}
 	}
 	async createAndWait(request, options) {
@@ -1881,6 +2960,67 @@ function createBoardEntityId() {
 	return `c-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
 }
 //#endregion
+//#region src/board/model/json.ts
+function sameJson(a, b) {
+	if (a === b) return true;
+	if (!a || !b || typeof a !== "object" || typeof b !== "object") return false;
+	if (Array.isArray(a) || Array.isArray(b)) {
+		if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+		for (let index = 0; index < a.length; index += 1) if (!sameJson(a[index], b[index])) return false;
+		return true;
+	}
+	const left = a;
+	const right = b;
+	let members = 0;
+	for (const key of Object.keys(left)) {
+		if (left[key] === void 0) continue;
+		members += 1;
+		if (!sameJson(left[key], right[key])) return false;
+	}
+	for (const key of Object.keys(right)) if (right[key] !== void 0) members -= 1;
+	return members === 0;
+}
+//#endregion
+//#region src/board/model/document-share.ts
+function shareRecord(previous, next) {
+	let same = Object.keys(previous).length === Object.keys(next).length;
+	const shared = {};
+	for (const [id, value] of Object.entries(next)) {
+		const current = previous[id];
+		const kept = current !== void 0 && sameJson(current, value) ? current : value;
+		if (kept !== current) same = false;
+		shared[id] = kept;
+	}
+	return same ? previous : shared;
+}
+function shareBoardDocument(previous, next) {
+	if (!previous) return next;
+	const board = sameJson(previous.board, next.board) ? previous.board : next.board;
+	const items = shareRecord(previous.items, next.items);
+	const animations = shareRecord(previous.animations, next.animations);
+	if (board === previous.board && items === previous.items && animations === previous.animations) return previous;
+	return {
+		board,
+		items,
+		animations
+	};
+}
+//#endregion
+//#region src/board/model/read.ts
+function readBoardDocument(result, base = null) {
+	if (result.changes) {
+		if (!base) throw new Error(`Board ${result.id} returned changes without a document to apply them to.`);
+		return result.changes.reduce(applyBoardDelta, base);
+	}
+	const parsed = parseBoardDocument({
+		board: result.board,
+		items: result.items ?? {},
+		animations: result.animations ?? {}
+	});
+	if (!parsed.ok) throw new Error(`Board ${result.id} could not be read.`);
+	return shareBoardDocument(base, parsed.document);
+}
+//#endregion
 //#region src/board/client/index.ts
 var BoardRealtimeClient = class {
 	websocketClient;
@@ -1895,7 +3035,7 @@ var BoardRealtimeClient = class {
 		if (!this.websocketClient) throw new Error("realtime transport is not configured for this client");
 		ensureRealtimeConnected(this.websocketClient);
 		const room = getRealtimeBoardRoom(this.boardId);
-		const releaseRoom = this.websocketClient.retainRooms([getRealtimeSpaceRoom(this.spaceId), room]);
+		const releaseRoom = this.websocketClient.retainRooms([room]);
 		const unsubscribe = this.websocketClient.on("event", (event) => {
 			if (event.spaceId !== this.spaceId) return;
 			if (event.type === "board.changed" && event.payload.boardId === this.boardId) {
@@ -1917,12 +3057,14 @@ var BoardRealtimeClient = class {
 			}
 		});
 		const resync = handlers.resync;
-		const stopResync = resync ? this.websocketClient.on("subscribed", ({ rooms }) => {
+		const stopResync = resync ? [this.websocketClient.on("subscribed", ({ rooms }) => {
 			if (rooms.includes(room)) resync();
-		}) : null;
+		}), this.websocketClient.on("subscribeError", ({ rejected }) => {
+			if (rejected.some((entry) => entry.room === room && entry.code !== "UNAVAILABLE")) resync();
+		})] : [];
 		return () => {
 			unsubscribe();
-			stopResync?.();
+			for (const stop of stopResync) stop();
 			releaseRoom();
 		};
 	}
@@ -1951,7 +3093,7 @@ var BoardClient = class {
 	/** Read the Board, or part of it. Every value is complete, defaults included. */
 	get(input = {}, customFetch) {
 		const params = new URLSearchParams();
-		if (input.only?.length) params.set("only", input.only.join(","));
+		if (input.only) params.set("only", input.only.join(","));
 		if (input.rect) params.set("rect", [
 			input.rect.x,
 			input.rect.y,
@@ -1963,9 +3105,25 @@ var BoardClient = class {
 		if (input.animations?.length) params.set("animations", input.animations.join(","));
 		if (input.limit !== void 0) params.set("limit", String(input.limit));
 		if (input.cursor) params.set("cursor", input.cursor);
+		if (input.since !== void 0) params.set("since", String(input.since));
 		const query = params.toString();
 		return this.http.request(`${this.path}${query ? `?${query}` : ""}`, { fetch: customFetch });
 	}
+	/** Bring a cached document up to date in one request that carries only what changed since its version. */
+	async sync(cached, customFetch) {
+		const result = await this.get(cached ? { since: cached.version } : {}, customFetch);
+		const document = readBoardDocument(result, cached?.document);
+		const { id, title, version, updatedAt, playback } = result;
+		return {
+			id,
+			title,
+			version,
+			updatedAt,
+			playback,
+			document,
+			changed: document !== cached?.document || version !== cached.version
+		};
+	}
 	/** Merge a patch into the Board: fields merge, `null` deletes. */
 	apply(patch, options = {}) {
 		return this.http.request(`${this.path}/apply`, {
@@ -2088,6 +3246,12 @@ var SpaceBoardsApi = class {
 			boardId
 		});
 	}
+	assetSource() {
+		return {
+			resolveFile: (path, options) => this.files.resolve(path, options),
+			subscribe: (listener) => this.files.onUrlChange(listener)
+		};
+	}
 	async open(target, customFetch) {
 		return this.byId(isBoardPath(target) ? await this.resolveId(target, customFetch) : target);
 	}
@@ -3000,7 +4164,7 @@ function getPatchMessageIdentity(event) {
 		messageOrdinal: typeof event.payload.messageOrdinal === "number" ? event.payload.messageOrdinal : null
 	};
 }
-async function withTimeout(promise, timeoutMs) {
+async function withTimeout$1(promise, timeoutMs) {
 	let timeout = null;
 	try {
 		return await Promise.race([promise, new Promise((_, reject) => {
@@ -3169,7 +4333,7 @@ var SessionGenerationStreamClient = class SessionGenerationStreamClient {
 	async loadSnapshot() {
 		if (!this.fetchStreamSnapshot) return null;
 		try {
-			return (await withTimeout(this.fetchStreamSnapshot(), SNAPSHOT_RECOVERY_TIMEOUT_MS)).snapshot;
+			return (await withTimeout$1(this.fetchStreamSnapshot(), SNAPSHOT_RECOVERY_TIMEOUT_MS)).snapshot;
 		} catch (error) {
 			console.warn("[SessionGenerationStreamClient] Failed to recover stream snapshot:", error);
 			return null;
@@ -3543,6 +4707,638 @@ function buildSpaceInvitePath(input) {
 	return `${buildSpacePath(input)}/join/${inviteCode}`;
 }
 //#endregion
+//#region src/apis/space-file-reads.ts
+const BATCH_SIZE = 32;
+const BATCH_CONCURRENCY = 2;
+const SINGLE_CONCURRENCY = 4;
+const BACKGROUND_DELAY_MS = 1500;
+const READ_TIMEOUT_MS = 3e4;
+function createLimiter(limit) {
+	let active = 0;
+	const lanes = [[], []];
+	function pump() {
+		while (active < limit) {
+			const job = lanes[0].shift() ?? lanes[1].shift();
+			if (!job) return;
+			active += 1;
+			job();
+		}
+	}
+	return (run, background = false) => new Promise((resolve, reject) => {
+		lanes[background ? 1 : 0].push(() => {
+			run().then(resolve, reject).finally(() => {
+				active -= 1;
+				pump();
+			});
+		});
+		pump();
+	});
+}
+const fileReadPath = (spaceId, path) => `/api/spaces/${spaceId}/fs/file?${new URLSearchParams({ path })}`;
+function createSpaceFileReads(transport) {
+	const queues = [/* @__PURE__ */ new Map(), /* @__PURE__ */ new Map()];
+	const timers = [null, null];
+	const inFlight = /* @__PURE__ */ new Map();
+	const batches = createLimiter(BATCH_CONCURRENCY);
+	const singles = createLimiter(SINGLE_CONCURRENCY);
+	const readOne = (spaceId, path, init = {}) => withTimeout((signal) => transport.requestRevalidated(fileReadPath(spaceId, path), {
+		...init,
+		signal
+	}));
+	function schedule(lane) {
+		timers[lane] ??= setTimeout(() => {
+			timers[lane] = null;
+			flush(lane);
+		}, lane ? BACKGROUND_DELAY_MS : 0);
+	}
+	function settle(pending, outcome) {
+		if (inFlight.get(pending.key) === pending) inFlight.delete(pending.key);
+		if ("file" in outcome) pending.resolve(outcome.file);
+		else pending.reject(outcome.error);
+	}
+	function flush(lane) {
+		const groups = /* @__PURE__ */ new Map();
+		for (const pending of queues[lane].values()) {
+			inFlight.set(pending.key, pending);
+			const id = `${pending.token}\u0000${pending.spaceId}`;
+			const group = groups.get(id);
+			if (group) group.push(pending);
+			else groups.set(id, [pending]);
+		}
+		queues[lane].clear();
+		for (const group of groups.values()) {
+			if (group.length === 1) {
+				readSingle(group[0], lane === 1);
+				continue;
+			}
+			for (let index = 0; index < group.length; index += BATCH_SIZE) batches(() => readBatch(group.slice(index, index + BATCH_SIZE)), lane === 1);
+		}
+	}
+	async function readSingle(pending, background = false) {
+		const { spaceId, path, token } = pending;
+		try {
+			settle(pending, { file: await singles(() => readOne(spaceId, path, { accessToken: token }), background) });
+		} catch (error) {
+			settle(pending, { error });
+		}
+	}
+	async function readBatch(chunk) {
+		const { spaceId, token } = chunk[0];
+		let response;
+		try {
+			response = await withTimeout((signal) => transport.request(`/api/spaces/${spaceId}/fs/files`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ paths: chunk.map((pending) => pending.path) }),
+				accessToken: token,
+				signal
+			}));
+		} catch {
+			await Promise.all(chunk.map((pending) => readSingle(pending)));
+			return;
+		}
+		const byPath = new Map(chunk.map((pending) => [pending.path, pending]));
+		const take = (path) => {
+			const pending = byPath.get(path);
+			byPath.delete(path);
+			return pending;
+		};
+		for (const file of [...response.files, ...response.preparing ?? []]) {
+			const pending = take(file.path);
+			if (pending) settle(pending, { file });
+		}
+		for (const { path, status, code, message } of response.errors) {
+			const pending = take(path);
+			if (pending) settle(pending, { error: new HttpError(message, status, {
+				code,
+				message
+			}) });
+		}
+		await Promise.all([...byPath.values()].map((pending) => readSingle(pending)));
+	}
+	function share(token, spaceId, path, background) {
+		const key = `${spaceId}\u0000${path}\u0000${token}`;
+		let pending = inFlight.get(key) ?? queues[0].get(key);
+		const deferred = queues[1].get(key);
+		if (!pending && deferred && !background) {
+			queues[1].delete(key);
+			queues[0].set(key, deferred);
+			schedule(0);
+		}
+		pending ??= deferred;
+		if (!pending) {
+			let resolve;
+			let reject;
+			const promise = new Promise((done, fail) => {
+				resolve = done;
+				reject = fail;
+			});
+			const lane = background ? 1 : 0;
+			pending = {
+				key,
+				token,
+				spaceId,
+				path,
+				promise,
+				resolve,
+				reject
+			};
+			queues[lane].set(key, pending);
+			schedule(lane);
+		}
+		return pending.promise;
+	}
+	return {
+		async read(spaceId, path, options = {}) {
+			const own = options.token === void 0;
+			const token = own ? await transport.credential() : options.token ?? null;
+			try {
+				return await abortable(share(token, spaceId, path, options.background === true), options.signal);
+			} catch (error) {
+				if (!own || !isUnauthorized(error)) throw error;
+				return abortable(readOne(spaceId, path), options.signal);
+			}
+		},
+		invalidate(spaceId, paths) {
+			const stale = new Set([...paths].map((path) => `${spaceId}\u0000${path}`));
+			for (const key of inFlight.keys()) if (stale.has(key.slice(0, key.lastIndexOf("\0")))) inFlight.delete(key);
+		}
+	};
+}
+const isUnauthorized = (error) => error instanceof HttpError && error.status === 401;
+async function withTimeout(run) {
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(new DOMException("Space file read timed out", "TimeoutError")), READ_TIMEOUT_MS);
+	try {
+		return await run(controller.signal);
+	} finally {
+		clearTimeout(timer);
+	}
+}
+function abortable(promise, signal) {
+	if (!signal) return promise;
+	if (signal.aborted) return Promise.reject(signal.reason);
+	return new Promise((resolve, reject) => {
+		const abort = () => reject(signal.reason);
+		signal.addEventListener("abort", abort, { once: true });
+		promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", abort));
+	});
+}
+//#endregion
+//#region src/indexeddb.ts
+const OPEN_TIMEOUT_MS = 3e3;
+const connections = /* @__PURE__ */ new Map();
+function open(name, version, upgrade) {
+	const existing = connections.get(name);
+	if (existing) return existing;
+	const opening = new Promise((resolve, reject) => {
+		const factory = globalThis.indexedDB;
+		if (!factory) {
+			reject(/* @__PURE__ */ new Error("IndexedDB is unavailable."));
+			return;
+		}
+		let late = false;
+		const timer = setTimeout(() => {
+			late = true;
+			reject(/* @__PURE__ */ new Error("IndexedDB did not open in time."));
+		}, OPEN_TIMEOUT_MS);
+		const request = factory.open(name, version);
+		request.onupgradeneeded = () => upgrade(request.result);
+		request.onsuccess = () => {
+			clearTimeout(timer);
+			const db = request.result;
+			if (late) {
+				db.close();
+				return;
+			}
+			const forget = () => {
+				if (connections.get(name) === opening) connections.delete(name);
+			};
+			db.onversionchange = () => {
+				db.close();
+				forget();
+			};
+			db.onclose = forget;
+			resolve(db);
+		};
+		request.onerror = () => {
+			clearTimeout(timer);
+			reject(request.error ?? /* @__PURE__ */ new Error("IndexedDB failed to open."));
+		};
+	});
+	connections.set(name, opening);
+	opening.catch(() => {
+		if (connections.get(name) === opening) connections.delete(name);
+	});
+	return opening;
+}
+function indexedDb(name, version, upgrade) {
+	async function transact(stores, mode, work, retry = true) {
+		const db = await open(name, version, upgrade);
+		let tx;
+		try {
+			tx = db.transaction(stores, mode);
+		} catch (error) {
+			if (!retry) throw error;
+			db.close();
+			connections.delete(name);
+			return transact(stores, mode, work, false);
+		}
+		return new Promise((resolve, reject) => {
+			const result = work(tx);
+			tx.oncomplete = () => resolve(result());
+			tx.onerror = () => reject(tx.error ?? /* @__PURE__ */ new Error("IndexedDB transaction failed."));
+			tx.onabort = () => reject(tx.error ?? /* @__PURE__ */ new Error("IndexedDB transaction aborted."));
+		});
+	}
+	return { transact: (stores, mode, work) => transact(stores, mode, work) };
+}
+function deleteByIndex(store, index, key) {
+	const request = store.index(index).openKeyCursor(IDBKeyRange.only(key));
+	request.onsuccess = () => {
+		const cursor = request.result;
+		if (!cursor) return;
+		store.delete(cursor.primaryKey);
+		cursor.continue();
+	};
+}
+//#endregion
+//#region src/apis/space-file-url-store.ts
+const DATABASE = "cohub-file-urls";
+const STORE = "urls";
+const MAX_ENTRIES = 2e4;
+const TRIM_TO = 18e3;
+const TRIM_EVERY_WRITES = 500;
+const database = indexedDb(DATABASE, 1, (db) => {
+	const store = db.createObjectStore(STORE, { keyPath: "key" });
+	store.createIndex("scope", "scope");
+	store.createIndex("verifiedAt", "verifiedAt");
+});
+const recordKey = (scope, spaceId, path) => `${scope}\u0000${spaceId}\u0000${path}`;
+let writes = 0;
+const fileUrlStore = {
+	read(scope, spaceId, paths) {
+		return database.transact([STORE], "readonly", (tx) => {
+			const store = tx.objectStore(STORE);
+			const requests = paths.map((path) => [path, store.get(recordKey(scope, spaceId, path))]);
+			return () => {
+				const found = /* @__PURE__ */ new Map();
+				for (const [path, request] of requests) {
+					const record = request.result;
+					if (record) found.set(path, {
+						url: record.url,
+						verifiedAt: record.verifiedAt,
+						media: record.media
+					});
+				}
+				return found;
+			};
+		});
+	},
+	async write(scope, spaceId, changes) {
+		await database.transact([STORE], "readwrite", (tx) => {
+			const store = tx.objectStore(STORE);
+			for (const [path, stored] of changes.put) store.put({
+				...stored,
+				key: recordKey(scope, spaceId, path),
+				scope
+			});
+			for (const path of changes.remove) store.delete(recordKey(scope, spaceId, path));
+			return () => void 0;
+		});
+		writes += changes.put.size;
+		if (writes < TRIM_EVERY_WRITES) return;
+		writes = 0;
+		await trim();
+	}
+};
+function trim() {
+	return database.transact([STORE], "readwrite", (tx) => {
+		const store = tx.objectStore(STORE);
+		const count = store.count();
+		count.onsuccess = () => {
+			let excess = count.result > MAX_ENTRIES ? count.result - TRIM_TO : 0;
+			if (excess === 0) return;
+			const cursor = store.index("verifiedAt").openKeyCursor();
+			cursor.onsuccess = () => {
+				const current = cursor.result;
+				if (!current || excess-- <= 0) return;
+				store.delete(current.primaryKey);
+				current.continue();
+			};
+		};
+		return () => void 0;
+	});
+}
+async function clearFileUrlCache(options = {}) {
+	if (!globalThis.indexedDB) return;
+	await database.transact([STORE], "readwrite", (tx) => {
+		const store = tx.objectStore(STORE);
+		if (options.scope === void 0) store.clear();
+		else deleteByIndex(store, "scope", options.scope);
+		return () => void 0;
+	});
+}
+//#endregion
+//#region src/apis/space-file-urls.ts
+const MEMORY_LIMIT = 4096;
+const INLINE_MEMORY_MAX_CHARS = 262144;
+const PREPARING_CONCURRENCY = 4;
+const PREPARING_TIMEOUT_MS = 15e3;
+/** Well inside the fs CDN manifest's 6.5 days; CDN URLs carry the file version and are not signed. */
+const STORED_MAX_AGE_MS = 2592e5;
+const UNWATCHED_TRUST_MS = 6e4;
+function inlineFileDataUrl(file) {
+	const mimeType = file.mimeType ?? "application/octet-stream";
+	return file.encoding === "base64" ? `data:${mimeType};base64,${file.content}` : `data:${mimeType};charset=utf-8,${encodeURIComponent(file.content)}`;
+}
+function resolvedOf(file) {
+	if (file.delivery === "url" && file.url) return {
+		url: file.url,
+		inline: false,
+		...file.media ? { media: file.media } : {}
+	};
+	return {
+		url: inlineFileDataUrl(file),
+		inline: true
+	};
+}
+const isGone = (error) => error instanceof HttpError && (error.status === 404 || error.status === 410);
+const sleep$1 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function remember(map, key, value) {
+	map.delete(key);
+	map.set(key, value);
+	if (map.size > MEMORY_LIMIT) map.delete(map.keys().next().value);
+}
+function createSpaceFileUrls(options) {
+	const { reads, cache } = options;
+	const now = options.now ?? Date.now;
+	const memory = /* @__PURE__ */ new Map();
+	const invalidatedAt = /* @__PURE__ */ new Map();
+	const epochs = /* @__PURE__ */ new Map();
+	const serverReads = /* @__PURE__ */ new Map();
+	const localReads = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Set();
+	const preparing = createLimiter(PREPARING_CONCURRENCY);
+	let localBatch = null;
+	let writes = null;
+	let lastScope = null;
+	const keyOf = (spaceId, path) => `${spaceId}\u0000${path}`;
+	const epochOf = (spaceId) => epochs.get(spaceId) ?? 0;
+	const persists = (scope) => cache && scope !== null && Boolean(globalThis.indexedDB);
+	function persist(scope, spaceId, path, entry) {
+		if (!writes) {
+			const batch = /* @__PURE__ */ new Map();
+			writes = batch;
+			setTimeout(() => {
+				writes = null;
+				for (const [id, { put, remove }] of batch) {
+					const [batchScope, batchSpace] = id.split("\0");
+					fileUrlStore.write(batchScope, batchSpace, {
+						put,
+						remove
+					}).catch(() => void 0);
+				}
+			}, 0);
+		}
+		const id = `${scope}\u0000${spaceId}`;
+		const pending = writes.get(id) ?? {
+			put: /* @__PURE__ */ new Map(),
+			remove: /* @__PURE__ */ new Set()
+		};
+		writes.set(id, pending);
+		if (entry) {
+			pending.remove.delete(path);
+			pending.put.set(path, {
+				url: entry.url,
+				verifiedAt: now(),
+				...entry.media ? { media: entry.media } : {}
+			});
+		} else {
+			pending.put.delete(path);
+			pending.remove.add(path);
+		}
+	}
+	async function load(token, spaceId, path, background) {
+		const first = await reads.read(spaceId, path, {
+			background,
+			token
+		});
+		if ("content" in first) return resolvedOf(first);
+		return preparing(async () => {
+			const deadline = now() + PREPARING_TIMEOUT_MS;
+			let file = first;
+			while (!("content" in file)) {
+				const wait = Math.min(Math.max(250, Math.min(file.retryAfterMs, 2e3)), deadline - now());
+				if (wait <= 0) return null;
+				await sleep$1(wait);
+				file = await reads.read(spaceId, path, { token });
+			}
+			return resolvedOf(file);
+		}, background);
+	}
+	function server(token, scope, spaceId, path, background) {
+		const key = keyOf(spaceId, path);
+		const readKey = `${key}\u0000${token}`;
+		const running = serverReads.get(readKey);
+		if (running) {
+			if (!background) reads.read(spaceId, path, { token }).catch(() => void 0);
+			return running;
+		}
+		const epoch = epochOf(spaceId);
+		const read = load(token, spaceId, path, background).then((resolved) => {
+			const current = serverReads.get(readKey) === read;
+			if (current) serverReads.delete(readKey);
+			if (!resolved) return null;
+			const entry = {
+				...resolved,
+				scope,
+				epoch,
+				verifiedAt: now()
+			};
+			if (current && cache) adopt(key, spaceId, path, entry);
+			return entry;
+		}, (error) => {
+			const current = serverReads.get(readKey) === read;
+			if (current) serverReads.delete(readKey);
+			if (current && cache && isGone(error)) {
+				memory.delete(key);
+				if (persists(scope)) persist(scope, spaceId, path, null);
+			}
+			throw error;
+		});
+		serverReads.set(readKey, read);
+		return read;
+	}
+	function adopt(key, spaceId, path, entry) {
+		const previous = memory.get(key);
+		if (!entry.inline || entry.url.length <= INLINE_MEMORY_MAX_CHARS) remember(memory, key, entry);
+		if (!entry.inline && persists(entry.scope)) persist(entry.scope, spaceId, path, entry);
+		if (previous && previous.url !== entry.url) emit(spaceId, path);
+	}
+	function revalidate(token, scope, spaceId, path) {
+		server(token, scope, spaceId, path, true).catch(() => void 0);
+	}
+	function readLocal(token, scope, spaceId, path) {
+		const key = keyOf(spaceId, path);
+		const running = localReads.get(key);
+		if (running) return running;
+		let resolve;
+		const read = new Promise((done) => {
+			resolve = done;
+		});
+		const forget = () => {
+			if (localReads.get(key) === read) localReads.delete(key);
+		};
+		read.then(forget, forget);
+		localReads.set(key, read);
+		if (!localBatch) {
+			const batch = [];
+			localBatch = batch;
+			queueMicrotask(() => {
+				localBatch = null;
+				const groups = /* @__PURE__ */ new Map();
+				for (const item of batch) {
+					const id = `${item.scope}\u0000${item.spaceId}`;
+					const group = groups.get(id);
+					if (group) group.push(item);
+					else groups.set(id, [item]);
+				}
+				for (const group of groups.values()) readStored(group);
+			});
+		}
+		localBatch.push({
+			key,
+			token,
+			scope,
+			spaceId,
+			path,
+			resolve
+		});
+		return read;
+	}
+	async function readStored(group) {
+		const { scope, spaceId } = group[0];
+		const records = await fileUrlStore.read(scope, spaceId, group.map((item) => item.path)).catch(() => /* @__PURE__ */ new Map());
+		for (const { key, token, path, resolve } of group) {
+			const record = records.get(path);
+			if (!(record && now() - record.verifiedAt <= STORED_MAX_AGE_MS && (invalidatedAt.get(key) ?? -1) < record.verifiedAt)) {
+				resolve(server(token, scope, spaceId, path, false));
+				continue;
+			}
+			const entry = {
+				url: record.url,
+				inline: false,
+				...record.media ? { media: record.media } : {},
+				scope,
+				epoch: -1,
+				verifiedAt: record.verifiedAt
+			};
+			if (!memory.has(key)) remember(memory, key, entry);
+			revalidate(token, scope, spaceId, path);
+			resolve(Promise.resolve(entry));
+		}
+	}
+	function emit(spaceId, path) {
+		for (const listener of listeners) listener(spaceId, path);
+	}
+	function invalidate(spaceId, paths) {
+		const stale = [...new Set(paths)];
+		if (stale.length === 0) return;
+		reads.invalidate(spaceId, stale);
+		const at = now();
+		const buffered = lastScope === null ? void 0 : writes?.get(`${lastScope}\u0000${spaceId}`);
+		const keys = /* @__PURE__ */ new Set();
+		for (const path of stale) {
+			const key = keyOf(spaceId, path);
+			keys.add(key);
+			memory.delete(key);
+			localReads.delete(key);
+			remember(invalidatedAt, key, at);
+			buffered?.put.delete(path);
+		}
+		for (const readKey of serverReads.keys()) if (keys.has(readKey.slice(0, readKey.lastIndexOf("\0")))) serverReads.delete(readKey);
+		if (persists(lastScope)) fileUrlStore.write(lastScope, spaceId, {
+			put: /* @__PURE__ */ new Map(),
+			remove: stale
+		}).catch(() => void 0);
+	}
+	return {
+		async resolve(spaceId, path, request = {}) {
+			const purpose = request.purpose ?? "preview";
+			const token = await options.credential();
+			const scope = cache ? await options.scope().catch(() => null) : null;
+			if (scope !== null) lastScope = scope;
+			const key = keyOf(spaceId, path);
+			const hit = cache && !request.fresh ? memory.get(key) : void 0;
+			let entry;
+			if (hit && hit.scope === scope) {
+				remember(memory, key, hit);
+				const unwatched = !options.watched(spaceId) && now() - hit.verifiedAt > UNWATCHED_TRUST_MS;
+				if (hit.epoch !== epochOf(spaceId) || unwatched) revalidate(token, scope, spaceId, path);
+				entry = hit;
+			} else entry = await settle((persists(scope) && !request.fresh ? readLocal(token, scope, spaceId, path) : server(token, scope, spaceId, path, false)).catch(async (error) => {
+				if (!isUnauthorized(error)) throw error;
+				await reads.read(spaceId, path, { signal: request.signal });
+				request.signal?.throwIfAborted();
+				return server(await options.credential(), scope, spaceId, path, false);
+			}), request);
+			if (!entry || purpose === "playback" && entry.inline) return null;
+			return entry.media ? {
+				url: entry.url,
+				media: entry.media
+			} : { url: entry.url };
+		},
+		applyFsChange(spaceId, payload) {
+			if (payload.resync) epochs.set(spaceId, epochOf(spaceId) + 1);
+			const paths = /* @__PURE__ */ new Set();
+			for (const change of payload.changes ?? []) {
+				if (change.path) paths.add(change.path);
+				if (change.oldPath) paths.add(change.oldPath);
+			}
+			invalidate(spaceId, paths);
+			for (const path of paths) emit(spaceId, path);
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		}
+	};
+}
+function createSpaceFileServices(transport, websocket) {
+	const reads = createSpaceFileReads(transport);
+	const urls = createSpaceFileUrls({
+		reads,
+		credential: () => transport.credential(),
+		scope: () => transport.cacheScope(),
+		watched: (spaceId) => websocket?.isRoomLive(getRealtimeSpaceRoom(spaceId)) ?? false,
+		cache: websocket !== null && typeof window !== "undefined"
+	});
+	websocket?.on("event", (event) => {
+		if (event.type === "space.fs.changed" && event.spaceId) urls.applyFsChange(event.spaceId, event.payload);
+	});
+	return {
+		reads,
+		urls
+	};
+}
+function settle(read, { timeoutMs = PREPARING_TIMEOUT_MS, signal }) {
+	if (signal?.aborted) return Promise.reject(signal.reason);
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(() => finish(() => resolve(null)), Math.max(0, timeoutMs));
+		const abort = () => finish(() => reject(signal?.reason));
+		signal?.addEventListener("abort", abort, { once: true });
+		function finish(done) {
+			clearTimeout(timer);
+			signal?.removeEventListener("abort", abort);
+			done();
+		}
+		read.then((value) => finish(() => resolve(value)), (error) => finish(() => reject(error)));
+	});
+}
+//#endregion
 //#region src/apis/spaces.ts
 async function fetchTurnObject(url, fetchImpl = globalThis.fetch, signal) {
 	const response = await fetchImpl(url, { signal });
@@ -3671,10 +5467,6 @@ var SpacesApi = class {
 		});
 	}
 };
-function inlineFileDataUrl(file) {
-	const mimeType = file.mimeType ?? "application/octet-stream";
-	return file.encoding === "base64" ? `data:${mimeType};base64,${file.content}` : `data:${mimeType};charset=utf-8,${encodeURIComponent(file.content)}`;
-}
 function spaceFileAbortReason(signal) {
 	return signal.reason ?? new DOMException("The operation was aborted", "AbortError");
 }
@@ -3748,22 +5540,34 @@ var SpacePublicFilesApi = class {
 var SpaceFilesApi = class {
 	transport;
 	spaceId;
-	constructor(transport, spaceId) {
+	services;
+	constructor(transport, spaceId, services) {
 		this.transport = transport;
 		this.spaceId = spaceId;
+		this.services = services;
 	}
 	list(path = "", options) {
 		return listDirectory(this.transport, `/api/spaces/${this.spaceId}/fs/tree`, path, options);
 	}
 	read(path, customFetch, signal) {
-		const params = new URLSearchParams({ path });
-		return this.transport.requestRevalidated(`/api/spaces/${this.spaceId}/fs/file?${params.toString()}`, {
+		if (customFetch) return this.transport.requestRevalidated(fileReadPath(this.spaceId, path), {
 			fetch: customFetch,
 			signal
 		});
+		return this.services.reads.read(this.spaceId, path, { signal });
 	}
 	/** Resolve a browser-ready file URL, waiting for CDN delivery when necessary. */
-	async resolveUrl(path, options = {}) {
+	resolve(path, options = {}) {
+		const { fetch: customFetch, ...request } = options;
+		if (customFetch) return this.resolveThrough(path, customFetch, options);
+		return this.services.urls.resolve(this.spaceId, path, request);
+	}
+	onUrlChange(listener) {
+		return this.services.urls.subscribe((spaceId, path) => {
+			if (spaceId === this.spaceId) listener(path);
+		});
+	}
+	async resolveThrough(path, customFetch, options) {
 		const purpose = options.purpose ?? "preview";
 		const requestedTimeoutMs = options.timeoutMs ?? 15e3;
 		const timeoutMs = Number.isFinite(requestedTimeoutMs) ? Math.max(0, requestedTimeoutMs) : 15e3;
@@ -3771,11 +5575,14 @@ var SpaceFilesApi = class {
 		const deadline = createSpaceFileDeadlineSignal(options.signal, timeoutMs);
 		try {
 			while (true) {
-				const file = await this.read(path, options.fetch, deadline.signal);
+				const file = await this.read(path, customFetch, deadline.signal);
 				if (deadline.timedOut()) return null;
 				if ("content" in file) {
-					if (file.delivery === "url" && file.url) return file.url;
-					return purpose === "preview" ? inlineFileDataUrl(file) : null;
+					if (file.delivery === "url" && file.url) return file.media ? {
+						url: file.url,
+						media: file.media
+					} : { url: file.url };
+					return purpose === "preview" ? { url: inlineFileDataUrl(file) } : null;
 				}
 				const remainingMs = deadlineAt - Date.now();
 				if (remainingMs <= 0) return null;
@@ -4049,14 +5856,9 @@ var SessionTurnsClient = class {
 		});
 	}
 };
-/**
-* Routes a rejected subscription for `room` (for example a missing
-* `space.view` permission) to `onRejected`. Without this an unauthorized
-* subscriber would simply never receive events, with no way to tell.
-*/
 const onRoomRejected = (websocketClient, room, onRejected) => websocketClient.on("event", (event) => {
 	if (event.type !== "system.subscribe.error") return;
-	if (event.payload.rejected?.some((entry) => entry.room === room)) onRejected(event);
+	if (event.payload.rejected?.some((entry) => entry.room === room && entry.code !== "UNAVAILABLE")) onRejected(event);
 });
 var SessionRealtimeClient = class {
 	websocketClient;
@@ -4314,14 +6116,6 @@ var SpaceEventsApi = class {
 				handler(event);
 				return;
 			}
-			if (type === "board.changed" && event.type === "board.changed") {
-				handler(event);
-				return;
-			}
-			if (type === "board.playback.changed" && event.type === "board.playback.changed") {
-				handler(event);
-				return;
-			}
 			if (type === "app.version.published" && event.type === "app.version.published") {
 				handler(event);
 				return;
@@ -4844,11 +6638,11 @@ var SpaceClient = class {
 	boards;
 	wallet;
 	commerce;
-	constructor(id, transport, websocketClient) {
+	constructor(id, transport, websocketClient, fileServices) {
 		this.id = id;
 		this.transport = transport;
 		this.websocketClient = websocketClient;
-		this.files = new SpaceFilesApi(transport, id);
+		this.files = new SpaceFilesApi(transport, id, fileServices);
 		this.publicFiles = new SpacePublicFilesApi(transport, id);
 		this.sessions = new SpaceSessionsApi(transport, id, websocketClient);
 		this.turns = new SpaceTurnsApi(transport, id);
@@ -5812,6 +7606,7 @@ var CohubHttpClient = class {
 		return this.desktop;
 	}
 	transport;
+	fileServices;
 	constructor(options = {}) {
 		const apiBaseUrl = resolveApiBaseUrl(options);
 		const executionToken = resolveExecutionToken();
@@ -5820,6 +7615,7 @@ var CohubHttpClient = class {
 			getAccessToken: () => executionToken
 		};
 		this.transport = new HttpTransport(resolvedOptions);
+		this.fileServices = createSpaceFileServices(this.transport, null);
 		this.spaces = new SpacesApi(this.transport);
 		this.channels = new ChannelsApi(this.transport);
 		this.user = new UserApi(this.transport, apiBaseUrl, options.setStoredAuthToken, options.clearStoredAuthToken);
@@ -5842,9 +7638,9 @@ var CohubHttpClient = class {
 		this.desktop = new DesktopCommandsApi(this.transport);
 	}
 	space(spaceId) {
-		return new SpaceClient(spaceId, this.transport, null);
+		return new SpaceClient(spaceId, this.transport, null, this.fileServices);
 	}
 };
 const createHttpClient = (options) => new CohubHttpClient(options);
 //#endregion
-export { isTerminalDesktopCommandStatus as $, BoardClient as A, CronJobsApi as B, SessionPatchReducer as C, isBuiltinItemType as Ct, connectDisplay as D, boardDefaultSize as Dt, DisplayConnection as E, BOARD_ARROW_STROKE_SIZE as Et, PublicAssetsApi as F, DESKTOP_COMMAND_OPEN_TIMEOUT_MS as G, DESKTOP_COMMAND_ACCEPT_TIMEOUT_MS as H, SkillsApi as I, DESKTOP_COMMAND_SETTLEMENT_GRACE_SECONDS as J, DESKTOP_COMMAND_PAYLOAD_MAX_BYTES as K, PromptsApi as L, SessionAccessApi as M, ReferencesApi as N, readRtcTransportStats as O, SearchApi as P, isDesktopCallMethod as Q, ModelsApi as R, parseAssistantMessageCommit as S, boardItemSchema as St, SpaceDisplaysApi as T, normalizeBoardRemoteUrl as Tt, DESKTOP_COMMAND_DEFAULT_TIMEOUT_MS as U, ChannelsApi as V, DESKTOP_COMMAND_MAX_TIMEOUT_MS as W, DESKTOP_COMMAND_VERSION as X, DESKTOP_COMMAND_TERMINAL_TTL_SECONDS as Y, defaultDesktopCommandTimeoutMs as Z, PublicInviteApi as _, BoardColorSchema as _t, WorkCommerceApi as a, DISPLAY_INPUT_MAX_SCHEDULE_MS as at, SessionGenerationStreamClient as b, BoardTrackSchema as bt, AppsApi as c, normalizeDisplayPoint as ct, UserApi as d, BOARD_MIME_TYPE as dt, parseDesktopCommand as et, TasksApi as f, BOARD_CAMERA_TARGET as ft, SpacesApi as g, BoardAnimationSchema as gt, SpaceWebhooksApi as h, BoardAnimationHeaderSchema as ht, AppCommerceApi as i, DISPLAY_ELEMENT_REF_PATTERN as it, ensureRealtimeConnected as j, waitForIceGathering as k, ReferralsApi as l, splitDisplayText as lt, SpacePublicFilesApi as m, BOARD_ITEM_TYPES as mt, createHttpClient as n, resolveOpenSurface as nt, DesktopCommandsApi as o, DISPLAY_INPUT_MAX_TEXT as ot, SpaceClient as p, BOARD_COLOR_TOKENS as pt, DESKTOP_COMMAND_PENDING_TTL_SECONDS as q, RoomsApi as r, NAVIGATION_ERROR_MESSAGE_MAX_LENGTH as rt, UiCommandsApi as s, DISPLAY_SYSTEM_ACTIONS as st, CohubHttpClient as t, parseDesktopCommandId as tt, UsersApi as u, BOARD_EXTENSION as ut, buildSpaceInvitePath as v, BoardPatchSchema as vt, createSessionPatchReducer as w, parseBoardItem as wt, createSessionGenerationStreamClient as x, BoardVec2Schema as xt, buildSpacePath as y, BoardSettingsSchema as yt, GenerationsApi as z };
+export { defaultDesktopCommandTimeoutMs as $, readRtcTransportStats as A, ModelsApi as B, createSessionGenerationStreamClient as C, SpaceDisplaysApi as D, createSessionPatchReducer as E, ReferencesApi as F, DESKTOP_COMMAND_DEFAULT_TIMEOUT_MS as G, CronJobsApi as H, SearchApi as I, DESKTOP_COMMAND_PAYLOAD_MAX_BYTES as J, DESKTOP_COMMAND_MAX_TIMEOUT_MS as K, PublicAssetsApi as L, BoardClient as M, ensureRealtimeConnected as N, DisplayConnection as O, SessionAccessApi as P, DESKTOP_COMMAND_VERSION as Q, SkillsApi as R, SessionGenerationStreamClient as S, SessionPatchReducer as T, ChannelsApi as U, GenerationsApi as V, DESKTOP_COMMAND_ACCEPT_TIMEOUT_MS as W, DESKTOP_COMMAND_SETTLEMENT_GRACE_SECONDS as X, DESKTOP_COMMAND_PENDING_TTL_SECONDS as Y, DESKTOP_COMMAND_TERMINAL_TTL_SECONDS as Z, createSpaceFileServices as _, BoardAnimationSchema as _t, WorkCommerceApi as a, NAVIGATION_ERROR_MESSAGE_MAX_LENGTH as at, buildSpaceInvitePath as b, parseBoardItem as bt, AppsApi as c, DISPLAY_INPUT_MAX_TEXT as ct, UserApi as d, splitDisplayText as dt, isDesktopCallMethod as et, TasksApi as f, parseBoardDocument as ft, SpacesApi as g, BOARD_ITEM_TYPES as gt, SpaceWebhooksApi as h, BOARD_COLOR_TOKENS as ht, AppCommerceApi as i, resolveOpenSurface as it, waitForIceGathering as j, connectDisplay as k, ReferralsApi as l, DISPLAY_SYSTEM_ACTIONS as lt, SpacePublicFilesApi as m, BOARD_MIME_TYPE as mt, createHttpClient as n, parseDesktopCommand as nt, DesktopCommandsApi as o, DISPLAY_ELEMENT_REF_PATTERN as ot, SpaceClient as p, BOARD_EXTENSION as pt, DESKTOP_COMMAND_OPEN_TIMEOUT_MS as q, RoomsApi as r, parseDesktopCommandId as rt, UiCommandsApi as s, DISPLAY_INPUT_MAX_SCHEDULE_MS as st, CohubHttpClient as t, isTerminalDesktopCommandStatus as tt, UsersApi as u, normalizeDisplayPoint as ut, clearFileUrlCache as v, BoardPatchSchema as vt, parseAssistantMessageCommit as w, buildSpacePath as x, normalizeBoardRemoteUrl as xt, PublicInviteApi as y, BoardTrackSchema as yt, PromptsApi as z };