@neta-art/cohub 8.24.0 → 9.0.0

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

@@ -0,0 +1,734 @@
+import { BOARD_CAMERA_TARGET, BoardAnimationHeaderSchema, BoardColorSchema, BoardPatchSchema, BoardSettingsSchema, BoardTrackSchema, BoardVec2Schema, boardItemSchema, isBuiltinItemType, parseBoardItem } from "./board-model.js";
+import { boardJsonEquals } from "./board-json.js";
+import { applyMatrix, arrowBindings, createBoardLayout, invertMatrix, isArrowBinding } from "./board-layout.js";
+import { z } from "zod";
+//#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(entry) && Object.keys(entry).length === 0) delete value[key];
+	return value;
+}
+function isRecord(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function mergePatch(target, patch) {
+	if (!isRecord(patch)) return patch;
+	const result = isRecord(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 diffMergePatch(before, after) {
+	if (boardJsonEquals(before, after)) return void 0;
+	if (after === void 0) return null;
+	if (!isRecord(before) || !isRecord(after)) return after;
+	const patch = {};
+	for (const key of /* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)])) {
+		const value = diffMergePatch(before[key], after[key]);
+		if (value !== void 0) patch[key] = value;
+	}
+	return patch;
+}
+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()
+	}
+};
+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 listBoardProperties(targetType) {
+	if (targetType === "camera") return Object.entries(CAMERA_PROPERTIES).map(([property, spec]) => ({
+		property,
+		kind: spec.kind
+	}));
+	if (targetType === "animation") return [{
+		property: "time",
+		kind: "number"
+	}];
+	const schema = boardItemSchema(targetType);
+	const shape = schema ? unwrapObjectShape(schema) : null;
+	const result = [];
+	const visit = (field, path) => {
+		const kind = kindOf(field, path);
+		if (kind !== "discrete") {
+			result.push({
+				property: path.join("."),
+				kind
+			});
+			if (kind === "vec2" || kind === "scale") return;
+		}
+		const nested = unwrapObjectShape(field);
+		if (nested && kind !== "color") for (const [key, child] of Object.entries(nested)) visit(child, [...path, key]);
+		else if (kind === "discrete") result.push({
+			property: path.join("."),
+			kind
+		});
+	};
+	for (const [key, field] of Object.entries(shape ?? {})) {
+		if (NOT_ANIMATABLE.has(key) || key === "type") continue;
+		visit(field, [key]);
+	}
+	return result;
+}
+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 boardPatchTouches(patch) {
+	const items = /* @__PURE__ */ new Set();
+	const deletedItems = [];
+	const parents = /* @__PURE__ */ new Set();
+	const references = /* @__PURE__ */ new Set();
+	for (const [id, value] of Object.entries(patch.items ?? {})) {
+		items.add(id);
+		if (value === null) {
+			deletedItems.push(id);
+			continue;
+		}
+		if (typeof value.parent === "string") parents.add(value.parent);
+		const props = isRecord(value.props) ? value.props : null;
+		for (const end of [props?.start, props?.end]) if (isRecord(end) && typeof end.item === "string") references.add(end.item);
+	}
+	const animations = /* @__PURE__ */ new Set();
+	const deletedAnimations = [];
+	const tracks = [];
+	for (const [id, value] of Object.entries(patch.animations ?? {})) {
+		animations.add(id);
+		if (value === null) {
+			deletedAnimations.push(id);
+			continue;
+		}
+		for (const [trackId, track] of Object.entries(value.tracks ?? {})) {
+			tracks.push({
+				animation: id,
+				track: trackId
+			});
+			if (!isRecord(track)) continue;
+			if (typeof track.target === "string") references.add(track.target);
+			if (Array.isArray(track.keyframes)) {
+				for (const keyframe of track.keyframes) if (isRecord(keyframe) && typeof keyframe.value === "string") references.add(keyframe.value);
+			}
+		}
+	}
+	references.delete(BOARD_CAMERA_TARGET);
+	return {
+		items: [...items],
+		animations: [...animations],
+		tracks,
+		deletedItems,
+		deletedAnimations,
+		parents: [...parents],
+		references: [...references]
+	};
+}
+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 diffBoardDocuments(before, after) {
+	const items = {};
+	for (const id of /* @__PURE__ */ new Set([...Object.keys(before.items), ...Object.keys(after.items)])) {
+		const previous = before.items[id];
+		const next = after.items[id];
+		if (previous === next) continue;
+		const value = !next ? null : previous && previous.type === next.type ? diffMergePatch(previous, next) : next;
+		if (value !== void 0) items[id] = value;
+	}
+	const animations = {};
+	for (const id of /* @__PURE__ */ new Set([...Object.keys(before.animations), ...Object.keys(after.animations)])) {
+		const previous = before.animations[id];
+		const next = after.animations[id];
+		if (previous === next) continue;
+		if (!next || !previous) {
+			animations[id] = next ?? null;
+			continue;
+		}
+		const { tracks: previousTracks, ...previousHeader } = previous;
+		const { tracks: nextTracks, ...nextHeader } = next;
+		const header = diffMergePatch(previousHeader, nextHeader);
+		const tracks = {};
+		for (const trackId of /* @__PURE__ */ new Set([...Object.keys(previousTracks), ...Object.keys(nextTracks)])) {
+			const value = diffMergePatch(previousTracks[trackId], nextTracks[trackId]);
+			if (value !== void 0) tracks[trackId] = value;
+		}
+		const entry = withoutEmpty({
+			...isRecord(header) ? header : {},
+			tracks
+		});
+		if (Object.keys(entry).length) animations[id] = entry;
+	}
+	return withoutEmpty({
+		board: diffMergePatch(before.board, after.board),
+		items,
+		animations
+	});
+}
+function isEmptyBoardPatch(patch) {
+	return patch.board === void 0 && Object.keys(patch.items ?? {}).length === 0 && Object.keys(patch.animations ?? {}).length === 0;
+}
+function parseBoardDocument(input) {
+	if (!isRecord(input)) return {
+		ok: false,
+		diagnostics: [error("", "INVALID_DOCUMENT", "expected an object")]
+	};
+	const result = applyBoardPatchToDocument({
+		board: BoardSettingsSchema.parse({}),
+		items: {},
+		animations: {}
+	}, {
+		...isRecord(input.board) ? { board: input.board } : {},
+		...isRecord(input.items) ? { items: input.items } : {},
+		...isRecord(input.animations) ? { animations: input.animations } : {}
+	});
+	return result.ok ? {
+		ok: true,
+		document: result.document
+	} : result;
+}
+//#endregion
+export { applyBoardDelta, applyBoardPatch, applyBoardPatchToDocument, boardPatchTouches, createDocumentState, diffBoardDocuments, diffMergePatch, isEmptyBoardPatch, listBoardProperties, mergePatch, parseBoardDocument, pruneBoardTrack, resolveBoardProperty, trackReferences };