@scrawl-board/board 0.1.0-beta.0

package/dist/core.js

@@ -0,0 +1,2253 @@
+//#region src/core-internal/assets.ts
+var ASSET_REF_PATTERN = /^asset:[a-z0-9](?:[a-z0-9.-]{0,61}[a-z0-9])?:[A-Za-z0-9._~-]+$/;
+function isAssetRef(value) {
+	return typeof value === "string" && ASSET_REF_PATTERN.test(value) && new TextEncoder().encode(value).length <= 512;
+}
+//#endregion
+//#region src/core-internal/identifiers.ts
+function documentId(value) {
+	if (!value) throw new TypeError("DocumentId cannot be empty");
+	return value;
+}
+function strokeId(value) {
+	if (!value) throw new TypeError("StrokeId cannot be empty");
+	return value;
+}
+//#endregion
+//#region src/document-schema.ts
+var CURRENT_DOCUMENT_SCHEMA_VERSION = 1;
+var DocumentRecoveryError = class extends Error {
+	constructor(code, message, originalBytes, path) {
+		super(message);
+		this.code = code;
+		this.originalBytes = originalBytes;
+		this.path = path;
+		this.name = "DocumentRecoveryError";
+	}
+};
+function loadDocumentBytes(originalBytes) {
+	let raw;
+	try {
+		raw = JSON.parse(originalBytes);
+	} catch {
+		return failure("DOCUMENT_JSON_INVALID", "Document is not valid JSON", originalBytes);
+	}
+	const result = migrateDocument(raw);
+	if (result.ok) return result;
+	return {
+		ok: false,
+		error: new DocumentRecoveryError(result.error.code, result.error.message, originalBytes, result.error.path)
+	};
+}
+function migrateDocument(raw) {
+	if (!isRecord(raw)) return failure("DOCUMENT_VALIDATION_FAILED", "Document must be an object");
+	const version = raw.schemaVersion ?? 0;
+	if (version !== 0 && version !== 1) return failure("DOCUMENT_VERSION_UNSUPPORTED", `Document schema version ${String(version)} is unsupported`, void 0, "schemaVersion");
+	if (!isJsonValue(raw)) return failure("DOCUMENT_VALIDATION_FAILED", "Document must contain JSON values only");
+	const strokes = validateStrokes(raw.strokes);
+	if (strokes instanceof DocumentRecoveryError) return {
+		ok: false,
+		error: strokes
+	};
+	const collections = {
+		notes: validateCollection(raw, "notes", version, validateNote),
+		textBlocks: validateCollection(raw, "textBlocks", version, validateText),
+		tables: validateCollection(raw, "tables", version, validateTable),
+		images: validateCollection(raw, "images", version, validateImage),
+		timers: validateCollection(raw, "timers", version, validateTimer),
+		customObjects: validateCollection(raw, "customObjects", version, validateCustomObject, false)
+	};
+	if (collections.notes instanceof DocumentRecoveryError) return {
+		ok: false,
+		error: collections.notes
+	};
+	if (collections.textBlocks instanceof DocumentRecoveryError) return {
+		ok: false,
+		error: collections.textBlocks
+	};
+	if (collections.tables instanceof DocumentRecoveryError) return {
+		ok: false,
+		error: collections.tables
+	};
+	if (collections.images instanceof DocumentRecoveryError) return {
+		ok: false,
+		error: collections.images
+	};
+	if (collections.timers instanceof DocumentRecoveryError) return {
+		ok: false,
+		error: collections.timers
+	};
+	if (collections.customObjects instanceof DocumentRecoveryError) return {
+		ok: false,
+		error: collections.customObjects
+	};
+	return {
+		ok: true,
+		migratedFrom: version,
+		document: {
+			schemaVersion: 1,
+			strokes,
+			notes: collections.notes,
+			textBlocks: collections.textBlocks,
+			tables: collections.tables,
+			images: collections.images,
+			timers: collections.timers,
+			customObjects: collections.customObjects
+		}
+	};
+}
+function serializeDocument(document) {
+	const result = migrateDocument(document);
+	if (!result.ok || result.migratedFrom !== 1) throw result.ok ? new DocumentRecoveryError("DOCUMENT_VALIDATION_FAILED", "Saving requires the current Document schema") : result.error;
+	return JSON.stringify(result.document);
+}
+function validateCollection(raw, name, version, validator, requiredAtCurrentVersion = true) {
+	if (requiredAtCurrentVersion && version === 1 && !(name in raw)) return validation(`${name} is required`, name);
+	const value = raw[name] ?? [];
+	if (!Array.isArray(value)) return validation(`${name} must be an array`, name);
+	for (let index = 0; index < value.length; index += 1) if (!isRecord(value[index]) || !validator(value[index])) return validation(`invalid ${name} entry`, `${name}[${index}]`);
+	return structuredClone(value);
+}
+function validateStrokes(raw) {
+	if (!Array.isArray(raw)) return validation("strokes must be an array", "strokes");
+	const strokes = [];
+	for (let index = 0; index < raw.length; index += 1) {
+		const value = raw[index];
+		const path = `strokes[${index}]`;
+		if (!isRecord(value) || !nonempty(value.id) || !nonempty(value.color) || !positive(value.baseWidth) || !optionalEnum(value.tool, ["marker", "highlighter"]) || !validLock(value) || !optionalString(value.clusterId) || !validMatrix(value.matrix) || !Array.isArray(value.points)) return validation("invalid stroke", path);
+		const points = [];
+		for (let pointIndex = 0; pointIndex < value.points.length; pointIndex += 1) {
+			const point = normalizePoint(value.points[pointIndex]);
+			if (!point) return validation("invalid stroke point", `${path}.points[${pointIndex}]`);
+			points.push(point);
+		}
+		strokes.push({
+			...structuredClone(value),
+			id: strokeId(value.id),
+			points
+		});
+	}
+	return strokes;
+}
+function normalizePoint(raw) {
+	const values = Array.isArray(raw) ? raw : isRecord(raw) ? [
+		raw.x,
+		raw.y,
+		raw.pressure,
+		raw.erase ?? 0
+	] : [];
+	if (values.length !== 4 || !values.every(finite) || !unit(values[2]) || !unit(values[3])) return null;
+	return values;
+}
+function validateNote(v) {
+	return basePosition(v) && positive(v.size) && finite(v.zOffset) && nonempty(v.color) && typeof v.text === "string" && validLock(v) && (v.votes === void 0 || Array.isArray(v.votes) && v.votes.every((vote) => isRecord(vote) && nonempty(vote.userId) && nonempty(vote.name) && nonempty(vote.color)));
+}
+function validateText(v) {
+	return basePosition(v) && typeof v.text === "string" && positive(v.fontSize) && nonempty(v.color) && validLock(v) && optionalString(v.clusterId);
+}
+function validateTable(v) {
+	return basePosition(v) && integer(v.rows) && integer(v.cols) && numberArray(v.colWidths, v.cols) && numberArray(v.rowHeights, v.rows) && isStringRecord(v.cells) && validLock(v) && optionalString(v.color) && optionalString(v.backgroundColor) && optionalString(v.clusterId);
+}
+function validateImage(v) {
+	const identifiesAnImage = v.ref !== void 0 ? isAssetRef(v.ref) : nonempty(v.src);
+	return basePosition(v) && identifiesAnImage && positive(v.width) && positive(v.height) && positive(v.aspectRatio) && validLock(v) && optionalString(v.name) && optionalString(v.createdAt) && optionalString(v.stamp);
+}
+function validateTimer(v) {
+	return basePosition(v) && positive(v.size) && positive(v.durationMs) && finite(v.remainingMs) && v.remainingMs >= 0 && (v.runningSince === void 0 || finite(v.runningSince)) && validLock(v);
+}
+function validateCustomObject(v) {
+	return nonempty(v.id) && nonempty(v.type) && integer(v.schemaVersion) && validMatrix(v.transform) && Array.isArray(v.transform) && validCustomFallback(v.fallback) && (v.lock === void 0 || validCustomLock(v.lock)) && isJsonValue(v.props);
+}
+function validCustomFallback(v) {
+	if (!isRecord(v)) return false;
+	const bounds = v.bounds;
+	return isRecord(bounds) && finite(bounds.x) && finite(bounds.y) && finite(bounds.width) && finite(bounds.height) && optionalString(v.label);
+}
+function validCustomLock(v) {
+	return isRecord(v) && nonempty(v.holderId) && finite(v.acquiredAt);
+}
+function basePosition(v) {
+	return nonempty(v.id) && finite(v.x) && finite(v.y);
+}
+function validLock(v) {
+	return (v.locked === void 0 || typeof v.locked === "boolean") && optionalString(v.lockedBy) && optionalString(v.lockedByName);
+}
+function validMatrix(v) {
+	return v === void 0 || Array.isArray(v) && v.length === 6 && v.every(finite);
+}
+function numberArray(v, length) {
+	return Array.isArray(v) && v.length === length && v.every(positive);
+}
+function isStringRecord(v) {
+	return isRecord(v) && Object.values(v).every((item) => typeof item === "string");
+}
+function optionalString(v) {
+	return v === void 0 || typeof v === "string";
+}
+function optionalEnum(v, values) {
+	return v === void 0 || typeof v === "string" && values.includes(v);
+}
+function nonempty(v) {
+	return typeof v === "string" && v.length > 0;
+}
+function finite(v) {
+	return typeof v === "number" && Number.isFinite(v);
+}
+function positive(v) {
+	return finite(v) && v > 0;
+}
+function integer(v) {
+	return Number.isInteger(v) && v > 0;
+}
+function unit(v) {
+	return finite(v) && v >= 0 && v <= 1;
+}
+function isRecord(v) {
+	if (typeof v !== "object" || v === null || Array.isArray(v)) return false;
+	const prototype = Object.getPrototypeOf(v);
+	return prototype === Object.prototype || prototype === null;
+}
+function isJsonValue(v) {
+	if (v === null || typeof v === "string" || typeof v === "boolean" || finite(v)) return true;
+	if (Array.isArray(v)) return v.every(isJsonValue);
+	return isRecord(v) && Object.values(v).every(isJsonValue);
+}
+function failure(code, message, originalBytes, path) {
+	return {
+		ok: false,
+		error: new DocumentRecoveryError(code, message, originalBytes, path)
+	};
+}
+function validation(message, path) {
+	return new DocumentRecoveryError("DOCUMENT_VALIDATION_FAILED", message, void 0, path);
+}
+//#endregion
+//#region src/core-internal/affine2d.ts
+var IDENTITY = [
+	1,
+	0,
+	0,
+	1,
+	0,
+	0
+];
+function isIdentity(m) {
+	return m[0] === 1 && m[1] === 0 && m[2] === 0 && m[3] === 1 && m[4] === 0 && m[5] === 0;
+}
+/** Compose: apply `first`, then `second`. */
+function mul(second, first) {
+	const [a2, b2, c2, d2, tx2, ty2] = second;
+	const [a1, b1, c1, d1, tx1, ty1] = first;
+	return [
+		a2 * a1 + c2 * b1,
+		b2 * a1 + d2 * b1,
+		a2 * c1 + c2 * d1,
+		b2 * c1 + d2 * d1,
+		a2 * tx1 + c2 * ty1 + tx2,
+		b2 * tx1 + d2 * ty1 + ty2
+	];
+}
+function invert(m) {
+	const [a, b, c, d, tx, ty] = m;
+	const det = a * d - b * c;
+	const ia = d / det;
+	const ib = -b / det;
+	const ic = -c / det;
+	const id = a / det;
+	return [
+		ia,
+		ib,
+		ic,
+		id,
+		-(ia * tx + ic * ty),
+		-(ib * tx + id * ty)
+	];
+}
+function apply(m, p) {
+	return {
+		x: m[0] * p.x + m[2] * p.y + m[4],
+		y: m[1] * p.x + m[3] * p.y + m[5]
+	};
+}
+function translation(dx, dy) {
+	return [
+		1,
+		0,
+		0,
+		1,
+		dx,
+		dy
+	];
+}
+function rotationAbout(angle, cx, cy) {
+	const cos = Math.cos(angle);
+	const sin = Math.sin(angle);
+	return [
+		cos,
+		sin,
+		-sin,
+		cos,
+		cx - cos * cx + sin * cy,
+		cy - sin * cx - cos * cy
+	];
+}
+function scalingAbout(sx, sy, cx, cy) {
+	return [
+		sx,
+		0,
+		0,
+		sy,
+		cx - sx * cx,
+		cy - sy * cy
+	];
+}
+/** Approximate uniform length scale (average of the axis scales). */
+function avgScale(m) {
+	return (Math.hypot(m[0], m[1]) + Math.hypot(m[2], m[3])) / 2;
+}
+//#endregion
+//#region src/core-internal/boardSearch.ts
+function hay(s) {
+	return s.toLowerCase();
+}
+function snippet(text, q, width = 72) {
+	const i = hay(text).indexOf(q);
+	if (i < 0) return text.slice(0, width);
+	const start = Math.max(0, i - 16);
+	const slice = text.slice(start, start + width).trim();
+	return (start > 0 ? "…" : "") + slice;
+}
+/**
+* Find notes, text, table cells, stamps, and comments whose text contains
+* `query`. Empty / whitespace queries return nothing.
+*/
+function searchBoard(query, board) {
+	const q = hay(query.trim());
+	if (!q) return [];
+	const hits = [];
+	for (const note of board.notes) if (hay(note.text).includes(q)) hits.push({
+		kind: "note",
+		id: note.id,
+		title: "Note",
+		snippet: snippet(note.text, q) || "(empty note)",
+		x: note.x,
+		y: note.y
+	});
+	for (const block of board.texts) if (hay(block.text).includes(q)) hits.push({
+		kind: "text",
+		id: block.id,
+		title: "Text",
+		snippet: snippet(block.text, q),
+		x: block.x,
+		y: block.y
+	});
+	for (const table of board.tables) {
+		const cells = Object.entries(table.cells).filter(([, text]) => hay(text).includes(q)).map(([, text]) => text);
+		if (cells.length) hits.push({
+			kind: "table",
+			id: table.id,
+			title: "Table",
+			snippet: snippet(cells.join(" · "), q),
+			x: table.x,
+			y: table.y
+		});
+	}
+	for (const image of board.images) if (hay(`${image.stamp ?? ""} ${image.name ?? ""}`).includes(q)) hits.push({
+		kind: "stamp",
+		id: image.id,
+		title: image.stamp ? "Stamp" : "Image",
+		snippet: image.name ?? image.stamp ?? "image",
+		x: image.x,
+		y: image.y
+	});
+	for (const comment of board.comments) if (hay([comment.text, ...comment.replies.map((r) => r.text)].join("\n")).includes(q) || hay(comment.authorName).includes(q)) hits.push({
+		kind: "comment",
+		id: comment.id,
+		title: comment.authorName,
+		snippet: snippet(comment.text, q),
+		x: comment.x,
+		y: comment.y
+	});
+	return hits;
+}
+//#endregion
+//#region src/core-internal/types.ts
+/** Erasure level at which a point counts as fully erased. */
+var ERASE_THRESHOLD = .95;
+function cloneStroke(stroke) {
+	return {
+		...stroke,
+		points: stroke.points.map((p) => ({ ...p })),
+		...stroke.matrix ? { matrix: [...stroke.matrix] } : {}
+	};
+}
+var INK_COLORS = {
+	black: "#1C1C1E",
+	red: "#E0333D",
+	blue: "#2563EB",
+	green: "#16A34A"
+};
+var HIGHLIGHT_COLORS = {
+	yellow: "#FDE047",
+	green: "#86EFAC",
+	pink: "#F9A8D4",
+	blue: "#93C5FD"
+};
+var NOTE_COLORS = {
+	yellow: "#FDE68A",
+	pink: "#FBCFE8",
+	blue: "#BFDBFE",
+	green: "#BBF7D0"
+};
+var TEXT_DEFAULT_SIZE = 1.8;
+function cloneText(block) {
+	return { ...block };
+}
+/**
+* Estimated bounds of a text block (average-glyph-width heuristic — no DOM,
+* usable from clustering, export, and tests alike).
+*/
+function measureTextBlock(text, fontSize) {
+	const lines = text.split("\n");
+	return {
+		width: Math.max(1, ...lines.map((l) => l.length)) * fontSize * .55,
+		height: lines.length * fontSize * 1.25
+	};
+}
+var NOTE_DEFAULT_SIZE = 10;
+var NOTE_DEFAULT_Z = 1;
+var NOTE_MIN_Z = .4;
+var NOTE_MAX_Z = 6;
+var NOTE_PEEL_STEP = .7;
+function cloneNote(note) {
+	return {
+		...note,
+		...note.votes ? { votes: note.votes.map((v) => ({ ...v })) } : {}
+	};
+}
+var TABLE_DEFAULT_CELL_WIDTH = 8;
+var TABLE_DEFAULT_CELL_HEIGHT = 3.6;
+var TABLE_DEFAULT_FONT_SIZE = 1.25;
+function cloneTable(table) {
+	return {
+		...table,
+		colWidths: [...table.colWidths],
+		rowHeights: [...table.rowHeights],
+		cells: { ...table.cells }
+	};
+}
+function measureTable(table) {
+	return {
+		width: table.colWidths.reduce((sum, w) => sum + w, 0),
+		height: table.rowHeights.reduce((sum, h) => sum + h, 0)
+	};
+}
+var BOARD_COLOR = "#FFFFFF";
+var FOG_COLOR = "#FFFFFF";
+function cloneImage(img) {
+	return { ...img };
+}
+//#endregion
+//#region src/core-internal/clusterStore.ts
+/** A stroke joins a cluster last written to within this window at full reach. */
+var RECENT_MS = 8e3;
+/** Older clusters are still joinable, at half the gap threshold. */
+var STALE_FACTOR = .5;
+var GAP_FACTOR = .9;
+var MIN_GAP = 1;
+var MAX_GAP = 8;
+var ClusterStore = class {
+	constructor(doc, createId, now) {
+		this.doc = doc;
+		this.createId = createId;
+		this.now = now;
+		this.clusters = /* @__PURE__ */ new Map();
+		this.byStroke = /* @__PURE__ */ new Map();
+		this.unsubscribe = doc.subscribe((change) => {
+			for (const id of change.removed) this.removeMember(id);
+			for (const id of change.textRemoved) this.removeMember(id);
+			for (const stroke of change.added) this.addMember(stroke.id, stroke.clusterId);
+			for (const block of change.textAdded) this.addMember(block.id, block.clusterId);
+			const moved = /* @__PURE__ */ new Set();
+			for (const stroke of change.transformed) {
+				const cid = this.byStroke.get(stroke.id);
+				if (cid) moved.add(cid);
+			}
+			for (const block of change.textUpdated) {
+				const cid = this.byStroke.get(block.id);
+				if (cid) moved.add(cid);
+			}
+			for (const cid of moved) this.recompute(cid);
+		});
+		for (const stroke of doc.all()) this.addMember(stroke.id, stroke.clusterId, 0);
+		for (const block of doc.allTexts()) this.addMember(block.id, block.clusterId, 0);
+	}
+	/**
+	* Pick (or create) the cluster for a freshly drawn stroke and stamp its
+	* clusterId. Gap threshold scales with stroke height, per the build prompt.
+	*/
+	assign(stroke, now = this.now()) {
+		const box = bboxOfPoints(stroke.points);
+		stroke.clusterId = this.pick(box, now);
+	}
+	/** Same assignment for a typed text block, using its estimated bounds. */
+	assignText(block, now = this.now()) {
+		block.clusterId = this.pick(textBBox(block), now);
+	}
+	pick(box, now) {
+		const height = box.maxY - box.minY;
+		let best = null;
+		for (const cluster of this.clusters.values()) {
+			const avgHeight = cluster.heightSum / cluster.strokeIds.size;
+			let threshold = clamp$1(GAP_FACTOR * Math.max(height, avgHeight), MIN_GAP, MAX_GAP);
+			if (now - cluster.lastStrokeAt > RECENT_MS) threshold *= STALE_FACTOR;
+			const gap = bboxGap(box, cluster.bbox);
+			if (gap <= threshold && (!best || gap < best.gap)) best = {
+				id: cluster.id,
+				gap
+			};
+		}
+		return best?.id ?? this.createId();
+	}
+	/** All strokes in the same cluster; a clusterless stroke is its own group. */
+	membersOf(strokeId) {
+		const cid = this.byStroke.get(strokeId);
+		const cluster = cid ? this.clusters.get(cid) : void 0;
+		return cluster ? [...cluster.strokeIds] : [strokeId];
+	}
+	dispose() {
+		this.unsubscribe();
+		this.clusters.clear();
+		this.byStroke.clear();
+	}
+	/** Strokes and text blocks index identically; bbox source differs. */
+	memberBBox(id) {
+		const strokeBox = this.doc.bbox(id);
+		if (strokeBox) return strokeBox;
+		const block = this.doc.getText(id);
+		return block ? textBBox(block) : void 0;
+	}
+	addMember(id, clusterId, at = this.now()) {
+		if (!clusterId) return;
+		const box = this.memberBBox(id);
+		if (!box) return;
+		let cluster = this.clusters.get(clusterId);
+		if (!cluster) {
+			cluster = {
+				id: clusterId,
+				strokeIds: /* @__PURE__ */ new Set(),
+				bbox: { ...box },
+				lastStrokeAt: at,
+				heightSum: 0
+			};
+			this.clusters.set(cluster.id, cluster);
+		}
+		cluster.strokeIds.add(id);
+		cluster.bbox.minX = Math.min(cluster.bbox.minX, box.minX);
+		cluster.bbox.minY = Math.min(cluster.bbox.minY, box.minY);
+		cluster.bbox.maxX = Math.max(cluster.bbox.maxX, box.maxX);
+		cluster.bbox.maxY = Math.max(cluster.bbox.maxY, box.maxY);
+		cluster.lastStrokeAt = Math.max(cluster.lastStrokeAt, at);
+		cluster.heightSum += box.maxY - box.minY;
+		this.byStroke.set(id, cluster.id);
+	}
+	removeMember(memberId) {
+		const cid = this.byStroke.get(memberId);
+		if (!cid) return;
+		this.byStroke.delete(memberId);
+		const cluster = this.clusters.get(cid);
+		if (!cluster) return;
+		cluster.strokeIds.delete(memberId);
+		if (cluster.strokeIds.size === 0) this.clusters.delete(cid);
+		else this.recompute(cid);
+	}
+	recompute(cid) {
+		const cluster = this.clusters.get(cid);
+		if (!cluster) return;
+		const box = {
+			minX: Infinity,
+			minY: Infinity,
+			maxX: -Infinity,
+			maxY: -Infinity
+		};
+		let heightSum = 0;
+		for (const id of cluster.strokeIds) {
+			const b = this.memberBBox(id);
+			if (!b) continue;
+			box.minX = Math.min(box.minX, b.minX);
+			box.minY = Math.min(box.minY, b.minY);
+			box.maxX = Math.max(box.maxX, b.maxX);
+			box.maxY = Math.max(box.maxY, b.maxY);
+			heightSum += b.maxY - b.minY;
+		}
+		cluster.bbox = box;
+		cluster.heightSum = heightSum;
+	}
+};
+/** Estimated world bounds of a text block: top-left anchor, lines flow -y. */
+function textBBox(block) {
+	const { width, height } = measureTextBlock(block.text, block.fontSize);
+	return {
+		minX: block.x,
+		maxX: block.x + width,
+		minY: block.y - height,
+		maxY: block.y
+	};
+}
+function bboxOfPoints(points) {
+	const box = {
+		minX: Infinity,
+		minY: Infinity,
+		maxX: -Infinity,
+		maxY: -Infinity
+	};
+	for (const p of points) {
+		if (p.x < box.minX) box.minX = p.x;
+		if (p.y < box.minY) box.minY = p.y;
+		if (p.x > box.maxX) box.maxX = p.x;
+		if (p.y > box.maxY) box.maxY = p.y;
+	}
+	return box;
+}
+/** Shortest distance between two bboxes; 0 when they touch or overlap. */
+function bboxGap(a, b) {
+	const dx = Math.max(0, b.minX - a.maxX, a.minX - b.maxX);
+	const dy = Math.max(0, b.minY - a.maxY, a.minY - b.maxY);
+	return Math.hypot(dx, dy);
+}
+function clamp$1(v, lo, hi) {
+	return Math.min(hi, Math.max(lo, v));
+}
+//#endregion
+//#region src/core-internal/extensionTypes.ts
+function cloneCustomObject(object) {
+	return {
+		...object,
+		transform: [...object.transform],
+		fallback: { ...object.fallback },
+		...object.lock ? { lock: { ...object.lock } } : {}
+	};
+}
+//#endregion
+//#region src/core-internal/kitchenTimer.ts
+var TIMER_DEFAULT_SIZE = 12;
+var TIMER_DEFAULT_DURATION_MS = 300 * 1e3;
+var TIMER_PRESETS_MS = [
+	6e4,
+	5 * 6e4,
+	10 * 6e4,
+	15 * 6e4
+];
+function cloneTimer(timer) {
+	return { ...timer };
+}
+function timerRemaining(timer, now) {
+	if (!timer.runningSince) return Math.max(0, timer.remainingMs);
+	return Math.max(0, timer.remainingMs - (now - timer.runningSince));
+}
+function timerExpired(timer, now) {
+	return timerRemaining(timer, now) <= 0;
+}
+function startTimer(timer, now) {
+	const remaining = timerRemaining(timer, now);
+	if (remaining <= 0) return {
+		...timer,
+		remainingMs: timer.durationMs,
+		runningSince: now
+	};
+	if (timer.runningSince) return timer;
+	return {
+		...timer,
+		remainingMs: remaining,
+		runningSince: now
+	};
+}
+function pauseTimer(timer, now) {
+	if (!timer.runningSince) return timer;
+	return {
+		...timer,
+		remainingMs: timerRemaining(timer, now),
+		runningSince: void 0
+	};
+}
+function toggleTimer(timer, now) {
+	return timer.runningSince ? pauseTimer(timer, now) : startTimer(timer, now);
+}
+function setTimerDuration(timer, durationMs) {
+	return {
+		...timer,
+		durationMs,
+		remainingMs: durationMs,
+		runningSince: void 0
+	};
+}
+function formatTimer(ms) {
+	const total = Math.max(0, Math.ceil(ms / 1e3));
+	return `${Math.floor(total / 60)}:${(total % 60).toString().padStart(2, "0")}`;
+}
+//#endregion
+//#region src/core-internal/itemLock.ts
+/**
+* Apply or clear a lock in place. Unlock always drops the holder so a stale
+* name cannot linger on an unlocked item.
+*/
+function applyItemLock(item, locked, by) {
+	if (locked) {
+		item.locked = true;
+		if (by) {
+			item.lockedBy = by.userId;
+			item.lockedByName = by.name;
+		}
+		return;
+	}
+	delete item.locked;
+	delete item.lockedBy;
+	delete item.lockedByName;
+}
+/**
+* Only the person who locked it can unlock it. Items locked before ownership
+* existed (no `lockedBy`) stay unlockable by anyone, so old boards don't brick.
+*/
+function canUnlockItem(item, userId) {
+	if (!item?.locked) return true;
+	if (!item.lockedBy) return true;
+	return !!userId && item.lockedBy === userId;
+}
+/** Wire fields for a locked item; omitted entirely when unlocked. */
+function serializeLock(item) {
+	if (!item.locked) return {};
+	return {
+		locked: true,
+		...item.lockedBy ? { lockedBy: item.lockedBy } : {},
+		...item.lockedByName ? { lockedByName: item.lockedByName } : {}
+	};
+}
+//#endregion
+//#region src/core-internal/document.ts
+/**
+* The one place a live Stroke becomes its wire representation — in
+* particular, points collapse from {x,y,pressure,erase?} objects into
+* [x,y,pressure,erase] tuples. Anything that persists a stroke (toJSON, and
+* the incremental ops opSync.ts sends) must go through this, or the two
+* paths drift: a stroke saved with points-as-objects looks fine until the
+* next load, where deserializeStrokes' array-destructuring throws "object is
+* not iterable" — exactly what shipping the live object straight into an op
+* used to do.
+*/
+function serializeStroke(s) {
+	return {
+		id: s.id,
+		color: s.color,
+		baseWidth: s.baseWidth,
+		...s.tool && s.tool !== "marker" ? { tool: s.tool } : {},
+		points: s.points.map((p) => [
+			p.x,
+			p.y,
+			p.pressure,
+			p.erase ?? 0
+		]),
+		...s.matrix && !isIdentity(s.matrix) ? { matrix: [...s.matrix] } : {},
+		...s.clusterId ? { clusterId: s.clusterId } : {},
+		...serializeLock(s)
+	};
+}
+var EMPTY_CHANGE = {
+	added: [],
+	removed: [],
+	updated: [],
+	transformed: [],
+	notesAdded: [],
+	notesRemoved: [],
+	notesUpdated: [],
+	textAdded: [],
+	textRemoved: [],
+	textUpdated: [],
+	tablesAdded: [],
+	tablesRemoved: [],
+	tablesUpdated: [],
+	imagesAdded: [],
+	imagesRemoved: [],
+	imagesUpdated: [],
+	timersAdded: [],
+	timersRemoved: [],
+	timersUpdated: [],
+	customObjectsAdded: [],
+	customObjectsRemoved: [],
+	customObjectsUpdated: []
+};
+var BoardDocument = class {
+	constructor(id) {
+		this.id = id;
+		this.version = 0;
+		this.strokes = /* @__PURE__ */ new Map();
+		this.notes = /* @__PURE__ */ new Map();
+		this.texts = /* @__PURE__ */ new Map();
+		this.tables = /* @__PURE__ */ new Map();
+		this.images = /* @__PURE__ */ new Map();
+		this.timers = /* @__PURE__ */ new Map();
+		this.customObjects = /* @__PURE__ */ new Map();
+		this.bboxes = /* @__PURE__ */ new Map();
+		this.listeners = /* @__PURE__ */ new Set();
+	}
+	get(id) {
+		return this.strokes.get(id);
+	}
+	all() {
+		return this.strokes.values();
+	}
+	bbox(id) {
+		return this.bboxes.get(id);
+	}
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	}
+	addStrokes(strokes) {
+		for (const stroke of strokes) {
+			this.strokes.set(stroke.id, stroke);
+			this.bboxes.set(stroke.id, computeBBox(stroke));
+		}
+		this.emit({ added: strokes });
+	}
+	removeStrokes(ids) {
+		const removed = [];
+		for (const id of ids) if (this.strokes.delete(id)) {
+			this.bboxes.delete(id);
+			removed.push(id);
+		}
+		if (removed.length) this.emit({ removed });
+	}
+	/** Announce in-place point mutations (erasure decay; bbox is unchanged). */
+	touchStrokes(strokes) {
+		this.emit({ updated: strokes });
+	}
+	/** Announce matrix changes; recomputes world bboxes. */
+	transformStrokes(strokes) {
+		for (const stroke of strokes) this.bboxes.set(stroke.id, computeBBox(stroke));
+		this.emit({ transformed: strokes });
+	}
+	getNote(id) {
+		return this.notes.get(id);
+	}
+	allNotes() {
+		return this.notes.values();
+	}
+	addNotes(notes) {
+		for (const note of notes) this.notes.set(note.id, note);
+		this.emit({ notesAdded: notes });
+	}
+	removeNotes(ids) {
+		const notesRemoved = [];
+		for (const id of ids) if (this.notes.delete(id)) notesRemoved.push(id);
+		if (notesRemoved.length) this.emit({ notesRemoved });
+	}
+	/** Replace a note's contents (move, peel, retext) under the same id. */
+	setNote(note) {
+		this.notes.set(note.id, note);
+		this.emit({ notesUpdated: [note] });
+	}
+	getText(id) {
+		return this.texts.get(id);
+	}
+	allTexts() {
+		return this.texts.values();
+	}
+	addTexts(blocks) {
+		for (const block of blocks) this.texts.set(block.id, block);
+		this.emit({ textAdded: blocks });
+	}
+	removeTexts(ids) {
+		const textRemoved = [];
+		for (const id of ids) if (this.texts.delete(id)) textRemoved.push(id);
+		if (textRemoved.length) this.emit({ textRemoved });
+	}
+	/** Replace a text block's contents (move, retext) under the same id. */
+	setText(block) {
+		this.texts.set(block.id, block);
+		this.emit({ textUpdated: [block] });
+	}
+	getTable(id) {
+		return this.tables.get(id);
+	}
+	allTables() {
+		return this.tables.values();
+	}
+	addTables(tables) {
+		for (const table of tables) this.tables.set(table.id, table);
+		this.emit({ tablesAdded: tables });
+	}
+	removeTables(ids) {
+		const tablesRemoved = [];
+		for (const id of ids) if (this.tables.delete(id)) tablesRemoved.push(id);
+		if (tablesRemoved.length) this.emit({ tablesRemoved });
+	}
+	/** Replace a table's contents (move, resize, change cells) under the same id. */
+	setTable(table) {
+		this.tables.set(table.id, table);
+		this.emit({ tablesUpdated: [table] });
+	}
+	getImage(id) {
+		return this.images.get(id);
+	}
+	allImages() {
+		return this.images.values();
+	}
+	addImages(images) {
+		for (const img of images) this.images.set(img.id, img);
+		this.emit({ imagesAdded: images });
+	}
+	removeImages(ids) {
+		const imagesRemoved = [];
+		for (const id of ids) if (this.images.delete(id)) imagesRemoved.push(id);
+		if (imagesRemoved.length) this.emit({ imagesRemoved });
+	}
+	/** Replace an image block's contents (move, resize) under the same id. */
+	setImage(image) {
+		this.images.set(image.id, image);
+		this.emit({ imagesUpdated: [image] });
+	}
+	getTimer(id) {
+		return this.timers.get(id);
+	}
+	allTimers() {
+		return this.timers.values();
+	}
+	addTimers(timers) {
+		for (const timer of timers) this.timers.set(timer.id, timer);
+		this.emit({ timersAdded: timers });
+	}
+	removeTimers(ids) {
+		const timersRemoved = [];
+		for (const id of ids) if (this.timers.delete(id)) timersRemoved.push(id);
+		if (timersRemoved.length) this.emit({ timersRemoved });
+	}
+	setTimer(timer) {
+		this.timers.set(timer.id, timer);
+		this.emit({ timersUpdated: [timer] });
+	}
+	getCustomObject(id) {
+		return this.customObjects.get(id);
+	}
+	allCustomObjects() {
+		return this.customObjects.values();
+	}
+	addCustomObjects(objects) {
+		for (const object of objects) this.customObjects.set(object.id, object);
+		this.emit({ customObjectsAdded: objects });
+	}
+	removeCustomObjects(ids) {
+		const customObjectsRemoved = [];
+		for (const id of ids) if (this.customObjects.delete(id)) customObjectsRemoved.push(id);
+		if (customObjectsRemoved.length) this.emit({ customObjectsRemoved });
+	}
+	/** Replace a custom object's contents under the same id. */
+	setCustomObject(object) {
+		this.customObjects.set(object.id, object);
+		this.emit({ customObjectsUpdated: [object] });
+	}
+	setStrokeLocked(id, locked, by) {
+		const stroke = this.strokes.get(id);
+		if (!stroke) return;
+		applyItemLock(stroke, locked, by);
+		this.emit({ updated: [stroke] });
+	}
+	setStrokesLocked(ids, locked, by) {
+		const updated = [];
+		for (const id of ids) {
+			const stroke = this.strokes.get(id);
+			if (stroke) {
+				applyItemLock(stroke, locked, by);
+				updated.push(stroke);
+			}
+		}
+		if (updated.length) this.emit({ updated });
+	}
+	setNoteLocked(id, locked, by) {
+		const note = this.notes.get(id);
+		if (!note) return;
+		applyItemLock(note, locked, by);
+		this.emit({ notesUpdated: [note] });
+	}
+	setTextLocked(id, locked, by) {
+		const text = this.texts.get(id);
+		if (!text) return;
+		applyItemLock(text, locked, by);
+		this.emit({ textUpdated: [text] });
+	}
+	setTableLocked(id, locked, by) {
+		const table = this.tables.get(id);
+		if (!table) return;
+		applyItemLock(table, locked, by);
+		this.emit({ tablesUpdated: [table] });
+	}
+	setImageLocked(id, locked, by) {
+		const img = this.images.get(id);
+		if (!img) return;
+		applyItemLock(img, locked, by);
+		this.emit({ imagesUpdated: [img] });
+	}
+	setTimerLocked(id, locked, by) {
+		const timer = this.timers.get(id);
+		if (!timer) return;
+		applyItemLock(timer, locked, by);
+		this.emit({ timersUpdated: [timer] });
+	}
+	/** Replace all content (initial load). Does not touch `version`. */
+	replaceAll(strokes, notes, texts, tables = [], images = [], timers = [], customObjects = []) {
+		const removed = [...this.strokes.keys()];
+		const notesRemoved = [...this.notes.keys()];
+		const textRemoved = [...this.texts.keys()];
+		const tablesRemoved = [...this.tables.keys()];
+		const imagesRemoved = [...this.images.keys()];
+		const timersRemoved = [...this.timers.keys()];
+		const customObjectsRemoved = [...this.customObjects.keys()];
+		this.strokes.clear();
+		this.notes.clear();
+		this.texts.clear();
+		this.tables.clear();
+		this.images.clear();
+		this.timers.clear();
+		this.customObjects.clear();
+		this.bboxes.clear();
+		for (const stroke of strokes) {
+			this.strokes.set(stroke.id, stroke);
+			this.bboxes.set(stroke.id, computeBBox(stroke));
+		}
+		for (const note of notes) this.notes.set(note.id, note);
+		for (const text of texts) this.texts.set(text.id, text);
+		for (const table of tables) this.tables.set(table.id, table);
+		for (const img of images) this.images.set(img.id, img);
+		for (const timer of timers) this.timers.set(timer.id, timer);
+		for (const object of customObjects) this.customObjects.set(object.id, object);
+		this.emit({
+			added: strokes,
+			removed,
+			notesAdded: notes,
+			notesRemoved,
+			textAdded: texts,
+			textRemoved,
+			tablesAdded: tables,
+			tablesRemoved,
+			imagesAdded: images,
+			imagesRemoved,
+			timersAdded: timers,
+			timersRemoved,
+			customObjectsAdded: customObjects,
+			customObjectsRemoved
+		});
+	}
+	/** Apply incremental real-time change received from a remote collaborator over WebSocket. */
+	applyRemoteChange(change) {
+		const events = {};
+		if (change.added && change.added.length > 0) {
+			for (const stroke of change.added) {
+				this.strokes.set(stroke.id, stroke);
+				this.bboxes.set(stroke.id, computeBBox(stroke));
+			}
+			events.added = change.added;
+		}
+		if (change.removed && change.removed.length > 0) {
+			const removed = [];
+			for (const id of change.removed) if (this.strokes.delete(id)) {
+				this.bboxes.delete(id);
+				removed.push(id);
+			}
+			if (removed.length > 0) events.removed = removed;
+		}
+		if (change.updated && change.updated.length > 0) {
+			for (const stroke of change.updated) {
+				this.strokes.set(stroke.id, stroke);
+				this.bboxes.set(stroke.id, computeBBox(stroke));
+			}
+			events.updated = change.updated;
+		}
+		if (change.transformed && change.transformed.length > 0) {
+			for (const stroke of change.transformed) {
+				this.strokes.set(stroke.id, stroke);
+				this.bboxes.set(stroke.id, computeBBox(stroke));
+			}
+			events.transformed = change.transformed;
+		}
+		if (change.notesAdded && change.notesAdded.length > 0) {
+			for (const note of change.notesAdded) this.notes.set(note.id, note);
+			events.notesAdded = change.notesAdded;
+		}
+		if (change.notesRemoved && change.notesRemoved.length > 0) {
+			const notesRemoved = [];
+			for (const id of change.notesRemoved) if (this.notes.delete(id)) notesRemoved.push(id);
+			if (notesRemoved.length > 0) events.notesRemoved = notesRemoved;
+		}
+		if (change.notesUpdated && change.notesUpdated.length > 0) {
+			for (const note of change.notesUpdated) this.notes.set(note.id, note);
+			events.notesUpdated = change.notesUpdated;
+		}
+		if (change.textAdded && change.textAdded.length > 0) {
+			for (const t of change.textAdded) this.texts.set(t.id, t);
+			events.textAdded = change.textAdded;
+		}
+		if (change.textRemoved && change.textRemoved.length > 0) {
+			const textRemoved = [];
+			for (const id of change.textRemoved) if (this.texts.delete(id)) textRemoved.push(id);
+			if (textRemoved.length > 0) events.textRemoved = textRemoved;
+		}
+		if (change.textUpdated && change.textUpdated.length > 0) {
+			for (const t of change.textUpdated) this.texts.set(t.id, t);
+			events.textUpdated = change.textUpdated;
+		}
+		if (change.tablesAdded && change.tablesAdded.length > 0) {
+			for (const tbl of change.tablesAdded) this.tables.set(tbl.id, tbl);
+			events.tablesAdded = change.tablesAdded;
+		}
+		if (change.tablesRemoved && change.tablesRemoved.length > 0) {
+			const tablesRemoved = [];
+			for (const id of change.tablesRemoved) if (this.tables.delete(id)) tablesRemoved.push(id);
+			if (tablesRemoved.length > 0) events.tablesRemoved = tablesRemoved;
+		}
+		if (change.tablesUpdated && change.tablesUpdated.length > 0) {
+			for (const tbl of change.tablesUpdated) this.tables.set(tbl.id, tbl);
+			events.tablesUpdated = change.tablesUpdated;
+		}
+		if (change.imagesAdded && change.imagesAdded.length > 0) {
+			for (const img of change.imagesAdded) this.images.set(img.id, img);
+			events.imagesAdded = change.imagesAdded;
+		}
+		if (change.imagesRemoved && change.imagesRemoved.length > 0) {
+			const imagesRemoved = [];
+			for (const id of change.imagesRemoved) if (this.images.delete(id)) imagesRemoved.push(id);
+			if (imagesRemoved.length > 0) events.imagesRemoved = imagesRemoved;
+		}
+		if (change.imagesUpdated && change.imagesUpdated.length > 0) {
+			for (const img of change.imagesUpdated) this.images.set(img.id, img);
+			events.imagesUpdated = change.imagesUpdated;
+		}
+		if (change.timersAdded && change.timersAdded.length > 0) {
+			for (const timer of change.timersAdded) this.timers.set(timer.id, timer);
+			events.timersAdded = change.timersAdded;
+		}
+		if (change.timersRemoved && change.timersRemoved.length > 0) {
+			const timersRemoved = [];
+			for (const id of change.timersRemoved) if (this.timers.delete(id)) timersRemoved.push(id);
+			if (timersRemoved.length > 0) events.timersRemoved = timersRemoved;
+		}
+		if (change.timersUpdated && change.timersUpdated.length > 0) {
+			for (const timer of change.timersUpdated) this.timers.set(timer.id, timer);
+			events.timersUpdated = change.timersUpdated;
+		}
+		if (change.customObjectsAdded && change.customObjectsAdded.length > 0) {
+			for (const object of change.customObjectsAdded) this.customObjects.set(object.id, object);
+			events.customObjectsAdded = change.customObjectsAdded;
+		}
+		if (change.customObjectsRemoved && change.customObjectsRemoved.length > 0) {
+			const customObjectsRemoved = [];
+			for (const id of change.customObjectsRemoved) if (this.customObjects.delete(id)) customObjectsRemoved.push(id);
+			if (customObjectsRemoved.length > 0) events.customObjectsRemoved = customObjectsRemoved;
+		}
+		if (change.customObjectsUpdated && change.customObjectsUpdated.length > 0) {
+			for (const object of change.customObjectsUpdated) this.customObjects.set(object.id, object);
+			events.customObjectsUpdated = change.customObjectsUpdated;
+		}
+		this.emit(events);
+	}
+	toJSON() {
+		return {
+			schemaVersion: 1,
+			strokes: [...this.strokes.values()].map(serializeStroke),
+			notes: [...this.notes.values()].map(cloneNote),
+			textBlocks: [...this.texts.values()].map(cloneText),
+			tables: [...this.tables.values()].map(cloneTable),
+			images: [...this.images.values()].map(cloneImage),
+			timers: [...this.timers.values()].map(cloneTimer),
+			customObjects: [...this.customObjects.values()].map(cloneCustomObject)
+		};
+	}
+	static deserializeCustomObjects(data) {
+		return (data.customObjects ?? []).map(cloneCustomObject);
+	}
+	static deserializeImages(data) {
+		return (data.images ?? []).map(cloneImage);
+	}
+	static deserializeTimers(data) {
+		return (data.timers ?? []).map(cloneTimer);
+	}
+	static deserializeNotes(data) {
+		return (data.notes ?? []).map(cloneNote);
+	}
+	static deserializeTexts(data) {
+		return (data.textBlocks ?? []).map(cloneText);
+	}
+	static deserializeTables(data) {
+		return (data.tables ?? []).map(cloneTable);
+	}
+	static deserializeStrokes(data) {
+		const strokes = [];
+		for (const s of data.strokes) try {
+			strokes.push({
+				id: s.id,
+				color: s.color,
+				baseWidth: s.baseWidth,
+				...s.tool ? { tool: s.tool } : {},
+				points: s.points.map(parseStrokePoint),
+				...s.matrix ? { matrix: [...s.matrix] } : {},
+				...s.clusterId ? { clusterId: s.clusterId } : {},
+				...serializeLock(s)
+			});
+		} catch (err) {
+			console.error(`Skipping malformed stroke ${s?.id ?? "(no id)"}:`, err);
+		}
+		return strokes;
+	}
+	emit(change) {
+		const full = {
+			...EMPTY_CHANGE,
+			...change
+		};
+		for (const listener of this.listeners) listener(full);
+	}
+};
+/** World-space bbox: local point bounds pushed through the stroke matrix. */
+/**
+* A point should be the wire tuple [x,y,pressure,erase]. Also accepts the
+* live {x,y,pressure,erase?} object shape, which is what a stroke saved
+* through the buggy pre-fix ops path was persisted as — so boards written
+* during that window keep loading instead of throwing "object is not
+* iterable" forever. Write paths always produce tuples; this is read-side
+* tolerance for data already on disk, not a second accepted format.
+*/
+function parseStrokePoint(raw) {
+	if (Array.isArray(raw)) {
+		const [x, y, pressure, erase] = raw;
+		return {
+			x,
+			y,
+			pressure,
+			...erase > 0 ? { erase } : {}
+		};
+	}
+	if (raw && typeof raw === "object") {
+		const p = raw;
+		return {
+			x: p.x,
+			y: p.y,
+			pressure: p.pressure,
+			...p.erase ? { erase: p.erase } : {}
+		};
+	}
+	throw new Error("point is neither a tuple nor an object");
+}
+function computeBBox(stroke) {
+	const box = {
+		minX: Infinity,
+		minY: Infinity,
+		maxX: -Infinity,
+		maxY: -Infinity
+	};
+	for (const p of stroke.points) {
+		if (p.x < box.minX) box.minX = p.x;
+		if (p.y < box.minY) box.minY = p.y;
+		if (p.x > box.maxX) box.maxX = p.x;
+		if (p.y > box.maxY) box.maxY = p.y;
+	}
+	const m = stroke.matrix;
+	if (!m || isIdentity(m)) return box;
+	const world = {
+		minX: Infinity,
+		minY: Infinity,
+		maxX: -Infinity,
+		maxY: -Infinity
+	};
+	for (const corner of [
+		{
+			x: box.minX,
+			y: box.minY
+		},
+		{
+			x: box.maxX,
+			y: box.minY
+		},
+		{
+			x: box.minX,
+			y: box.maxY
+		},
+		{
+			x: box.maxX,
+			y: box.maxY
+		}
+	]) {
+		const p = apply(m, corner);
+		if (p.x < world.minX) world.minX = p.x;
+		if (p.y < world.minY) world.minY = p.y;
+		if (p.x > world.maxX) world.maxX = p.x;
+		if (p.y > world.maxY) world.maxY = p.y;
+	}
+	return world;
+}
+//#endregion
+//#region src/core-internal/commands.ts
+/** One drawing action — a marker stroke, or a shape's strokes as one unit. */
+var AddStrokesCommand = class {
+	constructor(strokes) {
+		this.label = "draw";
+		this.strokes = strokes.map(cloneStroke);
+	}
+	apply(doc) {
+		doc.addStrokes(this.strokes.map(cloneStroke));
+	}
+	revert(doc) {
+		doc.removeStrokes(this.strokes.map((s) => s.id));
+	}
+};
+/**
+* One eraser swipe (ADR 0003): `before` are the touched strokes as they were
+* at swipe start; `after` is what survived — smudged, split, or gone.
+*/
+var EraseCommand = class {
+	constructor(before, after) {
+		this.label = "erase";
+		this.before = before.map(cloneStroke);
+		this.after = after.map(cloneStroke);
+	}
+	apply(doc) {
+		doc.removeStrokes(this.before.map((s) => s.id));
+		doc.addStrokes(this.after.map(cloneStroke));
+	}
+	revert(doc) {
+		doc.removeStrokes(this.after.map((s) => s.id));
+		doc.addStrokes(this.before.map(cloneStroke));
+	}
+};
+/**
+* One transform gesture: `delta` composed onto each member's matrix
+* (`child = delta × child`, per §6.3 — never baked into geometry).
+*/
+var TransformCommand = class {
+	constructor(ids, delta) {
+		this.ids = ids;
+		this.delta = delta;
+		this.label = "transform selection";
+		this.inverse = invert(delta);
+	}
+	apply(doc) {
+		this.compose(doc, this.delta);
+	}
+	revert(doc) {
+		this.compose(doc, this.inverse);
+	}
+	compose(doc, m) {
+		const changed = [];
+		for (const id of this.ids) {
+			const stroke = doc.get(id);
+			if (!stroke) continue;
+			stroke.matrix = mul(m, stroke.matrix ?? [
+				1,
+				0,
+				0,
+				1,
+				0,
+				0
+			]);
+			changed.push(stroke);
+		}
+		if (changed.length) doc.transformStrokes(changed);
+	}
+};
+var AddNoteCommand = class {
+	constructor(note) {
+		this.label = "add note";
+		this.note = cloneNote(note);
+	}
+	apply(doc) {
+		doc.addNotes([cloneNote(this.note)]);
+	}
+	revert(doc) {
+		doc.removeNotes([this.note.id]);
+	}
+};
+/** Any note mutation — move, peel, recolor, retext — as before/after. */
+var UpdateNoteCommand = class {
+	constructor(before, after) {
+		this.label = "update note";
+		this.before = cloneNote(before);
+		this.after = cloneNote(after);
+	}
+	apply(doc) {
+		doc.setNote(cloneNote(this.after));
+	}
+	revert(doc) {
+		doc.setNote(cloneNote(this.before));
+	}
+};
+var DeleteNoteCommand = class {
+	constructor(note) {
+		this.label = "delete note";
+		this.note = cloneNote(note);
+	}
+	apply(doc) {
+		doc.removeNotes([this.note.id]);
+	}
+	revert(doc) {
+		doc.addNotes([cloneNote(this.note)]);
+	}
+};
+var AddTextCommand = class {
+	constructor(block) {
+		this.label = "add text";
+		this.block = cloneText(block);
+	}
+	apply(doc) {
+		doc.addTexts([cloneText(this.block)]);
+	}
+	revert(doc) {
+		doc.removeTexts([this.block.id]);
+	}
+};
+/** Any text-block mutation — move or retext — as before/after. */
+var UpdateTextCommand = class {
+	constructor(before, after) {
+		this.label = "update text";
+		this.before = cloneText(before);
+		this.after = cloneText(after);
+	}
+	apply(doc) {
+		doc.setText(cloneText(this.after));
+	}
+	revert(doc) {
+		doc.setText(cloneText(this.before));
+	}
+};
+var DeleteTextCommand = class {
+	constructor(block) {
+		this.label = "delete text";
+		this.block = cloneText(block);
+	}
+	apply(doc) {
+		doc.removeTexts([this.block.id]);
+	}
+	revert(doc) {
+		doc.addTexts([cloneText(this.block)]);
+	}
+};
+var AddTableCommand = class {
+	constructor(table) {
+		this.label = "add table";
+		this.table = cloneTable(table);
+	}
+	apply(doc) {
+		doc.addTables([cloneTable(this.table)]);
+	}
+	revert(doc) {
+		doc.removeTables([this.table.id]);
+	}
+};
+/** Any table mutation — move, resize, cell text edit — as before/after. */
+var UpdateTableCommand = class {
+	constructor(before, after) {
+		this.label = "update table";
+		this.before = cloneTable(before);
+		this.after = cloneTable(after);
+	}
+	apply(doc) {
+		doc.setTable(cloneTable(this.after));
+	}
+	revert(doc) {
+		doc.setTable(cloneTable(this.before));
+	}
+};
+var DeleteTableCommand = class {
+	constructor(table) {
+		this.label = "delete table";
+		this.table = cloneTable(table);
+	}
+	apply(doc) {
+		doc.removeTables([this.table.id]);
+	}
+	revert(doc) {
+		doc.addTables([cloneTable(this.table)]);
+	}
+};
+var DeleteStrokesCommand = class {
+	constructor(strokes) {
+		this.label = "delete selection";
+		this.strokes = strokes.map(cloneStroke);
+	}
+	apply(doc) {
+		doc.removeStrokes(this.strokes.map((s) => s.id));
+	}
+	revert(doc) {
+		doc.addStrokes(this.strokes.map(cloneStroke));
+	}
+};
+var AddImageCommand = class {
+	constructor(image) {
+		this.label = "add image";
+		this.image = cloneImage(image);
+	}
+	apply(doc) {
+		doc.addImages([cloneImage(this.image)]);
+	}
+	revert(doc) {
+		doc.removeImages([this.image.id]);
+	}
+};
+/** Any image mutation — move, resize — as before/after. */
+var UpdateImageCommand = class {
+	constructor(before, after) {
+		this.label = "update image";
+		this.before = cloneImage(before);
+		this.after = cloneImage(after);
+	}
+	apply(doc) {
+		doc.setImage(cloneImage(this.after));
+	}
+	revert(doc) {
+		doc.setImage(cloneImage(this.before));
+	}
+};
+var DeleteImageCommand = class {
+	constructor(image) {
+		this.label = "delete image";
+		this.image = cloneImage(image);
+	}
+	apply(doc) {
+		doc.removeImages([this.image.id]);
+	}
+	revert(doc) {
+		doc.addImages([cloneImage(this.image)]);
+	}
+};
+var AddTimerCommand = class {
+	constructor(timer) {
+		this.label = "add timer";
+		this.timer = cloneTimer(timer);
+	}
+	apply(doc) {
+		doc.addTimers([cloneTimer(this.timer)]);
+	}
+	revert(doc) {
+		doc.removeTimers([this.timer.id]);
+	}
+};
+var UpdateTimerCommand = class {
+	constructor(before, after) {
+		this.label = "update timer";
+		this.before = cloneTimer(before);
+		this.after = cloneTimer(after);
+	}
+	apply(doc) {
+		doc.setTimer(cloneTimer(this.after));
+	}
+	revert(doc) {
+		doc.setTimer(cloneTimer(this.before));
+	}
+};
+var DeleteTimerCommand = class {
+	constructor(timer) {
+		this.label = "delete timer";
+		this.timer = cloneTimer(timer);
+	}
+	apply(doc) {
+		doc.removeTimers([this.timer.id]);
+	}
+	revert(doc) {
+		doc.addTimers([cloneTimer(this.timer)]);
+	}
+};
+var LockItemsCommand = class {
+	constructor(targets, targetState, actor) {
+		this.label = "toggle lock";
+		this.targets = targets.map((t) => ({ ...t }));
+		this.targetState = targetState;
+		this.actor = actor ?? null;
+	}
+	apply(doc) {
+		const by = this.targetState ? this.actor : null;
+		for (const t of this.targets) this.applyLock(doc, t.type, t.id, this.targetState, by);
+	}
+	revert(doc) {
+		for (const t of this.targets) {
+			const by = t.locked && t.lockedBy ? {
+				userId: t.lockedBy,
+				name: t.lockedByName ?? ""
+			} : null;
+			this.applyLock(doc, t.type, t.id, t.locked, by);
+		}
+	}
+	applyLock(doc, type, id, locked, by) {
+		if (type === "stroke") doc.setStrokeLocked(id, locked, by);
+		else if (type === "note") doc.setNoteLocked(id, locked, by);
+		else if (type === "text") doc.setTextLocked(id, locked, by);
+		else if (type === "table") doc.setTableLocked(id, locked, by);
+		else if (type === "image") doc.setImageLocked(id, locked, by);
+		else if (type === "timer") doc.setTimerLocked(id, locked, by);
+	}
+};
+//#endregion
+//#region src/core-internal/history.ts
+var LIMIT = 200;
+var History = class {
+	constructor(doc) {
+		this.doc = doc;
+		this.undoStack = [];
+		this.redoStack = [];
+		this.onCommand = null;
+		this.undoing = false;
+	}
+	/** Apply a command and make it undoable. */
+	execute(command) {
+		command.apply(this.doc);
+		this.record(command);
+	}
+	/** Make an already-applied change undoable (e.g. a live erase swipe). */
+	record(command) {
+		this.undoStack.push(command);
+		if (this.undoStack.length > LIMIT) this.undoStack.shift();
+		this.redoStack.length = 0;
+		this.onCommand?.(command, "do");
+	}
+	/**
+	* True while a revert is in flight. Persistence reads this: re-adding
+	* something the author deleted must be sent as a `restore`, the only op the
+	* server lets past a tombstone (ADR 0006).
+	*/
+	get isUndoing() {
+		return this.undoing;
+	}
+	undo() {
+		const command = this.undoStack.pop();
+		if (!command) return;
+		this.undoing = true;
+		try {
+			command.revert(this.doc);
+		} finally {
+			this.undoing = false;
+		}
+		this.redoStack.push(command);
+		this.onCommand?.(command, "undo");
+	}
+	redo() {
+		const command = this.redoStack.pop();
+		if (!command) return;
+		command.apply(this.doc);
+		this.undoStack.push(command);
+		this.onCommand?.(command, "redo");
+	}
+	get canUndo() {
+		return this.undoStack.length > 0;
+	}
+	get canRedo() {
+		return this.redoStack.length > 0;
+	}
+	clear() {
+		this.undoStack.length = 0;
+		this.redoStack.length = 0;
+	}
+};
+//#endregion
+//#region src/core-internal/ops.ts
+var ADDED = [
+	["added", "strokes"],
+	["notesAdded", "notes"],
+	["textAdded", "textBlocks"],
+	["tablesAdded", "tables"],
+	["imagesAdded", "images"],
+	["timersAdded", "timers"],
+	["customObjectsAdded", "customObjects"]
+];
+var UPDATED = [
+	["updated", "strokes"],
+	["transformed", "strokes"],
+	["notesUpdated", "notes"],
+	["textUpdated", "textBlocks"],
+	["tablesUpdated", "tables"],
+	["imagesUpdated", "images"],
+	["timersUpdated", "timers"],
+	["customObjectsUpdated", "customObjects"]
+];
+var REMOVED = [
+	["removed", "strokes"],
+	["notesRemoved", "notes"],
+	["textRemoved", "textBlocks"],
+	["tablesRemoved", "tables"],
+	["imagesRemoved", "images"],
+	["timersRemoved", "timers"],
+	["customObjectsRemoved", "customObjects"]
+];
+function toWireObject(collection, object) {
+	return collection === "strokes" ? serializeStroke(object) : object;
+}
+/** Convert a canonical Document change into durable, renderer-neutral Ops. */
+function changeToOps(change, restoring = false) {
+	const ops = [];
+	const addKind = restoring ? "restore" : "upsert";
+	for (const [field, collection] of ADDED) for (const object of change[field] ?? []) ops.push({
+		kind: addKind,
+		collection,
+		object: toWireObject(collection, object)
+	});
+	for (const [field, collection] of UPDATED) for (const object of change[field] ?? []) ops.push({
+		kind: "upsert",
+		collection,
+		object: toWireObject(collection, object)
+	});
+	for (const [field, collection] of REMOVED) for (const id of change[field] ?? []) ops.push({
+		kind: "remove",
+		collection,
+		id
+	});
+	return ops;
+}
+//#endregion
+//#region src/core-internal/ribbonEdges.ts
+var MIN_WIDTH_FACTOR = .35;
+var END_TAPER = .55;
+function ribbonEdges(points, baseWidth) {
+	const pts = points.length === 1 ? [points[0], {
+		...points[0],
+		x: points[0].x + baseWidth * .05
+	}] : points;
+	const n = pts.length;
+	const out = new Array(n);
+	for (let i = 0; i < n; i++) {
+		const prev = pts[Math.max(0, i - 1)];
+		const next = pts[Math.min(n - 1, i + 1)];
+		let dx = next.x - prev.x;
+		let dy = next.y - prev.y;
+		const len = Math.hypot(dx, dy) || 1;
+		dx /= len;
+		dy /= len;
+		let width = baseWidth * (MIN_WIDTH_FACTOR + (1 - MIN_WIDTH_FACTOR) * pts[i].pressure);
+		if (i === 0 || i === n - 1) width *= END_TAPER;
+		const hw = width / 2;
+		out[i] = {
+			lx: pts[i].x - dy * hw,
+			ly: pts[i].y + dx * hw,
+			rx: pts[i].x + dy * hw,
+			ry: pts[i].y - dx * hw,
+			alpha: 1 - Math.min(1, pts[i].erase ?? 0)
+		};
+	}
+	return out;
+}
+//#endregion
+//#region src/core-internal/spatialIndex.ts
+var CELL = 8;
+var SpatialIndex = class {
+	constructor(doc) {
+		this.doc = doc;
+		this.cells = /* @__PURE__ */ new Map();
+		this.strokeCells = /* @__PURE__ */ new Map();
+		this.unsubscribe = doc.subscribe((change) => {
+			for (const id of change.removed) this.remove(id);
+			for (const stroke of change.added) this.insert(stroke.id);
+			for (const stroke of change.transformed) {
+				this.remove(stroke.id);
+				this.insert(stroke.id);
+			}
+		});
+		for (const stroke of doc.all()) this.insert(stroke.id);
+	}
+	/** Ids of strokes whose bbox may overlap the query rect. */
+	query(minX, minY, maxX, maxY) {
+		const result = /* @__PURE__ */ new Set();
+		for (const key of cellsOf({
+			minX,
+			minY,
+			maxX,
+			maxY
+		})) {
+			const bucket = this.cells.get(key);
+			if (bucket) for (const id of bucket) result.add(id);
+		}
+		return result;
+	}
+	dispose() {
+		this.unsubscribe();
+		this.cells.clear();
+		this.strokeCells.clear();
+	}
+	insert(id) {
+		const box = this.doc.bbox(id);
+		if (!box) return;
+		const keys = cellsOf(box);
+		this.strokeCells.set(id, keys);
+		for (const key of keys) {
+			let bucket = this.cells.get(key);
+			if (!bucket) {
+				bucket = /* @__PURE__ */ new Set();
+				this.cells.set(key, bucket);
+			}
+			bucket.add(id);
+		}
+	}
+	remove(id) {
+		const keys = this.strokeCells.get(id);
+		if (!keys) return;
+		this.strokeCells.delete(id);
+		for (const key of keys) {
+			const bucket = this.cells.get(key);
+			if (bucket) {
+				bucket.delete(id);
+				if (bucket.size === 0) this.cells.delete(key);
+			}
+		}
+	}
+};
+function cellsOf(box) {
+	const x0 = Math.floor(box.minX / CELL);
+	const x1 = Math.floor(box.maxX / CELL);
+	const y0 = Math.floor(box.minY / CELL);
+	const y1 = Math.floor(box.maxY / CELL);
+	const keys = [];
+	for (let x = x0; x <= x1; x++) for (let y = y0; y <= y1; y++) keys.push(`${x}:${y}`);
+	return keys;
+}
+//#endregion
+//#region src/core-internal/stamps.ts
+var STAMP_SIZE = 6;
+var STAMPS = [
+	{
+		kind: "star",
+		label: "Star",
+		glyph: "★"
+	},
+	{
+		kind: "check",
+		label: "Check",
+		glyph: "✓"
+	},
+	{
+		kind: "ship",
+		label: "Ship it",
+		glyph: "⚑"
+	},
+	{
+		kind: "heart",
+		label: "Heart",
+		glyph: "♥"
+	},
+	{
+		kind: "plus",
+		label: "Plus",
+		glyph: "+"
+	},
+	{
+		kind: "fire",
+		label: "Fire",
+		glyph: "!"
+	}
+];
+var SVG = {
+	star: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64"><polygon fill="#F59E0B" points="32,4 39.5,24.2 61,24.2 43.7,36.6 50.4,57 32,44.4 13.6,57 20.3,36.6 3,24.2 24.5,24.2"/></svg>`,
+	check: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64"><circle cx="32" cy="32" r="28" fill="#16A34A"/><path fill="none" stroke="#fff" stroke-width="6" stroke-linecap="round" stroke-linejoin="round" d="M18 33l10 10 18-20"/></svg>`,
+	ship: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64"><rect x="8" y="8" width="48" height="48" rx="10" fill="#2563EB"/><text x="32" y="30" text-anchor="middle" font-size="11" font-family="ui-rounded,sans-serif" font-weight="700" fill="#fff">SHIP</text><text x="32" y="46" text-anchor="middle" font-size="11" font-family="ui-rounded,sans-serif" font-weight="700" fill="#fff">IT</text></svg>`,
+	heart: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64"><path fill="#E11D48" d="M32 54S8 38 8 24c0-8 6-14 14-14 5 0 8 3 10 6 2-3 5-6 10-6 8 0 14 6 14 14 0 14-24 30-24 30z"/></svg>`,
+	plus: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64"><circle cx="32" cy="32" r="28" fill="#7C3AED"/><path fill="none" stroke="#fff" stroke-width="7" stroke-linecap="round" d="M32 18v28M18 32h28"/></svg>`,
+	fire: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64"><path fill="#EA580C" d="M32 6s4 10-2 18c6-2 14 4 14 16 0 12-8 20-14 20s-14-8-14-20c0-10 6-16 10-20 2 6 6 8 6-14z"/><path fill="#FDE047" d="M32 30s2 6-1 10c3-1 7 2 7 8 0 6-4 10-6 10s-6-4-6-10c0-5 3-8 5-10 1 3 3 4 3-8z"/></svg>`
+};
+function stampDataUrl(kind) {
+	return `data:image/svg+xml;utf8,${encodeURIComponent(SVG[kind])}`;
+}
+function isStampKind(value) {
+	return typeof value === "string" && STAMPS.some((s) => s.kind === value);
+}
+//#endregion
+//#region src/core-internal/presence.ts
+/** Keep beacons clear of typical chrome at the top and bottom of the Board. */
+var BEACON_INSET = {
+	top: 72,
+	right: 24,
+	bottom: 108,
+	left: 24
+};
+/**
+* If a collaborator is in the usable viewport, return their screen position.
+* If they are outside it, clamp to the nearest edge and return the angle a
+* chevron should point (screen space, radians, 0 = right, clockwise).
+*/
+function placePresenceBeacon(screen, viewport, inset = BEACON_INSET) {
+	const minX = inset.left;
+	const maxX = Math.max(inset.left, viewport.width - inset.right);
+	const minY = inset.top;
+	const maxY = Math.max(inset.top, viewport.height - inset.bottom);
+	if (screen.x >= minX && screen.x <= maxX && screen.y >= minY && screen.y <= maxY) return {
+		kind: "on-screen",
+		x: screen.x,
+		y: screen.y
+	};
+	const x = clamp(screen.x, minX, maxX);
+	const y = clamp(screen.y, minY, maxY);
+	return {
+		kind: "edge",
+		x,
+		y,
+		angle: Math.atan2(screen.y - y, screen.x - x)
+	};
+}
+function clamp(value, min, max) {
+	return Math.min(max, Math.max(min, value));
+}
+//#endregion
+//#region src/core-internal/svg.ts
+/** Matches the key light used by the board shader and note shadows. */
+var LIGHT = {
+	x: -.25,
+	y: .4,
+	z: .88
+};
+var MARGIN = 4;
+var NOTE_FONT_RATIO = 44 / 512;
+var NOTE_PAD_RATIO = 40 / 512;
+/**
+* `registry` is optional and only enables rendering Custom objects through
+* their own `describe()` — without it (or for an object whose extension
+* isn't in it), Custom objects still export via the standard fallback
+* placeholder (`fallback.bounds`/`label`), never silently dropped.
+*
+* `resolvedAssets` (ticket #23) maps an Asset reference to an already-
+* resolved `data:` URI — see `assetExport.ts`'s `exportDocumentSVGWithAssets`,
+* which is the only intended caller that ever passes one. Without it, every
+* `ref`-backed image (built-in or Custom `SceneImage`) renders its
+* placeholder instead of guessing at a URL; a legacy `src`-backed image is
+* unaffected either way.
+*/
+function documentToSVG(doc, now = 0, registry, resolvedAssets) {
+	const notes = doc.notes ?? [];
+	const texts = doc.textBlocks ?? [];
+	const tables = doc.tables ?? [];
+	const images = doc.images ?? [];
+	const timers = doc.timers ?? [];
+	const customObjects = doc.customObjects ?? [];
+	const bounds = contentBounds(doc.strokes, notes, texts, tables, images, timers, customObjects);
+	const view = `${fmt(bounds.minX)} ${fmt(bounds.minY)} ${fmt(bounds.width)} ${fmt(bounds.height)}`;
+	const defs = notes.map(noteShadowFilter).join("\n");
+	const highlights = doc.strokes.filter((s) => s.tool === "highlighter");
+	const ink = doc.strokes.filter((s) => s.tool !== "highlighter");
+	return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="${view}">\n<defs>\n${defs}\n</defs>\n${[
+		`<rect x="${fmt(bounds.minX)}" y="${fmt(bounds.minY)}" width="${fmt(bounds.width)}" height="${fmt(bounds.height)}" fill="${BOARD_COLOR}"/>`,
+		...images.map((image) => imageToElement(image, resolvedAssets)),
+		...tables.map(tableToGroup),
+		...highlights.flatMap(strokeToPaths),
+		...ink.flatMap(strokeToPaths),
+		...texts.map(textToElement),
+		...notes.map(noteToGroup),
+		...timers.map((timer) => timerToGroup(timer, now)),
+		...customObjects.map((object) => customObjectToGroup(object, registry, resolvedAssets))
+	].join("\n")}\n</svg>\n`;
+}
+/**
+* Renders through the object's own `describe()` when its extension is
+* registered; otherwise (or if `describe` throws) falls back to the
+* standard non-editable placeholder — see the spec's "unknown/invalid
+* Custom objects... display a standard non-editable fallback" rule.
+*/
+function customObjectToGroup(object, registry, resolvedAssets) {
+	const definition = registry?.objectType(object.type);
+	if (definition) try {
+		const scene = definition.describe(object, { selected: false });
+		return `<g data-id="${object.id}">${sceneNodeToSVG(scene, object.transform, resolvedAssets)}</g>`;
+	} catch {}
+	return fallbackToGroup(object);
+}
+/** Board-space matrix `m`, expressed as the equivalent SVG-space `matrix()`. */
+function svgTransformAttr(m) {
+	if (isIdentity(m)) return "";
+	return ` transform="matrix(${fmt(m[0])} ${fmt(-m[1])} ${fmt(-m[2])} ${fmt(m[3])} ${fmt(m[4])} ${fmt(-m[5])})"`;
+}
+/**
+* Walks one `BoardScene` node. Coordinates are object-local (pre-`parent`
+* transform, y grows the same "downward" direction `sceneGeometry.ts`'s
+* bounds walk assumes); `ScenePath` has no renderer yet (deferred, matching
+* `sceneGeometry.ts`'s own bounds walk) so it renders nothing rather than
+* guessing at SVG path-data semantics.
+*/
+function sceneNodeToSVG(node, parent, resolvedAssets) {
+	const m = node.transform ? mul(parent, node.transform) : parent;
+	const opacityAttr = node.opacity !== void 0 && node.opacity < 1 ? ` opacity="${fmt(node.opacity)}"` : "";
+	const transformAttr = svgTransformAttr(m);
+	switch (node.kind) {
+		case "rect": {
+			const svgY = -node.y - node.height;
+			const rx = node.cornerRadius ? ` rx="${fmt(node.cornerRadius)}"` : "";
+			const stroke = node.stroke ? ` stroke="${node.stroke}" stroke-width="${fmt(node.strokeWidth ?? .1)}"` : "";
+			return `<rect x="${fmt(node.x)}" y="${fmt(svgY)}" width="${fmt(node.width)}" height="${fmt(node.height)}" fill="${node.fill ?? "none"}"${rx}${stroke}${opacityAttr}${transformAttr}/>`;
+		}
+		case "text": {
+			const anchor = node.align === "center" ? ` text-anchor="middle"` : node.align === "end" ? ` text-anchor="end"` : "";
+			const tspans = node.text.split("\n").map((line, i) => `<tspan x="${fmt(node.x)}" y="${fmt(-node.y + node.fontSize * (.8 + 1.25 * i))}">${escapeXML(line)}</tspan>`).join("");
+			return `<text font-family="Inter, 'Segoe UI', sans-serif" font-size="${fmt(node.fontSize)}" font-weight="500" fill="${node.color}"${anchor}${opacityAttr}${transformAttr}>${tspans}</text>`;
+		}
+		case "ellipse": {
+			const stroke = node.stroke ? ` stroke="${node.stroke}" stroke-width="${fmt(node.strokeWidth ?? .1)}"` : "";
+			return `<ellipse cx="${fmt(node.cx)}" cy="${fmt(-node.cy)}" rx="${fmt(node.rx)}" ry="${fmt(node.ry)}" fill="${node.fill ?? "none"}"${stroke}${opacityAttr}${transformAttr}/>`;
+		}
+		case "image": {
+			const svgY = -node.y - node.height;
+			const dataUri = resolvedAssets?.get(node.ref);
+			if (!dataUri) {
+				const label = typeof node.alt === "string" ? node.alt : void 0;
+				return `<g${opacityAttr}${transformAttr}>${imagePlaceholderElement(node.x, svgY, node.width, node.height, label)}</g>`;
+			}
+			const preserveAspectRatio = node.fit === "contain" ? "xMidYMid meet" : node.fit === "cover" ? "xMidYMid slice" : "none";
+			return `<image href="${escapeXML(dataUri)}" x="${fmt(node.x)}" y="${fmt(svgY)}" width="${fmt(node.width)}" height="${fmt(node.height)}" preserveAspectRatio="${preserveAspectRatio}"${opacityAttr}${transformAttr}/>`;
+		}
+		case "group": return `<g${opacityAttr}${transformAttr}>${node.children.map((child) => sceneNodeToSVG(child, IDENTITY, resolvedAssets)).join("")}</g>`;
+		case "path": return "";
+	}
+}
+/**
+* A never-resolved or missing Asset's placeholder (ticket #23) — same
+* visual language as `fallbackToGroup`'s Custom-object fallback. Never
+* reveals the reference, a path, a URL, or a resolver error detail.
+*/
+function imagePlaceholderElement(x, y, width, height, label) {
+	const labelEl = label ? `<text x="${fmt(x + Math.min(.3, width * .1))}" y="${fmt(y + Math.min(1.2, height * .4))}" font-family="Inter, 'Segoe UI', sans-serif" font-size="${fmt(Math.min(1.1, height * .3))}" fill="#6B7280">${escapeXML(label)}</text>` : "";
+	return [`<rect x="${fmt(x)}" y="${fmt(y)}" width="${fmt(width)}" height="${fmt(height)}" fill="#F3F4F6" stroke="#9CA3AF" stroke-width="0.15" stroke-dasharray="0.3 0.3"/>`, labelEl].join("");
+}
+function fallbackToGroup(object) {
+	const b = object.fallback.bounds;
+	const svgY = -b.y - b.height;
+	const label = object.fallback.label;
+	const labelEl = label ? `<text x="${fmt(b.x + Math.min(.3, b.width * .1))}" y="${fmt(svgY + Math.min(1.2, b.height * .4))}" font-family="Inter, 'Segoe UI', sans-serif" font-size="${fmt(Math.min(1.1, b.height * .3))}" fill="#6B7280">${escapeXML(label)}</text>` : "";
+	return [
+		`<g data-id="${object.id}" data-fallback="true"${svgTransformAttr(object.transform)}>`,
+		`<rect x="${fmt(b.x)}" y="${fmt(svgY)}" width="${fmt(b.width)}" height="${fmt(b.height)}" fill="#F3F4F6" stroke="#9CA3AF" stroke-width="0.15" stroke-dasharray="0.3 0.3"/>`,
+		labelEl,
+		`</g>`
+	].join("");
+}
+/** One filled outline path per run of similar erasure; y flipped at emit. */
+function strokeToPaths(stroke) {
+	const edges = ribbonEdges(stroke.points.map(([x, y, pressure, erase]) => ({
+		x,
+		y,
+		pressure,
+		...erase > 0 ? { erase } : {}
+	})), stroke.baseWidth);
+	const transform = stroke.matrix ? ` transform="matrix(${fmt(stroke.matrix[0])} ${fmt(-stroke.matrix[1])} ${fmt(-stroke.matrix[2])} ${fmt(stroke.matrix[3])} ${fmt(stroke.matrix[4])} ${fmt(-stroke.matrix[5])})"` : "";
+	const baseOpacity = stroke.tool === "highlighter" ? .4 : 1;
+	const paths = [];
+	for (const run of splitByOpacity(edges)) {
+		if (run.edges.length < 2) continue;
+		const left = run.edges.map((e) => `${fmt(e.lx)} ${fmt(-e.ly)}`);
+		const right = [...run.edges].reverse().map((e) => `${fmt(e.rx)} ${fmt(-e.ry)}`);
+		const d = `M ${left.join(" L ")} L ${right.join(" L ")} Z`;
+		const opacity = run.opacity * baseOpacity;
+		const opacityAttr = opacity < 1 ? ` fill-opacity="${fmt(opacity)}"` : "";
+		paths.push(`<path data-id="${stroke.id}" d="${d}" fill="${stroke.color}"${opacityAttr}${transform}/>`);
+	}
+	return paths;
+}
+/** Consecutive edge points bucketed by quarter-step opacity; erased spans dropped. */
+function splitByOpacity(edges) {
+	const runs = [];
+	for (const edge of edges) {
+		const opacity = Math.round(edge.alpha * 4) / 4;
+		const current = runs[runs.length - 1];
+		if (current && current.opacity === opacity) current.edges.push(edge);
+		else runs.push({
+			opacity,
+			edges: [edge]
+		});
+	}
+	return runs.filter((r) => r.opacity > 0);
+}
+/** Typed text: top-left anchored, lines flow downward (svg +y after flip). */
+function textToElement(block) {
+	const top = -block.y;
+	const tspans = block.text.split("\n").map((line, i) => `<tspan x="${fmt(block.x)}" y="${fmt(top + block.fontSize * (.8 + 1.25 * i))}">${escapeXML(line)}</tspan>`).join("");
+	return `<text font-family="Inter, 'Segoe UI', sans-serif" font-size="${fmt(block.fontSize)}" font-weight="500" fill="${block.color}">${tspans}</text>`;
+}
+function noteShadowFilter(note) {
+	const dx = -LIGHT.x / LIGHT.z * note.zOffset;
+	const dy = LIGHT.y / LIGHT.z * note.zOffset;
+	const blur = (.35 + note.zOffset * .55) / 2;
+	const opacity = Math.max(.05, .26 - note.zOffset * .028);
+	return `<filter id="sh-${note.id}" x="-50%" y="-50%" width="200%" height="200%"><feDropShadow dx="${fmt(dx)}" dy="${fmt(dy)}" stdDeviation="${fmt(blur)}" flood-opacity="${fmt(opacity)}"/></filter>`;
+}
+function noteToGroup(note) {
+	const left = note.x - note.size / 2;
+	const top = -note.y - note.size / 2;
+	const fontSize = note.size * NOTE_FONT_RATIO;
+	const pad = note.size * NOTE_PAD_RATIO;
+	const tspans = wrapText(note.text, note.size - pad * 2, fontSize).map((line, i) => `<tspan x="${fmt(left + pad)}" y="${fmt(top + pad + fontSize * (.8 + 1.25 * i))}">${escapeXML(line)}</tspan>`).join("");
+	return [
+		`<g>`,
+		`<rect x="${fmt(left)}" y="${fmt(top)}" width="${fmt(note.size)}" height="${fmt(note.size)}" fill="${note.color}" filter="url(#sh-${note.id})"/>`,
+		`<text font-family="ui-rounded, 'Segoe UI', sans-serif" font-size="${fmt(fontSize)}" font-weight="500" fill="#37352F">${tspans}</text>`,
+		`</g>`
+	].join("");
+}
+/**
+* Deterministic word wrap with an average-glyph-width estimate — no DOM
+* text measurement, so the walk stays pure and testable.
+*/
+function wrapText(text, maxWidth, fontSize) {
+	const charWidth = fontSize * .55;
+	const maxChars = Math.max(1, Math.floor(maxWidth / charWidth));
+	const lines = [];
+	for (const paragraph of text.split("\n")) {
+		let line = "";
+		for (const word of paragraph.split(" ")) {
+			const attempt = line ? `${line} ${word}` : word;
+			if (attempt.length > maxChars && line) {
+				lines.push(line);
+				line = word;
+			} else line = attempt;
+		}
+		lines.push(line);
+	}
+	return lines;
+}
+function tableToGroup(table) {
+	const { width, height } = measureTable(table);
+	const left = table.x;
+	const top = -table.y;
+	const headerH = table.rowHeights[0] ?? height / table.rows;
+	const borderColor = table.color || "#D1D5DB";
+	const bgColor = table.backgroundColor || "#FFFFFF";
+	const elements = [];
+	elements.push(`<rect x="${fmt(left)}" y="${fmt(top)}" width="${fmt(width)}" height="${fmt(height)}" fill="${bgColor}" rx="0.5"/>`);
+	elements.push(`<rect x="${fmt(left)}" y="${fmt(top)}" width="${fmt(width)}" height="${fmt(headerH)}" fill="#F3F4F6" rx="0.5"/>`);
+	elements.push(`<rect x="${fmt(left)}" y="${fmt(top)}" width="${fmt(width)}" height="${fmt(height)}" fill="none" stroke="${borderColor}" stroke-width="0.3" rx="0.5"/>`);
+	let curY = 0;
+	for (let r = 0; r < table.rows - 1; r++) {
+		curY += table.rowHeights[r];
+		elements.push(`<line x1="${fmt(left)}" y1="${fmt(top + curY)}" x2="${fmt(left + width)}" y2="${fmt(top + curY)}" stroke="${borderColor}" stroke-width="0.2"/>`);
+	}
+	let curX = 0;
+	for (let c = 0; c < table.cols - 1; c++) {
+		curX += table.colWidths[c];
+		elements.push(`<line x1="${fmt(left + curX)}" y1="${fmt(top)}" x2="${fmt(left + curX)}" y2="${fmt(top + height)}" stroke="${borderColor}" stroke-width="0.2"/>`);
+	}
+	let cellTop = 0;
+	for (let r = 0; r < table.rows; r++) {
+		const rowH = table.rowHeights[r];
+		let cellLeft = 0;
+		for (let c = 0; c < table.cols; c++) {
+			const colW = table.colWidths[c];
+			const key = `${r},${c}`;
+			const text = table.cells[key] ?? "";
+			if (text) {
+				const padX = Math.min(.4, colW * .08);
+				const padY = Math.min(.3, rowH * .12);
+				const fontSize = Math.min(1.25, rowH * .45);
+				const weight = r === 0 ? "bold" : "500";
+				const color = r === 0 ? "#111827" : table.color ?? "#374151";
+				elements.push(`<text x="${fmt(left + cellLeft + padX)}" y="${fmt(top + cellTop + padY + fontSize * .8)}" font-family="Inter, 'Segoe UI', sans-serif" font-size="${fmt(fontSize)}" font-weight="${weight}" fill="${color}">${escapeXML(text)}</text>`);
+			}
+			cellLeft += colW;
+		}
+		cellTop += rowH;
+	}
+	return `<g data-id="${table.id}">\n${elements.join("\n")}\n</g>`;
+}
+function timerToGroup(timer, now) {
+	const r = timer.size / 2;
+	const cx = timer.x;
+	const cy = -timer.y;
+	const label = formatTimer(timerRemaining(timer, now));
+	return [
+		`<g data-id="${timer.id}">`,
+		`<circle cx="${fmt(cx + .4)}" cy="${fmt(cy + .4)}" r="${fmt(r)}" fill="#000" fill-opacity="0.12"/>`,
+		`<circle cx="${fmt(cx)}" cy="${fmt(cy)}" r="${fmt(r)}" fill="#E11D48"/>`,
+		`<circle cx="${fmt(cx)}" cy="${fmt(cy)}" r="${fmt(r * .72)}" fill="#FAFAF9"/>`,
+		`<text x="${fmt(cx)}" y="${fmt(cy + timer.size * .08)}" text-anchor="middle" font-family="ui-rounded, 'Segoe UI', sans-serif" font-size="${fmt(timer.size * .22)}" font-weight="700" fill="#1C1917">${label}</text>`,
+		`</g>`
+	].join("");
+}
+function imageToElement(image, resolvedAssets) {
+	const left = image.x - image.width / 2;
+	const top = -image.y - image.height / 2;
+	if (image.ref) {
+		const dataUri = resolvedAssets?.get(image.ref);
+		if (!dataUri) return `<g data-id="${image.id}" data-fallback="true">${imagePlaceholderElement(left, top, image.width, image.height, image.name)}</g>`;
+		return `<image data-id="${image.id}" href="${escapeXML(dataUri)}" x="${fmt(left)}" y="${fmt(top)}" width="${fmt(image.width)}" height="${fmt(image.height)}" preserveAspectRatio="none"/>`;
+	}
+	return `<image href="${escapeXML(image.src)}" x="${fmt(left)}" y="${fmt(top)}" width="${fmt(image.width)}" height="${fmt(image.height)}" preserveAspectRatio="none"/>`;
+}
+function contentBounds(strokes, notes, texts, tables = [], images = [], timers = [], customObjects = []) {
+	let minX = Infinity;
+	let minY = Infinity;
+	let maxX = -Infinity;
+	let maxY = -Infinity;
+	const grow = (x, y) => {
+		if (x < minX) minX = x;
+		if (y < minY) minY = y;
+		if (x > maxX) maxX = x;
+		if (y > maxY) maxY = y;
+	};
+	for (const s of strokes) {
+		const m = s.matrix;
+		for (const [x, y] of s.points) grow(m ? m[0] * x + m[2] * y + m[4] : x, -(m ? m[1] * x + m[3] * y + m[5] : y));
+	}
+	for (const n of notes) {
+		grow(n.x - n.size / 2, -n.y - n.size / 2);
+		grow(n.x + n.size / 2, -n.y + n.size / 2);
+	}
+	for (const t of texts) {
+		const { width, height } = measureTextBlock(t.text, t.fontSize);
+		grow(t.x, -t.y);
+		grow(t.x + width, -t.y + height);
+	}
+	for (const table of tables) {
+		const { width, height } = measureTable(table);
+		grow(table.x, -table.y);
+		grow(table.x + width, -table.y + height);
+	}
+	for (const img of images) {
+		grow(img.x - img.width / 2, -img.y - img.height / 2);
+		grow(img.x + img.width / 2, -img.y + img.height / 2);
+	}
+	for (const timer of timers) {
+		const half = timer.size / 2;
+		grow(timer.x - half, -timer.y - half);
+		grow(timer.x + half, -timer.y + half);
+	}
+	for (const object of customObjects) {
+		const b = object.fallback.bounds;
+		for (const corner of [
+			{
+				x: b.x,
+				y: b.y
+			},
+			{
+				x: b.x + b.width,
+				y: b.y
+			},
+			{
+				x: b.x,
+				y: b.y + b.height
+			},
+			{
+				x: b.x + b.width,
+				y: b.y + b.height
+			}
+		]) {
+			const p = apply(object.transform, corner);
+			grow(p.x, -p.y);
+		}
+	}
+	if (minX > maxX) return {
+		minX: 0,
+		minY: 0,
+		width: 100,
+		height: 100
+	};
+	return {
+		minX: minX - MARGIN,
+		minY: minY - MARGIN,
+		width: maxX - minX + MARGIN * 2,
+		height: maxY - minY + MARGIN * 2
+	};
+}
+function escapeXML(s) {
+	return s.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;");
+}
+function fmt(n) {
+	return String(Math.round(n * 100) / 100);
+}
+//#endregion
+//#region src/core.ts
+var SDK_PACKAGE_NAME = "@scrawl-board/board";
+var SDK_DEVELOPMENT_VERSION = "0.0.0-development";
+//#endregion
+export { AddImageCommand, AddNoteCommand, AddStrokesCommand, AddTableCommand, AddTextCommand, AddTimerCommand, BEACON_INSET, BOARD_COLOR, BoardDocument, CURRENT_DOCUMENT_SCHEMA_VERSION, ClusterStore, DeleteImageCommand, DeleteNoteCommand, DeleteStrokesCommand, DeleteTableCommand, DeleteTextCommand, DeleteTimerCommand, DocumentRecoveryError, END_TAPER, ERASE_THRESHOLD, EraseCommand, FOG_COLOR, HIGHLIGHT_COLORS, History, IDENTITY, INK_COLORS, LockItemsCommand, MIN_WIDTH_FACTOR, NOTE_COLORS, NOTE_DEFAULT_SIZE, NOTE_DEFAULT_Z, NOTE_MAX_Z, NOTE_MIN_Z, NOTE_PEEL_STEP, SDK_DEVELOPMENT_VERSION, SDK_PACKAGE_NAME, STAMPS, STAMP_SIZE, SpatialIndex, TABLE_DEFAULT_CELL_HEIGHT, TABLE_DEFAULT_CELL_WIDTH, TABLE_DEFAULT_FONT_SIZE, TEXT_DEFAULT_SIZE, TIMER_DEFAULT_DURATION_MS, TIMER_DEFAULT_SIZE, TIMER_PRESETS_MS, TransformCommand, UpdateImageCommand, UpdateNoteCommand, UpdateTableCommand, UpdateTextCommand, UpdateTimerCommand, apply, applyItemLock, avgScale, canUnlockItem, changeToOps, cloneImage, cloneNote, cloneStroke, cloneTable, cloneText, cloneTimer, documentId, documentToSVG, formatTimer, invert, isIdentity, isStampKind, loadDocumentBytes, measureTable, measureTextBlock, migrateDocument, mul, pauseTimer, placePresenceBeacon, ribbonEdges, rotationAbout, scalingAbout, searchBoard, serializeDocument, serializeLock, serializeStroke, setTimerDuration, stampDataUrl, startTimer, strokeId, timerExpired, timerRemaining, toggleTimer, translation };