@inkbar/core 0.3.0 → 0.4.0

package/dist/signatures-DF2VmNVa.mjs

@@ -0,0 +1,3922 @@
+import { z } from "zod";
+import { v7 } from "uuid";
+//#region src/model/errors.ts
+var InkError = class extends Error {
+	name = "InkError";
+	code;
+	details;
+	constructor(code, message, details = {}, cause) {
+		super(message, cause === void 0 ? void 0 : { cause });
+		this.code = code;
+		this.details = details;
+	}
+};
+function isInkError(value) {
+	return value instanceof InkError || typeof value === "object" && value !== null && value.name === "InkError";
+}
+//#endregion
+//#region src/model/events.ts
+var Emitter = class {
+	listeners = /* @__PURE__ */ new Map();
+	on(event, fn) {
+		let set = this.listeners.get(event);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			this.listeners.set(event, set);
+		}
+		set.add(fn);
+		return () => {
+			set?.delete(fn);
+		};
+	}
+	emit(event, payload) {
+		const set = this.listeners.get(event);
+		if (!set) return;
+		for (const fn of [...set]) fn(payload);
+	}
+	clear() {
+		this.listeners.clear();
+	}
+};
+//#endregion
+//#region src/model/geometry.ts
+function approxEqual(a, b, eps = .01) {
+	return Math.abs(a - b) <= eps;
+}
+function rectFromPoints(a, b) {
+	return {
+		x: Math.min(a.x, b.x),
+		y: Math.min(a.y, b.y),
+		width: Math.abs(a.x - b.x),
+		height: Math.abs(a.y - b.y)
+	};
+}
+function rectFromQuad(q) {
+	const xs = [
+		q.p1.x,
+		q.p2.x,
+		q.p3.x,
+		q.p4.x
+	];
+	const ys = [
+		q.p1.y,
+		q.p2.y,
+		q.p3.y,
+		q.p4.y
+	];
+	const x = Math.min(...xs);
+	const y = Math.min(...ys);
+	return {
+		x,
+		y,
+		width: Math.max(...xs) - x,
+		height: Math.max(...ys) - y
+	};
+}
+function quadFromRect(r) {
+	const top = r.y + r.height;
+	const right = r.x + r.width;
+	return {
+		p1: {
+			x: r.x,
+			y: top
+		},
+		p2: {
+			x: right,
+			y: top
+		},
+		p3: {
+			x: r.x,
+			y: r.y
+		},
+		p4: {
+			x: right,
+			y: r.y
+		}
+	};
+}
+function unionRects(rects) {
+	if (rects.length === 0) throw new RangeError("unionRects needs at least one rect");
+	let x1 = Infinity;
+	let y1 = Infinity;
+	let x2 = -Infinity;
+	let y2 = -Infinity;
+	for (const r of rects) {
+		x1 = Math.min(x1, r.x);
+		y1 = Math.min(y1, r.y);
+		x2 = Math.max(x2, r.x + r.width);
+		y2 = Math.max(y2, r.y + r.height);
+	}
+	return {
+		x: x1,
+		y: y1,
+		width: x2 - x1,
+		height: y2 - y1
+	};
+}
+function rectsIntersect(a, b) {
+	return a.x < b.x + b.width && b.x < a.x + a.width && a.y < b.y + b.height && b.y < a.y + a.height;
+}
+function rectContainsPoint(r, p) {
+	return p.x >= r.x && p.x <= r.x + r.width && p.y >= r.y && p.y <= r.y + r.height;
+}
+function translateRect(r, dx, dy) {
+	return {
+		x: r.x + dx,
+		y: r.y + dy,
+		width: r.width,
+		height: r.height
+	};
+}
+function translateQuad(q, dx, dy) {
+	const t = (p) => ({
+		x: p.x + dx,
+		y: p.y + dy
+	});
+	return {
+		p1: t(q.p1),
+		p2: t(q.p2),
+		p3: t(q.p3),
+		p4: t(q.p4)
+	};
+}
+function applyMatrix(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 invertMatrix(m) {
+	const det = m[0] * m[3] - m[1] * m[2];
+	if (det === 0) throw new RangeError("matrix is not invertible");
+	return [
+		m[3] / det,
+		-m[1] / det,
+		-m[2] / det,
+		m[0] / det,
+		(m[2] * m[5] - m[3] * m[4]) / det,
+		(m[1] * m[4] - m[0] * m[5]) / det
+	];
+}
+/** Returns the matrix that applies `a` first, then `b`. */
+function multiplyMatrix(a, b) {
+	return [
+		a[0] * b[0] + a[1] * b[2],
+		a[0] * b[1] + a[1] * b[3],
+		a[2] * b[0] + a[3] * b[2],
+		a[2] * b[1] + a[3] * b[3],
+		a[4] * b[0] + a[5] * b[2] + b[4],
+		a[4] * b[1] + a[5] * b[3] + b[5]
+	];
+}
+function pointsFromFlat(flat) {
+	const out = [];
+	for (let i = 0; i + 1 < flat.length; i += 2) out.push({
+		x: flat[i],
+		y: flat[i + 1]
+	});
+	return out;
+}
+/** Eight numbers per quad, in PDF.js's normalised order. Trailing partial quads are dropped. */
+function quadsFromFlat(flat) {
+	const pts = pointsFromFlat(flat);
+	const out = [];
+	for (let i = 0; i + 3 < pts.length; i += 4) out.push({
+		p1: pts[i],
+		p2: pts[i + 1],
+		p3: pts[i + 2],
+		p4: pts[i + 3]
+	});
+	return out;
+}
+//#endregion
+//#region src/model/readable.ts
+function writable(initial) {
+	let value = initial;
+	const subs = /* @__PURE__ */ new Set();
+	const set = (next) => {
+		if (Object.is(next, value)) return;
+		value = next;
+		for (const fn of [...subs]) fn(value);
+	};
+	return {
+		get: () => value,
+		set,
+		update(fn) {
+			set(fn(value));
+		},
+		subscribe(fn) {
+			subs.add(fn);
+			return () => {
+				subs.delete(fn);
+			};
+		}
+	};
+}
+/**
+* A readable computed from `source`. It subscribes to the source only while it has
+* subscribers of its own, so an unobserved derived value holds no reference to the source.
+*/
+function derived(source, fn) {
+	const subs = /* @__PURE__ */ new Set();
+	let cached;
+	let stopSource;
+	const onSource = (v) => {
+		const next = fn(v);
+		if (Object.is(next, cached)) return;
+		cached = next;
+		for (const sub of [...subs]) sub(next);
+	};
+	return {
+		get: () => stopSource ? cached : fn(source.get()),
+		subscribe(sub) {
+			if (!stopSource) {
+				cached = fn(source.get());
+				stopSource = source.subscribe(onSource);
+			}
+			subs.add(sub);
+			return () => {
+				if (!subs.delete(sub) || subs.size > 0) return;
+				stopSource?.();
+				stopSource = void 0;
+			};
+		}
+	};
+}
+function readonly(w) {
+	return {
+		get: () => w.get(),
+		subscribe: (fn) => w.subscribe(fn)
+	};
+}
+//#endregion
+//#region src/model/selection.ts
+const union = (a, b) => {
+	const x = Math.min(a.x, b.x);
+	const y = Math.min(a.y, b.y);
+	return {
+		x,
+		y,
+		width: Math.max(a.x + a.width, b.x + b.width) - x,
+		height: Math.max(a.y + a.height, b.y + b.height) - y
+	};
+};
+const centreY = (r) => r.y + r.height / 2;
+function median(values) {
+	const sorted = [...values].sort((a, b) => a - b);
+	const mid = sorted.length >> 1;
+	return sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+}
+/**
+* Merges glyph boxes that share a line into one quad per run, ordered top to bottom (by
+* vertical centre) then left to right. Boxes whose vertical centres are within `tolerance`
+* points count as the same line; boxes with no area are dropped. Within a line, a horizontal
+* gap wider than `gap` points (default 1.5 × the line's median box height) starts a new run,
+* so text selected across a column gutter yields one quad per column. Pure user-space maths.
+*/
+function mergeLineRects(rects, tolerance = 2, gap) {
+	const lines = [];
+	for (const r of rects) {
+		if (!(r.width > 0 && r.height > 0)) continue;
+		const line = lines.find((l) => Math.abs(centreY(l.bounds) - centreY(r)) <= tolerance);
+		if (!line) {
+			lines.push({
+				bounds: { ...r },
+				boxes: [r]
+			});
+			continue;
+		}
+		line.bounds = union(line.bounds, r);
+		line.boxes.push(r);
+	}
+	const runs = [];
+	for (const line of lines) {
+		const maxGap = gap ?? 1.5 * median(line.boxes.map((b) => b.height));
+		const boxes = [...line.boxes].sort((a, b) => a.x - b.x);
+		let run = { ...boxes[0] };
+		for (const b of boxes.slice(1)) if (b.x - (run.x + run.width) > maxGap) {
+			runs.push(run);
+			run = { ...b };
+		} else run = union(run, b);
+		runs.push(run);
+	}
+	runs.sort((a, b) => centreY(b) - centreY(a) || a.x - b.x);
+	return runs.map(quadFromRect);
+}
+//#endregion
+//#region src/pdfjs/load.ts
+const REQUIRED = [
+	"worker",
+	"cMaps",
+	"standardFonts",
+	"wasm"
+];
+function assertAssets(value) {
+	const record = typeof value === "object" && value !== null ? value : {};
+	const missing = REQUIRED.filter((k) => typeof record[k] !== "string" || record[k] === "");
+	if (value === void 0 || value === null || missing.length > 0) throw new InkError("AssetConfigMissing", "openDocument needs an `assets` option naming the PDF.js worker, cMaps, standardFonts and wasm locations. Vite users: add the @inkbar/core/vite plugin and pass `assets` from \"virtual:inkbar-assets\".", { missing: value == null ? [...REQUIRED] : missing });
+}
+let modulePromise;
+let configuredWorker;
+/**
+* Loads PDF.js once. `#pdfjs` resolves to the legacy build in Node and the
+* modern build everywhere else (see package.json "imports").
+*/
+async function loadPdfjs(assets) {
+	assertAssets(assets);
+	modulePromise ??= import("#pdfjs").catch((cause) => {
+		modulePromise = void 0;
+		throw new InkError("AssetLoadFailed", "PDF.js could not be imported", { url: assets.worker }, cause);
+	});
+	const pdfjs = await modulePromise;
+	if (configuredWorker === void 0) {
+		pdfjs.GlobalWorkerOptions.workerSrc = assets.worker;
+		configuredWorker = assets.worker;
+	} else if (configuredWorker !== assets.worker) throw new InkError("AssetConfigMissing", "PDF.js worker URL cannot change after the first document is opened", {
+		configured: configuredWorker,
+		requested: assets.worker
+	});
+	return pdfjs;
+}
+async function openProxy(pdfjs, bytes, options) {
+	const { assets, password, verbosity } = options;
+	const task = pdfjs.getDocument({
+		data: bytes,
+		...password !== void 0 ? { password } : {},
+		...verbosity !== void 0 ? { verbosity } : {},
+		cMapUrl: assets.cMaps,
+		cMapPacked: true,
+		standardFontDataUrl: assets.standardFonts,
+		wasmUrl: assets.wasm,
+		...assets.icc !== void 0 ? { iccUrl: assets.icc } : {}
+	});
+	try {
+		return {
+			task,
+			proxy: await task.promise
+		};
+	} catch (cause) {
+		try {
+			await task.destroy();
+		} catch {}
+		throw mapLoadError(cause, {
+			assets,
+			passwordSupplied: password !== void 0
+		});
+	}
+}
+/** `PasswordResponses` values from PDF.js (`NEED_PASSWORD = 1`, `INCORRECT_PASSWORD = 2`). */
+const INCORRECT_PASSWORD = 2;
+/**
+* PDF.js raises these from `task.promise` when the worker script cannot be
+* imported (in browsers after its real Worker fails and the fake-worker
+* fallback also fails to import `workerSrc`).
+*/
+const WORKER_FAILURE = /Setting up fake worker failed|No "GlobalWorkerOptions\.workerSrc" specified/i;
+/**
+* Only the worker is mapped here. CMap, standard-font and wasm failures are
+* PDF.js warnings with fallbacks that never reject the open promise, so they
+* cannot be detected at open time.
+*
+* PDF.js 6 exports only some exception classes (`PasswordException`,
+* `InvalidPDFException`, `ResponseException`, `AbortException`), and errors
+* that cross the worker boundary are rebuilt by name, so match on `name`.
+* Inputs here are always in-memory bytes, so there is no fetch to fail:
+* every non-password failure means the bytes are not a usable PDF.
+*/
+function mapLoadError(cause, context) {
+	const { assets, passwordSupplied = false } = context;
+	const name = cause?.name;
+	const rawMessage = cause?.message;
+	const message = typeof rawMessage === "string" && rawMessage !== "" ? rawMessage : "Unknown PDF.js error";
+	if (WORKER_FAILURE.test(message)) return new InkError("AssetLoadFailed", "The PDF.js worker could not be loaded. Check the `assets.worker` URL.", { url: assets.worker }, cause);
+	if (name === "PasswordException") {
+		const wrong = cause.code === INCORRECT_PASSWORD;
+		return new InkError("PasswordRequired", wrong ? "The password is incorrect" : "This document is encrypted and needs a password", {
+			passwordSupplied,
+			incorrect: wrong
+		}, cause);
+	}
+	return new InkError("InvalidPdf", message, {
+		pdfjsErrorName: typeof name === "string" ? name : void 0,
+		pdfjsMessage: message
+	}, cause);
+}
+//#endregion
+//#region src/model/annotations/defaults.ts
+const COLORS = {
+	highlight: "#F2C230",
+	underline: "#2B5A9E",
+	strikeout: "#C0392B",
+	squiggly: "#1F7A4D",
+	text: "#F2C230",
+	freetext: "#151820",
+	square: "#C0392B",
+	circle: "#C0392B",
+	line: "#151820",
+	polyline: "#151820",
+	polygon: "#151820",
+	ink: "#151820",
+	stamp: "#151820",
+	loupe: "#151820",
+	mask: "#000000",
+	redact: "#C0392B"
+};
+/**
+* Suggested-redaction colours, strengthening with confidence: amber for low, orange for
+* medium, the redaction red for high.
+*/
+const SUGGESTION_COLORS = {
+	low: "#D4A017",
+	medium: "#E67E22",
+	high: "#C0392B"
+};
+const staticDefaults = {
+	color: (type) => COLORS[type],
+	fill: () => "#000000",
+	opacity: (type) => type === "highlight" ? .4 : 1,
+	suggestion: (bucket) => SUGGESTION_COLORS[bucket]
+};
+const VARIABLES = {
+	highlight: "--ink-highlight",
+	underline: "--ink-underline",
+	strikeout: "--ink-strikeout",
+	squiggly: "--ink-squiggly",
+	text: "--ink-note",
+	freetext: "--ink-free-text",
+	square: "--ink-shape",
+	circle: "--ink-shape",
+	line: "--ink-shape",
+	polyline: "--ink-shape",
+	polygon: "--ink-shape",
+	ink: "--ink-ink",
+	stamp: "--ink-ink",
+	loupe: "--ink-shape",
+	mask: "--ink-mask",
+	redact: "--ink-redact"
+};
+/** Resolves default colours from CSS custom properties on `el`, falling back to `staticDefaults`. */
+function cssVariableDefaults(el) {
+	const read = (name) => {
+		const view = el.ownerDocument.defaultView;
+		if (!view) return void 0;
+		return normalizeColor(view.getComputedStyle(el).getPropertyValue(name));
+	};
+	return {
+		color: (type) => read(VARIABLES[type]) ?? staticDefaults.color(type),
+		fill: () => read("--ink-redact-fill") ?? staticDefaults.fill(),
+		opacity: (type) => staticDefaults.opacity(type),
+		suggestion: (bucket) => read(`--ink-suggestion-${bucket}`) ?? staticDefaults.suggestion(bucket)
+	};
+}
+/** Accepts `#rgb`, `#rrggbb`, `rgb(r, g, b)` and `rgb(r g b)`; returns `#RRGGBB` or undefined. */
+function normalizeColor(value) {
+	const v = value.trim();
+	const short = /^#([0-9a-f])([0-9a-f])([0-9a-f])$/i.exec(v);
+	if (short) {
+		const [, r = "", g = "", b = ""] = short;
+		return `#${r}${r}${g}${g}${b}${b}`.toUpperCase();
+	}
+	if (/^#[0-9a-f]{6}$/i.test(v)) return v.toUpperCase();
+	const rgb = /^rgba?\(\s*(\d{1,3})[\s,]+(\d{1,3})[\s,]+(\d{1,3})/i.exec(v);
+	if (rgb) return `#${[
+		rgb[1],
+		rgb[2],
+		rgb[3]
+	].map((n) => Math.min(255, Number(n)).toString(16).padStart(2, "0")).join("")}`.toUpperCase();
+}
+//#endregion
+//#region src/model/pdf-date.ts
+/** Parses a PDF date string (`D:YYYYMMDDHHmmSSOHH'mm'`) into ISO 8601. Returns `fallback` on anything unparseable. */
+function parsePdfDate(value, fallback) {
+	if (!value) return fallback;
+	const m = /^(?:D:)?(\d{4})(\d{2})?(\d{2})?(\d{2})?(\d{2})?(\d{2})?(Z|[+-]\d{2}(?:'\d{2}')?)?/.exec(value.trim());
+	if (!m) return fallback;
+	const [, y, mo = "01", d = "01", h = "00", mi = "00", s = "00", zone] = m;
+	let offsetMinutes = 0;
+	if (zone && zone !== "Z") {
+		const sign = zone.startsWith("-") ? -1 : 1;
+		const zh = Number(zone.slice(1, 3));
+		const zm = Number(zone.slice(4, 6) || 0);
+		offsetMinutes = sign * (zh * 60 + zm);
+	}
+	const utc = Date.UTC(Number(y), Number(mo) - 1, Number(d), Number(h), Number(mi), Number(s)) - offsetMinutes * 6e4;
+	if (Number.isNaN(utc)) return fallback;
+	return new Date(utc).toISOString();
+}
+//#endregion
+//#region src/model/annotations/pdf-names.ts
+/**
+* A PDF name: a non-empty run of regular characters, so no whitespace and none of the
+* delimiters `( ) < > [ ] { } / %`.
+*/
+const PDF_NAME = /^[^\s()<>[\]{}/%]+$/;
+/**
+* A set of PDF names Inkbar knows that stays open: any other valid PDF name loads, is kept and
+* is written back unchanged. The output type keeps autocomplete for the known values.
+*/
+function pdfNameSet(known) {
+	return z.union([z.enum(known), z.string().regex(PDF_NAME, "expected a PDF name")]).describe(`One of ${known.join(", ")}. Any other PDF name is allowed and kept unchanged.`);
+}
+/** Line ending styles (PDF `/LE`). */
+const LINE_ENDINGS = [
+	"None",
+	"Square",
+	"Circle",
+	"Diamond",
+	"OpenArrow",
+	"ClosedArrow",
+	"Butt",
+	"ROpenArrow",
+	"RClosedArrow",
+	"Slash"
+];
+/** Note icons (PDF `/Name` on a text annotation). */
+const NOTE_ICONS = [
+	"Comment",
+	"Note",
+	"Help",
+	"Insert",
+	"Key",
+	"NewParagraph",
+	"Paragraph"
+];
+/** Annotation intents (PDF `/IT`). */
+const INTENTS = [
+	"FreeText",
+	"FreeTextCallout",
+	"FreeTextTypeWriter",
+	"LineArrow",
+	"LineDimension",
+	"PolygonCloud",
+	"PolygonDimension",
+	"PolyLineDimension"
+];
+/** True when `v` is one of the values in `list`. */
+function isKnown(list, v) {
+	return list.includes(v);
+}
+//#endregion
+//#region src/model/annotations/callout.ts
+/**
+* The insets from a free text's `rect` to its text box, in points (PDF `/RD`, XFDF `fringe`,
+* both in this order).
+*/
+const FringeSchema = z.object({
+	left: z.number().nonnegative(),
+	top: z.number().nonnegative(),
+	right: z.number().nonnegative(),
+	bottom: z.number().nonnegative()
+});
+/** An ending's length, and its full width, as a multiple of the stroke width. */
+const ENDING_SCALE = 3;
+/**
+* A free text's text box: `rect` inset by `fringe`, or `rect` itself without one. Insets wider
+* or taller than `rect` leave a box of width or height 0 at the inset origin.
+*/
+function freeTextBox(a) {
+	const { rect, fringe } = a;
+	if (!fringe) return rect;
+	return {
+		x: rect.x + fringe.left,
+		y: rect.y + fringe.bottom,
+		width: Math.max(0, rect.width - fringe.left - fringe.right),
+		height: Math.max(0, rect.height - fringe.top - fringe.bottom)
+	};
+}
+/**
+* True for a free-text callout drawn the standard way: a box with a leader line through
+* `callout`. A callout with `cornerRadius` is Inkbar's speech bubble instead.
+*/
+function isStandardCallout(a) {
+	return a.type === "freetext" && a.intent === "FreeTextCallout" && a.callout !== void 0 && a.callout.length >= 2 && a.cornerRadius === void 0;
+}
+/**
+* The leader line's stroke: the border colour, else the text colour, and the border width, with
+* 1 pt when the box has no border.
+*/
+function calloutStroke(a) {
+	return {
+		color: a.borderColor ?? a.defaultStyle.color,
+		width: a.width > 0 ? a.width : 1
+	};
+}
+/**
+* The `rect` and `fringe` that hold the text box `box` and a leader line through `callout`
+* stroked `width` points wide: every point is padded by half the stroke, and by the ending's
+* size as well when `head` is one Inkbar draws.
+*/
+function withCalloutBounds(box, callout, width, head) {
+	const drawn = head !== void 0 && head !== "None" && isKnown(LINE_ENDINGS, head);
+	const pad = width / 2 + (drawn ? ENDING_SCALE * Math.max(width, 1) : 0);
+	const xs = [
+		box.x,
+		box.x + box.width,
+		...callout.map((p) => p.x)
+	];
+	const ys = [
+		box.y,
+		box.y + box.height,
+		...callout.map((p) => p.y)
+	];
+	const left = Math.min(...xs) - pad;
+	const bottom = Math.min(...ys) - pad;
+	const right = Math.max(...xs) + pad;
+	const top = Math.max(...ys) + pad;
+	return {
+		rect: {
+			x: left,
+			y: bottom,
+			width: right - left,
+			height: top - bottom
+		},
+		fringe: {
+			left: box.x - left,
+			top: top - (box.y + box.height),
+			right: right - (box.x + box.width),
+			bottom: box.y - bottom
+		}
+	};
+}
+//#endregion
+//#region src/model/annotations/types.ts
+const ANNOTATION_FORMAT = "inkbar/annotations";
+const ANNOTATION_VERSION = 1;
+const Hex = z.string().regex(/^#[0-9a-fA-F]{6}$/, "expected #RRGGBB");
+const PointSchema = z.object({
+	x: z.number(),
+	y: z.number()
+});
+const RectSchema = z.object({
+	x: z.number(),
+	y: z.number(),
+	width: z.number().nonnegative(),
+	height: z.number().nonnegative()
+});
+const QuadSchema = z.object({
+	p1: PointSchema,
+	p2: PointSchema,
+	p3: PointSchema,
+	p4: PointSchema
+});
+const Base = z.object({
+	/** Client id, UUIDv7, assigned at creation and never reassigned. Embedded annotations use `pdf:<ref>`. */
+	id: z.string().min(1),
+	/** 0-based page index. */
+	page: z.number().int().nonnegative(),
+	/** Bounding box in PDF user space. */
+	rect: RectSchema,
+	/** Resolved #RRGGBB. Written into the PDF later, so it is always concrete. */
+	color: Hex,
+	opacity: z.number().min(0).max(1),
+	author: z.string().optional(),
+	contents: z.string().optional(),
+	/** Id of the parent note; replies form threads. */
+	inReplyTo: z.string().optional(),
+	/** ISO 8601 date-time. */
+	createdAt: z.iso.datetime({ offset: true }),
+	/** ISO 8601 date-time. */
+	modifiedAt: z.iso.datetime({ offset: true }),
+	/** Created in this session, or imported from the file. Viewer state, never exported. */
+	source: z.enum(["session", "pdf"]),
+	/** Embedded annotations are locked until the engine can rewrite the file. Viewer state, never exported. */
+	locked: z.boolean().optional(),
+	/** Short label for what the mark is (XFDF `subject`). */
+	subject: z.string().optional(),
+	/** What the mark is for, e.g. a callout or an arrow (XFDF `intent`, a PDF name). */
+	intent: pdfNameSet(INTENTS).optional(),
+	/** Host data. Preserved, never interpreted. */
+	custom: z.record(z.string(), z.unknown()).optional()
+});
+const TextMarkupSchema = Base.extend({
+	type: z.enum([
+		"highlight",
+		"underline",
+		"strikeout",
+		"squiggly"
+	]),
+	quads: z.array(QuadSchema).min(1)
+});
+/** A note's icon (XFDF `icon`): a PDF name, so a name Inkbar does not know is kept. */
+const NoteIconSchema = pdfNameSet(NOTE_ICONS);
+const NoteSchema = Base.extend({
+	type: z.literal("text"),
+	icon: NoteIconSchema.default("Note")
+});
+/** A line ending (XFDF `head`/`tail`): a PDF name, so a name Inkbar does not know is kept. */
+const LineEndingSchema = pdfNameSet(LINE_ENDINGS);
+/** Dash pattern in points, on then off, repeating. Absent means solid. */
+const DashesSchema = z.array(z.number().nonnegative()).min(1).optional();
+/**
+* A key a type refuses outright rather than dropping like other unknown keys: one an older
+* shape used (so its value is not silently lost), or one that means nothing on the type (so a
+* later version is free to give it a meaning).
+*/
+const Refused = z.never().optional();
+/**
+* A free-text box's text style, keyed by the CSS property names XFDF writes in its
+* `defaultstyle` string. The older `align` is refused; other unknown keys are dropped.
+*/
+const FreeTextStyleSchema = z.object({
+	fontFamily: z.string().min(1).default("Helvetica"),
+	/** Points. */
+	fontSize: z.number().positive().default(12),
+	/** The text colour. */
+	color: Hex,
+	textAlign: z.enum([
+		"left",
+		"center",
+		"right",
+		"justify"
+	]).default("left"),
+	fontWeight: z.literal("bold").optional(),
+	fontStyle: z.literal("italic").optional(),
+	textDecoration: z.literal("underline").optional(),
+	align: Refused
+});
+/**
+* Free text, as XFDF has it: `color` is the box's fill and the text style lives in
+* `defaultStyle`. A box in the older shape (top-level `fontFamily`, `fontSize`, `align`) is
+* refused rather than silently losing its style; other unknown keys are dropped.
+*/
+const FreeTextSchema = Base.extend({
+	type: z.literal("freetext"),
+	/** The text shown on the page. */
+	contents: z.string(),
+	/** The box's fill (XFDF `color`). Absent means no fill. */
+	color: Hex.optional(),
+	/** The border's colour. An extension, not XFDF. */
+	borderColor: Hex.optional(),
+	/** The border's width in points; 0 draws no border. */
+	width: z.number().nonnegative().default(0),
+	dashes: DashesSchema,
+	/** Points. An extension, not XFDF. */
+	cornerRadius: z.number().nonnegative().optional(),
+	defaultStyle: FreeTextStyleSchema,
+	/**
+	* The insets from `rect` to the text box, in points (XFDF `fringe`, PDF `/RD`). Absent means
+	* the box is `rect`.
+	*/
+	fringe: FringeSchema.optional(),
+	/** A callout's leader line: the tip, an optional bend, and where it meets the box (PDF `/CL`). */
+	callout: z.array(PointSchema).min(2).max(3).optional(),
+	/** The line ending at a callout's tip (XFDF `head`, PDF `/LE`). Absent means `None`. */
+	head: LineEndingSchema.optional(),
+	fontFamily: Refused,
+	fontSize: Refused,
+	align: Refused
+});
+const ShapeFields = {
+	width: z.number().nonnegative().default(1),
+	dashes: DashesSchema,
+	interiorColor: Hex.optional()
+};
+const SquareSchema = Base.extend({
+	type: z.literal("square"),
+	...ShapeFields,
+	/** The corner radius in points. An extension, not XFDF. */
+	cornerRadius: z.number().nonnegative().optional()
+});
+const CircleSchema = Base.extend({
+	type: z.literal("circle"),
+	...ShapeFields,
+	cornerRadius: Refused
+});
+const ShapeSchema = z.discriminatedUnion("type", [SquareSchema, CircleSchema]);
+const LineSchema = Base.extend({
+	type: z.literal("line"),
+	start: PointSchema,
+	end: PointSchema,
+	width: z.number().nonnegative().default(1),
+	dashes: DashesSchema,
+	head: LineEndingSchema.optional(),
+	tail: LineEndingSchema.optional()
+});
+const PolyFields = {
+	vertices: z.array(PointSchema).min(2),
+	width: z.number().nonnegative().default(1),
+	dashes: DashesSchema,
+	interiorColor: Hex.optional()
+};
+const PolylineSchema = Base.extend({
+	type: z.literal("polyline"),
+	...PolyFields,
+	/** The ending at the first vertex. */
+	head: LineEndingSchema.optional(),
+	/** The ending at the last vertex. */
+	tail: LineEndingSchema.optional()
+});
+const PolygonSchema = Base.extend({
+	type: z.literal("polygon"),
+	...PolyFields,
+	head: Refused,
+	tail: Refused
+});
+const PolySchema = z.discriminatedUnion("type", [PolylineSchema, PolygonSchema]);
+const InkShape = Base.extend({
+	type: z.literal("ink"),
+	inklist: z.array(z.array(PointSchema).min(1)).min(1),
+	/** Pen pressure per sample, 0 to 1, shaped like `inklist`. Absent for mouse input. */
+	pressure: z.array(z.array(z.number().min(0).max(1))).optional(),
+	width: z.number().nonnegative().default(2),
+	/** Kept so imported dashed ink round-trips. Inkbar draws ink solid. */
+	dashes: DashesSchema
+});
+/** Pressure must have one value per point of each stroke. */
+function checkPressure(a, ctx) {
+	if (!a.pressure) return;
+	if (!(a.pressure.length === a.inklist.length && a.pressure.every((p, i) => p.length === a.inklist[i]?.length))) ctx.addIssue({
+		code: "custom",
+		path: ["pressure"],
+		message: "pressure must have the same shape as inklist"
+	});
+}
+const InkSchema = InkShape.superRefine(checkPressure);
+/** A PNG or JPEG image as a base64 `data:` URL, as XFDF carries a stamp's `<imagedata>`. */
+const IMAGE_DATA_URL = /^data:image\/(png|jpeg);base64,/;
+/**
+* An image on the page (XFDF `stamp`), drawn to fill `rect`. Image and typed signatures are
+* stamps with `subject: 'Signature'`.
+*/
+const StampSchema = Base.extend({
+	type: z.literal("stamp"),
+	/** A PNG or JPEG `data:` URL (XFDF `imagedata`). */
+	imagedata: z.string().regex(IMAGE_DATA_URL, "expected a PNG or JPEG data URL"),
+	/**
+	* Quarter turns, in degrees anticlockwise, the image is turned within `rect` (XFDF
+	* `rotation`). Absent means upright in user space.
+	*/
+	rotation: z.union([
+		z.literal(0),
+		z.literal(90),
+		z.literal(180),
+		z.literal(270)
+	]).optional()
+});
+/**
+* A loupe (an extension, not XFDF): a circle inscribed in `rect` that shows the page content
+* under its own centre, magnified. `color` and `width` draw its rim.
+*/
+const LoupeSchema = Base.extend({
+	type: z.literal("loupe"),
+	/** How many times larger the content under the centre is drawn. Above 1. */
+	magnification: z.number().gt(1).default(2),
+	/** The rim's width in points. */
+	width: z.number().nonnegative().default(2)
+});
+/**
+* A mask (an extension, not XFDF): dims everything on the page outside `shape` drawn in
+* `rect`, an ellipse inscribed in it or the rectangle itself. `color` is the dimming colour
+* (black by default) and `dim` how strongly it covers. One per page: adding a second replaces
+* the first.
+*/
+const MaskSchema = Base.extend({
+	type: z.literal("mask"),
+	shape: z.enum(["rect", "ellipse"]),
+	/** Opacity of the dimming, 0 (none) to 1 (opaque). */
+	dim: z.number().min(0).max(1).default(.5)
+});
+const SuggestionSchema = z.object({
+	jobId: z.string().optional(),
+	confidence: z.number().min(0).max(1),
+	reason: z.string().optional(),
+	explanation: z.string().optional(),
+	recommendation: z.enum([
+		"redact",
+		"review",
+		"keep"
+	]).optional()
+});
+const RedactSchema = Base.extend({
+	type: z.literal("redact"),
+	/** Present when the mark came from text; absent for an area mark. */
+	quads: z.array(QuadSchema).min(1).optional(),
+	origin: z.enum(["user", "suggested"]).default("user"),
+	suggestion: SuggestionSchema.optional(),
+	overlayText: z.string().optional(),
+	/** Colour the redaction will be filled with when applied. */
+	interiorColor: Hex
+});
+const AnnotationSchema = z.discriminatedUnion("type", [
+	TextMarkupSchema,
+	NoteSchema,
+	FreeTextSchema,
+	SquareSchema,
+	CircleSchema,
+	LineSchema,
+	PolylineSchema,
+	PolygonSchema,
+	InkSchema,
+	StampSchema,
+	LoupeSchema,
+	MaskSchema,
+	RedactSchema
+]);
+/** The viewer's own state on an annotation, left out of exports. */
+const VIEWER_STATE = {
+	source: true,
+	locked: true
+};
+/** One exported annotation: the stored annotation without its viewer state. */
+const ExportedAnnotationSchema = z.discriminatedUnion("type", [
+	TextMarkupSchema.omit(VIEWER_STATE),
+	NoteSchema.omit(VIEWER_STATE),
+	FreeTextSchema.omit(VIEWER_STATE),
+	SquareSchema.omit(VIEWER_STATE),
+	CircleSchema.omit(VIEWER_STATE),
+	LineSchema.omit(VIEWER_STATE),
+	PolylineSchema.omit(VIEWER_STATE),
+	PolygonSchema.omit(VIEWER_STATE),
+	InkShape.omit(VIEWER_STATE).superRefine(checkPressure),
+	StampSchema.omit(VIEWER_STATE),
+	LoupeSchema.omit(VIEWER_STATE),
+	MaskSchema.omit(VIEWER_STATE),
+	RedactSchema.omit(VIEWER_STATE)
+]);
+const AnnotationDocumentSchema = z.object({
+	format: z.literal(ANNOTATION_FORMAT),
+	version: z.literal(1),
+	documentKey: z.string().optional(),
+	/** Validated item by item on import so unknown types can be preserved. */
+	annotations: z.array(z.unknown())
+});
+function confidenceBucket(confidence) {
+	if (confidence < .5) return "low";
+	if (confidence < .8) return "medium";
+	return "high";
+}
+//#endregion
+//#region src/model/annotations/embedded.ts
+const SUPPORTED_SUBTYPES = /* @__PURE__ */ new Set([
+	"Highlight",
+	"Underline",
+	"StrikeOut",
+	"Squiggly",
+	"Text",
+	"FreeText",
+	"Square",
+	"Circle",
+	"Line",
+	"Polygon",
+	"PolyLine",
+	"Ink",
+	"Redact"
+]);
+function pdfColorToHex(c, fallback) {
+	if (!c || c.length < 3) return fallback;
+	return `#${[
+		c[0],
+		c[1],
+		c[2]
+	].map((n) => Math.round(n).toString(16).padStart(2, "0")).join("")}`.toUpperCase();
+}
+/** PDF.js hands back `rect` already in user space, but not always ordered; normalise with min/max. */
+function rectFromPdf(r) {
+	return rectFromPoints({
+		x: r[0],
+		y: r[1]
+	}, {
+		x: r[2],
+		y: r[3]
+	});
+}
+/** A PDF name exactly as PDF.js gives it (names are case-sensitive), or undefined if invalid. */
+function pdfName(raw) {
+	return raw !== void 0 && PDF_NAME.test(raw) ? raw : void 0;
+}
+/** `head` and `tail` from a Line's or PolyLine's `/LE`, left out when both are `None`. */
+function lineEndingsOf(raw) {
+	const endings = raw?.map((e) => pdfName(e) ?? "None");
+	return endings && endings.length === 2 && endings.some((e) => e !== "None") ? {
+		head: endings[0],
+		tail: endings[1]
+	} : {};
+}
+/**
+* Imported ids are `pdf:<page>:<pdfjsId>` (page is 0-based, pdfjsId is the annotation's object
+* reference such as `12R`). They are stable across opens of the same file, and `inReplyTo`
+* uses the same scheme so threads resolve.
+*/
+function importedId(page, pdfjsId) {
+	return `pdf:${page}:${pdfjsId}`;
+}
+function importEmbeddedPage(page, raw, importedAt) {
+	const counts = {};
+	const annotations = [];
+	for (const data of raw) {
+		counts[data.subtype] = (counts[data.subtype] ?? 0) + 1;
+		if (!SUPPORTED_SUBTYPES.has(data.subtype) || data.hidden || data.noView) continue;
+		const converted = convert(page, data, importedAt);
+		if (converted) annotations.push(converted);
+	}
+	return {
+		annotations,
+		counts
+	};
+}
+function summarise(perPage) {
+	const totals = /* @__PURE__ */ new Map();
+	for (const counts of perPage) for (const [k, v] of Object.entries(counts)) totals.set(k, (totals.get(k) ?? 0) + v);
+	return [...totals.entries()].map(([subtype, count]) => ({
+		subtype,
+		count,
+		supported: SUPPORTED_SUBTYPES.has(subtype)
+	})).sort((a, b) => a.subtype < b.subtype ? -1 : a.subtype > b.subtype ? 1 : 0);
+}
+function convert(page, d, importedAt) {
+	const created = parsePdfDate(d.creationDate, parsePdfDate(d.modificationDate, importedAt));
+	const author = d.titleObj?.str;
+	const contents = d.contentsObj?.str;
+	const stroke = d.borderStyle?.width ?? 1;
+	const quads = d.quadPoints ? quadsFromFlat(d.quadPoints) : [];
+	const optional = (v) => v !== void 0 && v !== "";
+	const withColor = (type, source = d.color) => pdfColorToHex(source, staticDefaults.color(type));
+	const intent = pdfName(d.it);
+	const base = (type, color = withColor(type)) => ({
+		id: importedId(page, d.id),
+		page,
+		rect: rectFromPdf(d.rect),
+		color,
+		opacity: d.opacity ?? 1,
+		...optional(author) ? { author } : {},
+		...optional(contents) ? { contents } : {},
+		...d.inReplyTo ? { inReplyTo: importedId(page, d.inReplyTo) } : {},
+		...intent !== void 0 ? { intent } : {},
+		createdAt: created,
+		modifiedAt: parsePdfDate(d.modificationDate, created),
+		source: "pdf",
+		locked: true
+	});
+	const fillOf = (c) => c && c.length >= 3 ? { interiorColor: pdfColorToHex(c, "#FFFFFF") } : {};
+	let candidate;
+	switch (d.subtype) {
+		case "Highlight":
+		case "Underline":
+		case "StrikeOut":
+		case "Squiggly": {
+			if (quads.length === 0) return void 0;
+			const type = d.subtype === "StrikeOut" ? "strikeout" : d.subtype.toLowerCase();
+			candidate = {
+				...base(type),
+				type,
+				quads
+			};
+			break;
+		}
+		case "Text": {
+			const icon = d.name === "NoIcon" ? void 0 : pdfName(d.name);
+			candidate = {
+				...base("text"),
+				type: "text",
+				...icon !== void 0 ? { icon } : {}
+			};
+			break;
+		}
+		case "FreeText": {
+			const da = d.defaultAppearanceData;
+			const { color: _stroke, ...rest } = base("freetext");
+			candidate = {
+				...rest,
+				...d.color && d.color.length >= 3 ? { color: pdfColorToHex(d.color, "#FFFFFF") } : {},
+				type: "freetext",
+				contents: contents ?? "",
+				width: d.borderStyle?.width ?? 0,
+				defaultStyle: {
+					color: pdfColorToHex(da?.fontColor, staticDefaults.color("freetext")),
+					...da && da.fontSize > 0 ? { fontSize: da.fontSize } : {}
+				}
+			};
+			break;
+		}
+		case "Square":
+		case "Circle": {
+			const type = d.subtype.toLowerCase();
+			candidate = {
+				...base(type),
+				type,
+				width: stroke,
+				...fillOf(d.interiorColor)
+			};
+			break;
+		}
+		case "Line": {
+			const l = d.lineCoordinates ?? [
+				d.rect[0],
+				d.rect[1],
+				d.rect[2],
+				d.rect[3]
+			];
+			candidate = {
+				...base("line"),
+				type: "line",
+				start: {
+					x: l[0],
+					y: l[1]
+				},
+				end: {
+					x: l[2],
+					y: l[3]
+				},
+				width: stroke,
+				...lineEndingsOf(d.lineEndings)
+			};
+			break;
+		}
+		case "Polygon":
+		case "PolyLine": {
+			const type = d.subtype === "Polygon" ? "polygon" : "polyline";
+			const vertices = d.vertices ? pointsFromFlat(d.vertices) : [];
+			if (vertices.length < 2) return void 0;
+			candidate = {
+				...base(type),
+				type,
+				vertices,
+				width: stroke,
+				...fillOf(d.interiorColor),
+				...type === "polyline" ? lineEndingsOf(d.lineEndings) : {}
+			};
+			break;
+		}
+		case "Ink": {
+			const inklist = (d.inkLists ?? []).map((p) => pointsFromFlat(p)).filter((p) => p.length > 0);
+			if (inklist.length === 0) return void 0;
+			candidate = {
+				...base("ink"),
+				type: "ink",
+				inklist,
+				width: stroke
+			};
+			break;
+		}
+		case "Redact":
+			candidate = {
+				...base("redact"),
+				type: "redact",
+				origin: "user",
+				interiorColor: pdfColorToHex(d.interiorColor, staticDefaults.fill()),
+				...quads.length > 0 ? { quads } : {}
+			};
+			break;
+		default: return;
+	}
+	const parsed = AnnotationSchema.safeParse(candidate);
+	return parsed.success ? parsed.data : void 0;
+}
+//#endregion
+//#region src/model/env.ts
+/** True only when the build or runtime says production; browsers without `process` count as dev. */
+function isProduction() {
+	try {
+		return process.env.NODE_ENV === "production";
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/model/annotations/history.ts
+/**
+* Snapshot-based undo and redo over an uncontrolled store.
+*
+* In controlled mode the host owns the list, so history is the host's concern (the Vue layer
+* offers `useHistory`). There `createHistory` returns an inert History: `canUndo` and `canRedo`
+* stay false, `undo` and `redo` do nothing, and nothing is recorded.
+*/
+function createHistory(store, opts = {}) {
+	const canUndo = writable(false);
+	const canRedo = writable(false);
+	if (store.mode === "controlled") return {
+		canUndo: readonly(canUndo),
+		canRedo: readonly(canRedo),
+		undo() {},
+		redo() {},
+		clear() {},
+		batch(fn) {
+			fn();
+		},
+		destroy() {}
+	};
+	const limit = opts.limit ?? 200;
+	const undoStack = [];
+	const redoStack = [];
+	let previous = store.list.get();
+	let replaying = false;
+	/** Open batch depth; while above zero, changes update `previous` but push no entry. */
+	let depth = 0;
+	/** The list when the outermost batch opened (or was restarted by a replace). */
+	let batchStart = null;
+	const sync = () => {
+		canUndo.set(undoStack.length > 0);
+		canRedo.set(redoStack.length > 0);
+	};
+	let destroyed = false;
+	const unsubscribe = store.on("change", (change) => {
+		const current = store.list.get();
+		if (replaying || change.kind === "replace" && change.reason === "history") {
+			previous = current;
+			return;
+		}
+		if (change.kind === "replace") {
+			undoStack.length = 0;
+			redoStack.length = 0;
+			previous = current;
+			if (depth > 0) batchStart = current;
+			sync();
+			return;
+		}
+		if (depth > 0) {
+			previous = current;
+			return;
+		}
+		undoStack.push({
+			before: previous,
+			after: current
+		});
+		if (undoStack.length > limit) undoStack.shift();
+		redoStack.length = 0;
+		previous = current;
+		sync();
+	});
+	const apply = (list) => {
+		replaying = true;
+		try {
+			store.replaceAll([...list], "history");
+		} finally {
+			replaying = false;
+		}
+	};
+	return {
+		canUndo: readonly(canUndo),
+		canRedo: readonly(canRedo),
+		undo() {
+			const entry = undoStack.pop();
+			if (destroyed || !entry) return;
+			redoStack.push(entry);
+			apply(entry.before);
+			sync();
+		},
+		redo() {
+			const entry = redoStack.pop();
+			if (destroyed || !entry) return;
+			undoStack.push(entry);
+			apply(entry.after);
+			sync();
+		},
+		batch(fn) {
+			if (destroyed) {
+				fn();
+				return;
+			}
+			if (depth++ === 0) batchStart = store.list.get();
+			try {
+				const result = fn();
+				if (result !== null && typeof result === "object" && typeof result.then === "function" && !isProduction()) console.warn("[inkbar] history.batch(fn): fn returned a promise. Changes after its first await are not part of the batch.");
+			} finally {
+				if (--depth === 0 && !destroyed) {
+					const before = batchStart;
+					batchStart = null;
+					const after = store.list.get();
+					if (before && !sameAnnotations(before, after)) {
+						undoStack.push({
+							before,
+							after
+						});
+						if (undoStack.length > limit) undoStack.shift();
+						redoStack.length = 0;
+						sync();
+					}
+				}
+			}
+		},
+		destroy() {
+			destroyed = true;
+			batchStart = null;
+			unsubscribe();
+			undoStack.length = 0;
+			redoStack.length = 0;
+			sync();
+		},
+		clear() {
+			undoStack.length = 0;
+			redoStack.length = 0;
+			previous = store.list.get();
+			sync();
+		}
+	};
+}
+/** The same annotation objects in the same order. */
+function sameAnnotations(a, b) {
+	return a === b || a.length === b.length && a.every((x, i) => x === b[i]);
+}
+//#endregion
+//#region src/model/annotations/json.ts
+const KNOWN_TYPES = new Set(ExportedAnnotationSchema.options.flatMap((o) => [...o.shape.type._zod.values]));
+/**
+* Session annotations plus any preserved foreign items. Embedded (`source: 'pdf'`) ones stay in
+* the file. `source` and `locked` are viewer state and are left out.
+*
+* The result is a JSON copy (`JSON.parse(JSON.stringify(...))`), the same data a serialised
+* export would carry: editing it never touches the store, and values JSON cannot hold, such as
+* functions or `undefined` inside `custom`, are left out exactly as `JSON.stringify` would.
+*
+* Without foreign items the result validates against this version's `schema.json`. With them it
+* validates only against the newer schema that produced them, since this version's schema
+* describes only the types it knows.
+*/
+function exportAnnotations(store, preserved = [], documentKey) {
+	const session = store.list.get().filter((a) => a.source === "session").map(({ source: _source, locked: _locked, ...rest }) => rest);
+	return {
+		format: ANNOTATION_FORMAT,
+		version: 1,
+		...documentKey === void 0 ? {} : { documentKey },
+		annotations: JSON.parse(JSON.stringify([...session, ...preserved]))
+	};
+}
+/**
+* Validates the envelope (throws a TypeError when it is not an inkbar/annotations v1 document),
+* then each item on its own. Embedded annotations are never touched; imported items become
+* session annotations.
+*/
+function importAnnotations(store, data, opts) {
+	const plan = planImport(store, data, opts);
+	plan.apply();
+	return plan.result;
+}
+/**
+* @internal Validation half of `importAnnotations`, so the document can record foreign items
+* before the store publishes the change.
+*
+* Ids are unique across the payload: the first item with an id claims it, and later ones (known
+* or foreign) are reported in `errors`, even when the first was itself rejected. An id that
+* matches an embedded annotation is rejected for known and foreign items alike. In `merge` mode an incoming item replaces whatever session
+* annotation has its id, whether the incoming item is known or foreign.
+*/
+function planImport(store, data, opts) {
+	const raw = typeof data === "string" ? JSON.parse(data) : data;
+	const envelope = AnnotationDocumentSchema.safeParse(raw);
+	if (!envelope.success) throw new TypeError(`Expected an ${ANNOTATION_FORMAT} v1 document: ${envelope.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ")}`);
+	const embeddedIds = new Set(store.list.get().filter((a) => a.source === "pdf").map((a) => a.id));
+	const result = {
+		imported: 0,
+		unknown: [],
+		errors: []
+	};
+	const incoming = [];
+	/** id -> index of the first item that used it, whether that item was accepted or not. */
+	const seen = /* @__PURE__ */ new Map();
+	/** Ids the import actually brings in. */
+	const accepted = /* @__PURE__ */ new Set();
+	/**
+	* Reserves `id` for the item at `index`. Later items with the same id are duplicates even
+	* when this one is rejected for reusing an embedded id.
+	*/
+	const claim = (id, index) => {
+		const first = seen.get(id);
+		if (first !== void 0) {
+			result.errors.push({
+				index,
+				issues: [`id: duplicate id "${id}", already used by item ${first}`]
+			});
+			return false;
+		}
+		seen.set(id, index);
+		if (embeddedIds.has(id)) {
+			result.errors.push({
+				index,
+				issues: ["id: matches an annotation embedded in the PDF, which import never replaces"]
+			});
+			return false;
+		}
+		accepted.add(id);
+		return true;
+	};
+	envelope.data.annotations.forEach((item, index) => {
+		const type = item?.type;
+		if (typeof type === "string" && !KNOWN_TYPES.has(type)) {
+			if (!isForeign(item)) result.errors.push({
+				index,
+				issues: [`type: unknown type "${type}" needs a string id and a numeric page to be preserved`]
+			});
+			else if (claim(item.id, index)) result.unknown.push(item);
+			return;
+		}
+		const parsed = ExportedAnnotationSchema.safeParse(item);
+		if (!parsed.success) {
+			result.errors.push({
+				index,
+				issues: parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`)
+			});
+			return;
+		}
+		if (!claim(parsed.data.id, index)) return;
+		incoming.push({
+			...parsed.data,
+			source: "session"
+		});
+		result.imported++;
+	});
+	if (result.unknown.length > 0 && !isProduction()) {
+		const types = [...new Set(result.unknown.map((u) => u.type))];
+		console.warn(`[inkbar] importAnnotations kept ${result.unknown.length} annotation(s) of unknown type (${types.join(", ")}). They are not shown, and exportAnnotations writes them back out.`);
+	}
+	const ids = accepted;
+	return {
+		result,
+		ids,
+		apply() {
+			const current = store.list.get();
+			const embedded = current.filter((a) => a.source === "pdf");
+			if (opts.mode === "replace") {
+				store.replaceAll([...embedded, ...incoming], "import");
+				return;
+			}
+			const byId = new Map(current.filter((a) => a.source === "session" && !ids.has(a.id)).map((a) => [a.id, a]));
+			for (const a of incoming) byId.set(a.id, a);
+			store.replaceAll([...embedded, ...byId.values()], "import");
+		}
+	};
+}
+function isForeign(item) {
+	if (typeof item !== "object" || item === null || Array.isArray(item)) return false;
+	const { type, id, page } = item;
+	return typeof type === "string" && typeof id === "string" && typeof page === "number";
+}
+//#endregion
+//#region src/model/annotations/store.ts
+/** Keys a locked annotation refuses to change. */
+const LOCKED_KEYS = /* @__PURE__ */ new Set([
+	"page",
+	"rect",
+	"quads",
+	"inklist",
+	"start",
+	"end",
+	"vertices",
+	"callout",
+	"contents",
+	"imagedata",
+	"rotation"
+]);
+function keepKey(target, from, key) {
+	if (Object.prototype.hasOwnProperty.call(from, key)) target[key] = from[key];
+	else delete target[key];
+}
+/** `proposed` as a replacement for embedded `current`, with what the file owns kept from `current`. */
+function guardEmbedded(current, proposed) {
+	if (proposed === current) return current;
+	if (proposed.type !== current.type) return current;
+	const candidate = {
+		...proposed,
+		id: current.id,
+		createdAt: current.createdAt,
+		source: "pdf"
+	};
+	keepKey(candidate, current, "locked");
+	if (current.locked) for (const key of LOCKED_KEYS) keepKey(candidate, current, key);
+	const parsed = AnnotationSchema.safeParse(candidate);
+	return parsed.success ? parsed.data : current;
+}
+function deriveRect(input) {
+	switch (input.type) {
+		case "highlight":
+		case "underline":
+		case "strikeout":
+		case "squiggly": return unionRects(input.quads.map(rectFromQuad));
+		case "redact":
+			if (input.quads) return unionRects(input.quads.map(rectFromQuad));
+			break;
+		case "ink": {
+			const pad = (input.width ?? 2) / 2;
+			const r = bounds(input.inklist.flat());
+			return {
+				x: r.x - pad,
+				y: r.y - pad,
+				width: r.width + pad * 2,
+				height: r.height + pad * 2
+			};
+		}
+		case "line": return bounds([input.start, input.end]);
+		case "polyline":
+		case "polygon": return bounds(input.vertices);
+	}
+	if (input.rect) return input.rect;
+	throw new TypeError(`rect is required for ${input.type}`);
+}
+function bounds(pts) {
+	const xs = pts.map((p) => p.x);
+	const ys = pts.map((p) => p.y);
+	const x = Math.min(...xs);
+	const y = Math.min(...ys);
+	return {
+		x,
+		y,
+		width: Math.max(...xs) - x,
+		height: Math.max(...ys) - y
+	};
+}
+/** `o` without its `undefined` values. */
+function withoutUndefined(o) {
+	return Object.fromEntries(Object.entries(o).filter(([, v]) => v !== void 0));
+}
+/**
+* A `defaultStyle` patch merges one level deep into the current one, so changing the weight
+* keeps the font and size. An `undefined` value removes its key.
+*/
+function mergedStyle(before, patch) {
+	const next = patch.defaultStyle;
+	if (before.type !== "freetext" || next === void 0 || next === null) return {};
+	return { defaultStyle: withoutUndefined({
+		...before.defaultStyle,
+		...next
+	}) };
+}
+/** Pending-map key; only annotation changes are tracked, and the prefix keeps ids apart from any other slot. */
+function changeKey(change) {
+	return `annotation:${change.kind === "update" ? change.id : change.annotation.id}`;
+}
+/** Structural equality for plain JSON values, ignoring `modifiedAt` at the top level. */
+function sameIgnoringModifiedAt(a, b) {
+	const { modifiedAt: _a, ...restA } = a;
+	const { modifiedAt: _b, ...restB } = b;
+	return deepEqual(restA, restB);
+}
+function deepEqual(a, b) {
+	if (Object.is(a, b)) return true;
+	if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+	if (Array.isArray(a) !== Array.isArray(b)) return false;
+	const ka = Object.keys(a);
+	const kb = Object.keys(b);
+	if (ka.length !== kb.length) return false;
+	return ka.every((k) => Object.prototype.hasOwnProperty.call(b, k) && deepEqual(a[k], b[k]));
+}
+function isApplied(change, current) {
+	switch (change.kind) {
+		case "add": return current.some((a) => a.id === change.annotation.id);
+		case "remove": return !current.some((a) => a.id === change.annotation.id);
+		case "update": {
+			const mine = current.find((a) => a.id === change.id);
+			if (!mine) return false;
+			return mine === change.after || sameIgnoringModifiedAt(mine, change.after);
+		}
+		case "replace": return true;
+	}
+}
+function createAnnotationStore(opts) {
+	const now = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+	const nextId = opts.id ?? (() => v7());
+	const list = writable([...opts.mode.initial ?? []]);
+	const selection = writable([]);
+	const emitter = new Emitter();
+	const controlled = opts.mode.mode === "controlled" ? opts.mode : void 0;
+	const pending = /* @__PURE__ */ new Map();
+	/**
+	* Controlled mode: the list as the store last proposed it, embedded items included. Later
+	* proposals build on it, so several mutations in a row (one highlight per page, a bulk
+	* remove, add then select) all reach the host. It resets to the applied list when the host
+	* pushes a value or a pending change's check fires without one.
+	*/
+	let proposed;
+	let destroyed = false;
+	/** What mutations build on: the pending proposal in controlled mode, else the list. */
+	const basis = () => proposed ?? list.get();
+	const findIn = (items, id) => items.find((a) => a.id === id);
+	function completeInput(input) {
+		const ts = now();
+		const candidate = {
+			...input,
+			id: input.id ?? nextId(),
+			rect: input.rect ?? deriveRect(input),
+			color: input.color ?? opts.defaults.color(input.type),
+			opacity: input.opacity ?? opts.defaults.opacity(input.type),
+			createdAt: ts,
+			modifiedAt: ts,
+			source: "session"
+		};
+		if (input.type === "freetext") {
+			if (input.color === void 0) delete candidate.color;
+			candidate.defaultStyle = {
+				color: opts.defaults.color("freetext"),
+				...withoutUndefined(input.defaultStyle ?? {})
+			};
+		}
+		if (input.type === "redact") {
+			if (input.interiorColor === void 0) candidate.interiorColor = opts.defaults.fill();
+			if (input.origin === "suggested" && input.suggestion && input.color === void 0) candidate.color = opts.defaults.suggestion(confidenceBucket(input.suggestion.confidence));
+		}
+		return AnnotationSchema.parse(candidate);
+	}
+	function clearPending(key) {
+		const entry = pending.get(key);
+		if (!entry) return;
+		clearTimeout(entry.timer);
+		pending.delete(key);
+	}
+	function warnIfIgnored(key) {
+		const entry = pending.get(key);
+		if (!entry) return;
+		pending.delete(key);
+		if (pending.size === 0) proposed = void 0;
+		if (isApplied(entry.change, list.get()) || isProduction()) return;
+		console.warn(`[inkbar] ControlledMutationIgnored: the host did not apply a ${entry.change.kind} for annotation ${entry.id}. In controlled mode, pass the list from onChange back into the store.`);
+	}
+	function commit(next, change) {
+		if (controlled) {
+			if (change.kind !== "replace") {
+				const key = changeKey(change);
+				clearPending(key);
+				const entry = {
+					id: change.kind === "update" ? change.id : change.annotation.id,
+					change,
+					timer: setTimeout(() => {
+						entry.timer = setTimeout(() => {
+							warnIfIgnored(key);
+						}, 0);
+					}, 0)
+				};
+				pending.set(key, entry);
+			}
+			proposed = change.kind === "replace" ? [...list.get().filter((a) => a.source === "pdf"), ...next.filter((a) => a.source !== "pdf")] : next;
+			controlled.onChange(next.filter((a) => a.source !== "pdf"), change);
+			return;
+		}
+		list.set(next);
+		emitter.emit("change", change);
+	}
+	/**
+	* Uncontrolled `replaceAll` cannot drop or forge embedded annotations: every current embedded
+	* item stays (taking the list's version of it, guarded like `update`, when the list has one),
+	* and items claiming `source: 'pdf'` that the store does not hold are dropped. History
+	* snapshots contain the embedded items, so undo and redo of their edits still work.
+	*/
+	function withEmbedded(proposed) {
+		const current = new Map(list.get().filter((a) => a.source === "pdf").map((a) => [a.id, a]));
+		const seen = /* @__PURE__ */ new Set();
+		const out = [];
+		for (const a of proposed) {
+			const mine = current.get(a.id);
+			if (mine) {
+				if (!seen.has(a.id)) out.push(guardEmbedded(mine, a));
+				seen.add(a.id);
+			} else if (a.source !== "pdf") out.push(a);
+		}
+		return [...[...current.values()].filter((a) => !seen.has(a.id)), ...out];
+	}
+	function pruneSelection(next) {
+		const known = new Set(next.map((a) => a.id));
+		const current = selection.get();
+		if (current.every((id) => known.has(id))) return;
+		selection.set(current.filter((id) => known.has(id)));
+	}
+	return {
+		mode: opts.mode.mode,
+		list: readonly(list),
+		selection: readonly(selection),
+		defaults: opts.defaults,
+		get: (id) => list.get().find((a) => a.id === id),
+		_getProposed: (id) => findIn(basis(), id),
+		byPage: (page) => list.get().filter((a) => a.page === page),
+		completeInput,
+		add(input) {
+			const a = completeInput(input);
+			if (findIn(basis(), a.id)) throw new Error(`An annotation with id ${a.id} already exists`);
+			if (destroyed) return a;
+			const replaced = a.type === "mask" ? basis().filter((x) => x.type === "mask" && x.page === a.page && x.source !== "pdf") : [];
+			const gone = new Set(replaced.map((x) => x.id));
+			for (const x of replaced) clearPending(changeKey({
+				kind: "add",
+				annotation: x
+			}));
+			commit([...basis().filter((x) => !gone.has(x.id)), a], {
+				kind: "add",
+				annotation: a
+			});
+			if (!controlled && gone.size > 0) pruneSelection(list.get());
+			return a;
+		},
+		update(id, patch) {
+			const before = findIn(basis(), id);
+			if (destroyed || !before) return void 0;
+			if (before.locked && Object.keys(patch).some((k) => LOCKED_KEYS.has(k))) return void 0;
+			const candidate = {
+				...before,
+				...patch,
+				...mergedStyle(before, patch),
+				id: before.id,
+				type: before.type,
+				createdAt: before.createdAt,
+				source: before.source,
+				modifiedAt: now()
+			};
+			if (before.source === "pdf") keepKey(candidate, before, "locked");
+			const after = AnnotationSchema.parse(candidate);
+			const swap = (items) => items.map((a) => a.id === id ? after : a);
+			const next = swap(basis());
+			const change = {
+				kind: "update",
+				id,
+				before,
+				after
+			};
+			if (controlled && before.source === "pdf") {
+				list.set(swap(list.get()));
+				if (proposed) proposed = next;
+				emitter.emit("change", change);
+			} else commit(next, change);
+			return after;
+		},
+		remove(id) {
+			const items = basis();
+			const target = findIn(items, id);
+			if (destroyed || !target || target.locked) return false;
+			const doomed = /* @__PURE__ */ new Set([id]);
+			let grew = true;
+			while (grew) {
+				grew = false;
+				for (const a of items) if (a.inReplyTo !== void 0 && doomed.has(a.inReplyTo) && !doomed.has(a.id)) {
+					doomed.add(a.id);
+					grew = true;
+				}
+			}
+			const next = items.filter((a) => !doomed.has(a.id));
+			commit(next, {
+				kind: "remove",
+				annotation: target,
+				removed: [target, ...items.filter((a) => a.id !== id && doomed.has(a.id))]
+			});
+			if (!controlled) pruneSelection(next);
+			return true;
+		},
+		select(ids) {
+			const known = new Set(basis().map((a) => a.id));
+			selection.set(ids.filter((id) => known.has(id)));
+		},
+		replaceAll(list, reason) {
+			if (destroyed) return;
+			const next = controlled ? [...list] : withEmbedded(list);
+			commit(next, {
+				kind: "replace",
+				reason
+			});
+			if (!controlled) pruneSelection(next);
+		},
+		setControlledValue(value) {
+			if (!controlled) throw new TypeError("setControlledValue is only valid in controlled mode");
+			if (destroyed) return;
+			const embedded = list.get().filter((a) => a.source === "pdf");
+			const embeddedIds = new Set(embedded.map((a) => a.id));
+			const next = [...embedded, ...value.filter((a) => !embeddedIds.has(a.id))];
+			list.set(next);
+			proposed = void 0;
+			for (const [key, entry] of [...pending]) if (isApplied(entry.change, next)) clearPending(key);
+			pruneSelection(next);
+			emitter.emit("change", {
+				kind: "replace",
+				reason: "sync"
+			});
+		},
+		_setEmbedded(items) {
+			if (destroyed) return;
+			const ids = new Set(items.map((a) => a.id));
+			const next = [...items, ...list.get().filter((a) => a.source !== "pdf" && !ids.has(a.id))];
+			proposed = void 0;
+			list.set(next);
+			pruneSelection(next);
+			emitter.emit("change", {
+				kind: "replace",
+				reason: "import"
+			});
+		},
+		on: (event, fn) => emitter.on(event, fn),
+		destroy() {
+			destroyed = true;
+			proposed = void 0;
+			for (const key of [...pending.keys()]) clearPending(key);
+			emitter.clear();
+		}
+	};
+}
+//#endregion
+//#region src/model/page-cache.ts
+function createPageCache(fetch) {
+	const cache = /* @__PURE__ */ new Map();
+	return {
+		get(index) {
+			const cached = cache.get(index);
+			if (cached) return cached;
+			const fetched = fetch(index);
+			cache.set(index, fetched);
+			fetched.catch(() => {
+				if (cache.get(index) === fetched) cache.delete(index);
+			});
+			return fetched;
+		},
+		clear: () => cache.clear()
+	};
+}
+//#endregion
+//#region src/model/pages.ts
+function pageInfoFromProxy(page, index) {
+	const [x1, y1, x2, y2] = page.view;
+	const box = {
+		x: Math.min(x1, x2),
+		y: Math.min(y1, y2),
+		width: Math.abs(x2 - x1),
+		height: Math.abs(y2 - y1)
+	};
+	return {
+		index,
+		box,
+		rotate: normaliseRotation(page.rotate),
+		userUnit: page.userUnit > 0 ? page.userUnit : 1,
+		width: box.width,
+		height: box.height
+	};
+}
+/** PDF.js already rejects /Rotate values that are not multiples of 90; this also folds negatives. */
+function normaliseRotation(rotate) {
+	return (Math.round(rotate / 90) * 90 % 360 + 360) % 360;
+}
+//#endregion
+//#region src/model/source.ts
+function resolveSource(src, fetchImpl = globalThis.fetch) {
+	if (typeof src === "string") return {
+		key: src,
+		bytes: () => fetchBytes(src, fetchImpl)
+	};
+	if (src instanceof ArrayBuffer || src instanceof Uint8Array) {
+		const data = toBytes(src);
+		return {
+			key: `bytes:${v7()}`,
+			bytes: () => Promise.resolve(data.slice())
+		};
+	}
+	if ("url" in src) {
+		const { url } = src;
+		return {
+			key: src.key,
+			bytes: () => fetchBytes(url, fetchImpl)
+		};
+	}
+	if ("data" in src) {
+		const data = toBytes(src.data);
+		return {
+			key: src.key,
+			bytes: () => Promise.resolve(data.slice())
+		};
+	}
+	const blob = src;
+	return {
+		key: `bytes:${v7()}`,
+		bytes: async () => new Uint8Array(await blob.arrayBuffer())
+	};
+}
+/**
+* A view over the host's bytes. `bytes()` hands PDF.js a copy each time: PDF.js transfers the
+* buffer it is given to its worker, which would empty the host's array and break a reopen
+* (a password retry, for one).
+*/
+function toBytes(data) {
+	return data instanceof Uint8Array ? data : new Uint8Array(data);
+}
+async function fetchBytes(url, fetchImpl) {
+	if (typeof fetchImpl !== "function") throw new InkError("SourceFetchFailed", "No fetch implementation available for URL sources", { url });
+	let res;
+	try {
+		res = await fetchImpl(url, { credentials: "same-origin" });
+	} catch (cause) {
+		throw new InkError("SourceFetchFailed", `Could not fetch ${url}`, { url }, cause);
+	}
+	if (!res.ok) throw new InkError("SourceFetchFailed", `Fetching ${url} returned HTTP ${res.status}`, {
+		url,
+		status: res.status
+	});
+	try {
+		return new Uint8Array(await res.arrayBuffer());
+	} catch (cause) {
+		throw new InkError("SourceFetchFailed", `Reading the body of ${url} failed`, { url }, cause);
+	}
+}
+//#endregion
+//#region src/model/text.ts
+/** Fractions of the font size used when PDF.js has no usable metrics for the font. */
+const FALLBACK_ASCENT = .75;
+const FALLBACK_DESCENT = .25;
+/**
+* Converts `getTextContent()` output to user-space boxes.
+*
+* For an item with transform [a, b, c, d, e, f] (already in user space):
+* - (e, f) is the start of the run on the baseline;
+* - u = (a, b) / |(a, b)| is the baseline direction, along which the run advances `width`;
+* - v = (c, d) / |(c, d)| is the glyph-up direction, and `fontSize` = |(c, d)|;
+* - the box spans from `descent * fontSize` below the baseline to `ascent * fontSize` above it,
+*   using the font's ascent/descent from `styles` when PDF.js provides them, else 0.75 / 0.25.
+*
+* So p3 = (e, f) - v * descent * fontSize, p4 = p3 + u * width, p1 = p3 + v * (ascent + descent) * fontSize,
+* p2 = p4 + (p1 - p3). `rect` is the axis-aligned bounding box of the quad.
+*/
+function textContentFromPdfjs(page, tc) {
+	const items = [];
+	for (const raw of tc.items) {
+		if (!("str" in raw)) continue;
+		const item = raw;
+		const [a, b, c, d, e, f] = item.transform;
+		const baseLen = Math.hypot(a, b);
+		const fontSize = Math.hypot(c, d);
+		const u = baseLen === 0 ? {
+			x: 1,
+			y: 0
+		} : {
+			x: a / baseLen,
+			y: b / baseLen
+		};
+		const v = fontSize === 0 ? {
+			x: -u.y,
+			y: u.x
+		} : {
+			x: c / fontSize,
+			y: d / fontSize
+		};
+		const { ascent, descent } = metrics(tc.styles[item.fontName]);
+		const below = descent * fontSize;
+		const total = (ascent + descent) * fontSize;
+		const w = item.width;
+		const p3 = {
+			x: e - v.x * below,
+			y: f - v.y * below
+		};
+		const p4 = {
+			x: p3.x + u.x * w,
+			y: p3.y + u.y * w
+		};
+		const quad = {
+			p1: {
+				x: p3.x + v.x * total,
+				y: p3.y + v.y * total
+			},
+			p2: {
+				x: p4.x + v.x * total,
+				y: p4.y + v.y * total
+			},
+			p3,
+			p4
+		};
+		items.push({
+			str: item.str,
+			dir: isDir(item.dir) ? item.dir : "ltr",
+			fontName: item.fontName,
+			fontSize,
+			hasEOL: item.hasEOL,
+			quad,
+			rect: rectFromQuad(quad)
+		});
+	}
+	return {
+		page,
+		items
+	};
+}
+function metrics(style) {
+	if (!style || style.vertical) return {
+		ascent: FALLBACK_ASCENT,
+		descent: FALLBACK_DESCENT
+	};
+	const ascent = style.ascent;
+	const descent = Math.abs(style.descent);
+	if (!(ascent > 0) || !Number.isFinite(descent) || ascent + descent <= 0) return {
+		ascent: FALLBACK_ASCENT,
+		descent: FALLBACK_DESCENT
+	};
+	return {
+		ascent,
+		descent
+	};
+}
+function isDir(dir) {
+	return dir === "ltr" || dir === "rtl" || dir === "ttb";
+}
+//#endregion
+//#region src/model/document.ts
+/**
+* Opens a document. Resolves once loading has finished, whether it succeeded or not:
+* check `status` or await `ready`, which rejects with the InkError. Only a missing
+* `assets` option (a programmer error) makes this promise itself reject.
+*/
+async function openDocument(source, options) {
+	assertAssets(options?.assets);
+	const resolved = resolveSource(source, options.fetch);
+	const status = writable({ state: "loading" });
+	const pages = [];
+	const info = {
+		pageCount: 0,
+		isEncrypted: false
+	};
+	let pageCache;
+	let destroyed = false;
+	let handles;
+	let destroyTask;
+	const store = createAnnotationStore({
+		mode: options.annotations ?? { mode: "uncontrolled" },
+		defaults: options.defaults ?? staticDefaults
+	});
+	const embedded = [];
+	let preserved = [];
+	const destroyedError = () => new InkError("DocumentDestroyed", "The document has been destroyed");
+	const ready = (async () => {
+		const pdfjs = await loadPdfjs(options.assets);
+		const { task, proxy } = await openProxy(pdfjs, await resolved.bytes(), {
+			assets: options.assets,
+			password: options.password,
+			verbosity: options.verbosity
+		});
+		destroyTask = () => task.destroy();
+		const cache = createPageCache((index) => proxy.getPage(index + 1));
+		pageCache = cache;
+		const getPage = (index) => {
+			if (destroyed) return Promise.reject(destroyedError());
+			if (!Number.isInteger(index) || index < 0 || index >= proxy.numPages) return Promise.reject(new InkError("PageOutOfRange", `Page ${index} does not exist`, {
+				index,
+				pageCount: proxy.numPages
+			}));
+			return cache.get(index);
+		};
+		handles = {
+			module: pdfjs,
+			proxy,
+			getPage
+		};
+		const docInfo = (await proxy.getMetadata().catch(() => {}))?.info ?? {};
+		const title = nonEmptyString(docInfo.Title);
+		const author = nonEmptyString(docInfo.Author);
+		if (title !== void 0) info.title = title;
+		if (author !== void 0) info.author = author;
+		info.pageCount = proxy.numPages;
+		info.isEncrypted = docInfo.EncryptFilterName !== null && docInfo.EncryptFilterName !== void 0;
+		for (let i = 0; i < proxy.numPages; i++) pages.push(pageInfoFromProxy(await getPage(i), i));
+		const importedAt = (/* @__PURE__ */ new Date()).toISOString();
+		const perPage = await mapInOrder(proxy.numPages, EMBEDDED_CONCURRENCY, async (i) => {
+			return importEmbeddedPage(i, await (await getPage(i)).getAnnotations().catch(() => {
+				return [];
+			}), importedAt);
+		});
+		embedded.push(...summarise(perPage.map((r) => r.counts)));
+		const fromFile = perPage.flatMap((r) => r.annotations);
+		if (fromFile.length > 0) store._setEmbedded(fromFile);
+	})().then(() => {
+		status.set({ state: "ready" });
+	}, (cause) => {
+		const error = isInkError(cause) ? cause : new InkError("InvalidPdf", errorMessage(cause), {}, cause);
+		if (error.code === "PasswordRequired") info.isEncrypted = true;
+		status.set({
+			state: "error",
+			error
+		});
+		throw error;
+	});
+	await ready.catch(() => void 0);
+	const historyOption = options.history ?? true;
+	const historyLimit = historyOption === false ? 0 : historyOption === true ? void 0 : historyOption.limit;
+	const history = createHistory(store, historyLimit === void 0 ? {} : { limit: historyLimit });
+	return {
+		key: resolved.key,
+		status: readonly(status),
+		ready,
+		pages,
+		info,
+		async text(page) {
+			if (destroyed) throw destroyedError();
+			if (!handles) throw statusError(status.get());
+			return textContentFromPdfjs(page, await (await handles.getPage(page)).getTextContent());
+		},
+		annotations: store,
+		embedded,
+		history,
+		exportAnnotations(format) {
+			if (format !== "json") throw new TypeError(`Unsupported export format ${String(format)}`);
+			return exportAnnotations(store, preserved, resolved.key);
+		},
+		importAnnotations(data, opts = { mode: "replace" }) {
+			const plan = planImport(store, data, opts);
+			preserved = opts.mode === "replace" ? plan.result.unknown : [...preserved.filter((u) => !plan.ids.has(u.id)), ...plan.result.unknown];
+			plan.apply();
+			return plan.result;
+		},
+		save() {
+			return Promise.reject(new InkError("EngineUnavailable", "Saving needs @inkbar/engine, which is not registered. Use exportAnnotations(\"json\") to keep annotations without writing the PDF."));
+		},
+		destroy() {
+			if (destroyed) return;
+			destroyed = true;
+			history.destroy();
+			store.destroy();
+			pageCache?.clear();
+			if (destroyTask) teardown(destroyTask);
+		},
+		get _pdfjs() {
+			if (!handles) throw statusError(status.get());
+			return handles;
+		}
+	};
+}
+const EMBEDDED_CONCURRENCY = 8;
+/** Runs `task(0..count-1)` with at most `limit` in flight; results come back in index order. */
+async function mapInOrder(count, limit, task) {
+	const results = new Array(count);
+	let next = 0;
+	const worker = async () => {
+		while (next < count) {
+			const i = next++;
+			results[i] = await task(i);
+		}
+	};
+	await Promise.all(Array.from({ length: Math.min(limit, count) }, worker));
+	return results;
+}
+function teardown(destroyTask) {
+	destroyTask().catch(() => {});
+}
+function statusError(s) {
+	return s.state === "error" ? s.error : new InkError("InvalidPdf", "The document has not finished loading");
+}
+function nonEmptyString(value) {
+	return typeof value === "string" && value !== "" ? value : void 0;
+}
+function errorMessage(cause) {
+	if (cause instanceof Error) return cause.message;
+	return String(cause);
+}
+const shift = (p, dx, dy) => ({
+	x: p.x + dx,
+	y: p.y + dy
+});
+/** The geometry patch that translates `a` by (dx, dy) in user space. */
+function translated(a, dx, dy) {
+	const patch = { rect: translateRect(a.rect, dx, dy) };
+	if ("quads" in a && a.quads) patch.quads = a.quads.map((q) => translateQuad(q, dx, dy));
+	if ("callout" in a && a.callout) patch.callout = a.callout.map((p) => shift(p, dx, dy));
+	switch (a.type) {
+		case "line":
+			patch.start = shift(a.start, dx, dy);
+			patch.end = shift(a.end, dx, dy);
+			break;
+		case "polyline":
+		case "polygon":
+			patch.vertices = a.vertices.map((p) => shift(p, dx, dy));
+			break;
+		case "ink": patch.inklist = a.inklist.map((path) => path.map((p) => shift(p, dx, dy)));
+	}
+	return patch;
+}
+/**
+* True when `rect` is the annotation's whole shape, so resizing means changing `rect`: area
+* redactions, free text, squares, circles, stamps, loupes and masks. Text-derived marks (quads), note icons and
+* point-based shapes are not.
+*/
+function hasRectGeometry(a) {
+	switch (a.type) {
+		case "redact": return a.quads === void 0 || a.quads.length === 0;
+		case "freetext":
+		case "square":
+		case "circle":
+		case "stamp":
+		case "loupe":
+		case "mask": return true;
+		default: return false;
+	}
+}
+/**
+* Grows (positive) or shrinks (negative) a rect by `dw` and `dh` points, keeping its top-left
+* corner (user space: left edge and top edge, `y + height`) where it is. Neither side goes
+* below `MIN_SIZE`. With `keepAspect`, the side that changes leads and the other follows it in
+* proportion (the width when both change).
+*/
+function resizedRect(r, dw, dh, keepAspect = false) {
+	let width = Math.max(1, r.width + dw);
+	let height = Math.max(1, r.height + dh);
+	if (keepAspect && r.width > 0 && r.height > 0) {
+		const aspect = r.width / r.height;
+		if (dw !== 0) height = width / aspect;
+		else width = height * aspect;
+		const grow = Math.max(1 / width, 1 / height, 1);
+		width *= grow;
+		height *= grow;
+	}
+	const top = r.y + r.height;
+	return {
+		x: r.x,
+		y: top - height,
+		width,
+		height
+	};
+}
+/**
+* True for highlight, underline, strikeout and squiggly: marks on text, which a drag passes
+* through to text selection and a click selects.
+*/
+function isTextMarkup(a) {
+	return a.type === "highlight" || a.type === "underline" || a.type === "strikeout" || a.type === "squiggly";
+}
+/**
+* True for the point-based shapes a corner handle resizes by scaling their points: polylines,
+* polygons and ink. With `hasRectGeometry`, the annotations that get corner handles.
+*/
+function scalesPoints(a) {
+	return a.type === "polyline" || a.type === "polygon" || a.type === "ink";
+}
+/** True when a corner handle resizes `a`: rect-shaped types and point-based shapes. */
+function hasCornerHandles(a) {
+	return hasRectGeometry(a) || scalesPoints(a);
+}
+/**
+* The geometry patch that maps `a` from the box `from` onto the box `to`, both in user space:
+* `rect`, every point field (quads, ink paths, vertices, line ends, callout) and a free text's
+* `fringe` scale with the boxes. Stroke widths and font sizes stay as they are.
+*/
+function scaled(a, from, to) {
+	const sx = from.width === 0 ? 1 : to.width / from.width;
+	const sy = from.height === 0 ? 1 : to.height / from.height;
+	const map = (p) => ({
+		x: to.x + (p.x - from.x) * sx,
+		y: to.y + (p.y - from.y) * sy
+	});
+	const sameBox = (r) => r.x === from.x && r.y === from.y && r.width === from.width && r.height === from.height;
+	const patch = { rect: sameBox(a.rect) ? { ...to } : {
+		...map(a.rect),
+		width: a.rect.width * sx,
+		height: a.rect.height * sy
+	} };
+	if ("quads" in a && a.quads) patch.quads = a.quads.map((q) => ({
+		p1: map(q.p1),
+		p2: map(q.p2),
+		p3: map(q.p3),
+		p4: map(q.p4)
+	}));
+	if ("callout" in a && a.callout) patch.callout = a.callout.map(map);
+	if (a.type === "freetext" && a.fringe) patch.fringe = {
+		left: a.fringe.left * sx,
+		top: a.fringe.top * sy,
+		right: a.fringe.right * sx,
+		bottom: a.fringe.bottom * sy
+	};
+	switch (a.type) {
+		case "line":
+			patch.start = map(a.start);
+			patch.end = map(a.end);
+			break;
+		case "polyline":
+		case "polygon":
+			patch.vertices = a.vertices.map(map);
+			break;
+		case "ink": patch.inklist = a.inklist.map((path) => path.map(map));
+	}
+	return patch;
+}
+/**
+* The patch that moves one end of a line to `to` and refits `rect` to the new ends, padded by
+* half the stroke width on every side.
+*/
+function movedEndpoint(a, which, to) {
+	const start = which === "start" ? to : a.start;
+	const end = which === "end" ? to : a.end;
+	const pad = a.width / 2;
+	const x = Math.min(start.x, end.x);
+	const y = Math.min(start.y, end.y);
+	return {
+		[which]: { ...to },
+		rect: {
+			x: x - pad,
+			y: y - pad,
+			width: Math.abs(end.x - start.x) + pad * 2,
+			height: Math.abs(end.y - start.y) + pad * 2
+		}
+	};
+}
+/**
+* True for annotations whose resize keeps their aspect ratio without `Shift`: stamps, loupes,
+* masks and signatures (ink with subject `Signature`).
+*/
+function keepsAspect(a) {
+	if (a.type === "stamp" || a.type === "loupe" || a.type === "mask") return true;
+	return a.type === "ink" && a.subject === "Signature";
+}
+/**
+* True for a speech bubble: a standard free-text callout (`intent: 'FreeTextCallout'`, `rect`,
+* `fringe`, `callout`) with Inkbar's `cornerRadius`. Inkbar draws it as one rounded outline with
+* a wedge from where `callout`'s last point meets the box to the tip, `callout[0]`.
+*/
+function isBubble(a) {
+	return a.type === "freetext" && a.intent === "FreeTextCallout" && a.cornerRadius !== void 0 && a.callout !== void 0 && a.callout.length >= 2;
+}
+/** True for a free text with a callout to edit: a speech bubble or a standard callout. */
+function hasCallout(a) {
+	return isBubble(a) || isStandardCallout(a);
+}
+/**
+* The patch that puts a free text's text box at `box`, refitting `rect` and `fringe` around
+* it. A callout's points become `callout` (its own by default) and `rect` holds them too; any
+* other box keeps its fringe, or has `rect` equal to the box without one.
+*/
+function withBox(a, box, callout = a.callout) {
+	if (hasCallout(a) && callout) return {
+		...withCalloutBounds(box, callout, calloutStroke(a).width, a.head),
+		callout: callout.map((p) => ({ ...p }))
+	};
+	const f = a.fringe;
+	if (!f) return { rect: { ...box } };
+	return { rect: {
+		x: box.x - f.left,
+		y: box.y - f.bottom,
+		width: box.width + f.left + f.right,
+		height: box.height + f.bottom + f.top
+	} };
+}
+const EDGES = [
+	"left",
+	"right",
+	"bottom",
+	"top"
+];
+/**
+* The edge of `box` nearest `p`. `bubblePath` (dom/overlay-render.ts) picks the wedge's edge by
+* the same rule in CSS px; change both together.
+*/
+function nearestEdge(p, box) {
+	const gaps = {
+		left: Math.abs(p.x - box.x),
+		right: Math.abs(p.x - (box.x + box.width)),
+		bottom: Math.abs(p.y - box.y),
+		top: Math.abs(p.y - (box.y + box.height))
+	};
+	return EDGES.reduce((best, e) => gaps[e] < gaps[best] ? e : best);
+}
+/** The side of `box` that `p` lies furthest beyond. */
+function edgeBeyond(p, box) {
+	const beyond = {
+		left: box.x - p.x,
+		right: p.x - (box.x + box.width),
+		bottom: box.y - p.y,
+		top: p.y - (box.y + box.height)
+	};
+	return EDGES.reduce((best, e) => beyond[e] > beyond[best] ? e : best);
+}
+/**
+* `p` carried from the box `from` onto the box `to`: it keeps its fraction along the box edge
+* nearest it and its distance off that edge.
+*/
+function onMovedEdge(p, from, to) {
+	const edge = nearestEdge(p, from);
+	const along = (v, start, size, next, nextSize) => next + (size === 0 ? nextSize / 2 : (v - start) / size * nextSize);
+	if (edge === "left" || edge === "right") {
+		const x = edge === "left" ? from.x : from.x + from.width;
+		return {
+			x: (edge === "left" ? to.x : to.x + to.width) + p.x - x,
+			y: along(p.y, from.y, from.height, to.y, to.height)
+		};
+	}
+	const y = edge === "bottom" ? from.y : from.y + from.height;
+	const ny = edge === "bottom" ? to.y : to.y + to.height;
+	return {
+		x: along(p.x, from.x, from.width, to.x, to.width),
+		y: ny + p.y - y
+	};
+}
+/**
+* `p` placed on `box`'s `edge` at its own position along it, kept `margin` points clear of the
+* corners (at most half the edge).
+*/
+function ontoEdge(p, box, edge, margin) {
+	const clamp = (v, start, size) => {
+		const m = Math.min(margin, size / 2);
+		return Math.min(Math.max(v, start + m), start + size - m);
+	};
+	if (edge === "left" || edge === "right") return {
+		x: edge === "left" ? box.x : box.x + box.width,
+		y: clamp(p.y, box.y, box.height)
+	};
+	return {
+		x: clamp(p.x, box.x, box.width),
+		y: edge === "bottom" ? box.y : box.y + box.height
+	};
+}
+/**
+* The patch that resizes a free text's text box to `to`. A callout's tip and bend stay where
+* they are and its last point moves with the box edge it sits on (`onMovedEdge`).
+*/
+function resizedBox(a, to) {
+	if (!hasCallout(a)) return withBox(a, to);
+	const from = freeTextBox(a);
+	const last = a.callout.length - 1;
+	return withBox(a, to, a.callout.map((p, i) => i === last ? onMovedEdge(p, from, to) : p));
+}
+/**
+* The patch that moves a callout's tip to `to`, leaving its text box where it is. A callout
+* without a bend (every bubble) moves its edge point to the side the tip now lies furthest
+* beyond, at its own position along that side and clear of the corners, so the line or wedge
+* never crosses the box; on the same side it stays put. A bend and its edge point stay.
+*/
+function movedTip(a, to) {
+	const box = freeTextBox(a);
+	if (a.callout.length !== 2) return withBox(a, box, [to, ...a.callout.slice(1)]);
+	const edge = a.callout[1];
+	const side = edgeBeyond(to, box);
+	const margin = (a.cornerRadius ?? 0) + 8;
+	return withBox(a, box, [to, nearestEdge(edge, box) === side ? edge : ontoEdge(edge, box, side, margin)]);
+}
+//#endregion
+//#region src/model/annotations/style-map.ts
+/** For each type, the control-level props it supports and the field each writes. */
+const FIELDS = {
+	square: {
+		border: "color",
+		fill: "interiorColor",
+		opacity: "opacity",
+		width: "width",
+		dashes: "dashes"
+	},
+	circle: {
+		border: "color",
+		fill: "interiorColor",
+		opacity: "opacity",
+		width: "width",
+		dashes: "dashes"
+	},
+	polygon: {
+		border: "color",
+		fill: "interiorColor",
+		opacity: "opacity",
+		width: "width",
+		dashes: "dashes"
+	},
+	polyline: {
+		border: "color",
+		opacity: "opacity",
+		width: "width",
+		dashes: "dashes",
+		head: "head",
+		tail: "tail"
+	},
+	line: {
+		border: "color",
+		opacity: "opacity",
+		width: "width",
+		dashes: "dashes",
+		head: "head",
+		tail: "tail"
+	},
+	ink: {
+		border: "color",
+		opacity: "opacity",
+		width: "width"
+	},
+	highlight: {
+		border: "color",
+		opacity: "opacity"
+	},
+	underline: {
+		border: "color",
+		opacity: "opacity"
+	},
+	strikeout: {
+		border: "color",
+		opacity: "opacity"
+	},
+	squiggly: {
+		border: "color",
+		opacity: "opacity"
+	},
+	redact: {
+		border: "color",
+		opacity: "opacity"
+	},
+	freetext: {
+		border: "borderColor",
+		fill: "color",
+		textColor: "defaultStyle.color",
+		opacity: "opacity",
+		width: "width",
+		dashes: "dashes",
+		fontFamily: "defaultStyle.fontFamily",
+		fontSize: "defaultStyle.fontSize",
+		fontWeight: "defaultStyle.fontWeight",
+		fontStyle: "defaultStyle.fontStyle",
+		textDecoration: "defaultStyle.textDecoration",
+		textAlign: "defaultStyle.textAlign"
+	},
+	loupe: {
+		border: "color",
+		opacity: "opacity",
+		width: "width"
+	},
+	mask: {},
+	text: {},
+	stamp: {}
+};
+const GROUPS = {
+	square: "shape",
+	circle: "shape",
+	line: "shape",
+	polyline: "shape",
+	polygon: "shape",
+	loupe: "shape",
+	ink: "ink",
+	freetext: "text",
+	highlight: "markup",
+	underline: "markup",
+	strikeout: "markup",
+	squiggly: "markup",
+	redact: "redact",
+	text: void 0,
+	stamp: void 0,
+	mask: void 0
+};
+const SUPPORTED = new Map(Object.keys(FIELDS).map((type) => [type, new Set(Object.keys(FIELDS[type]))]));
+/**
+* The props a speech bubble (`intent: 'FreeTextCallout'`) takes from the `shape` group: its
+* outline, fill and opacity, as the shape tool creates it. Its text props stay in `text`.
+*/
+const BUBBLE_SHAPE_PROPS = /* @__PURE__ */ new Set([
+	"border",
+	"fill",
+	"opacity",
+	"width",
+	"dashes"
+]);
+/**
+* The style group an annotation's type belongs to; notes belong to none. With `key`, the group
+* that owns that prop on `a`: a speech bubble's outline and fill are `shape`'s, its text `text`'s.
+*/
+function styleGroupOf(a, key) {
+	if (key !== void 0 && a.type === "freetext" && a.intent === "FreeTextCallout" && BUBBLE_SHAPE_PROPS.has(key)) return "shape";
+	return GROUPS[a.type];
+}
+/** Every group that owns some prop on `a`: two for a speech bubble, else at most one. */
+function styleGroupsOf(a) {
+	const out = /* @__PURE__ */ new Set();
+	const own = GROUPS[a.type];
+	if (own) out.add(own);
+	for (const key of supportedProps(a.type)) {
+		const g = styleGroupOf(a, key);
+		if (g) out.add(g);
+	}
+	return [...out];
+}
+/** The types in `group`, from the same table `styleGroupOf` reads. */
+function typesInGroup(group) {
+	return Object.keys(GROUPS).filter((t) => GROUPS[t] === group);
+}
+/** The style group a type belongs to. */
+function styleGroupOfType(type) {
+	return GROUPS[type];
+}
+/** The control-level props `type` supports. */
+function supportedProps(type) {
+	return SUPPORTED.get(type) ?? /* @__PURE__ */ new Set();
+}
+/**
+* The control values a field leaves out: `normal` weight and style, no decoration. The field
+* is absent rather than holding them, as XFDF writes only what differs.
+*/
+const UNSET = {
+	fontWeight: "normal",
+	fontStyle: "normal",
+	textDecoration: "none"
+};
+/** The prefix of a field nested in `defaultStyle` (free text). */
+const STYLE = "defaultStyle.";
+/**
+* The field patch `patch` means on `type`. Props the type lacks are dropped. A `null` fill
+* becomes `interiorColor: undefined` (`color` on free text), which removes the fill when the
+* store applies it; so does `normal` weight or style and no decoration. Free-text text props go
+* into a partial `defaultStyle`, which the store merges into the current one.
+*/
+function toFields(type, patch) {
+	const fields = FIELDS[type];
+	const out = {};
+	for (const key of Object.keys(patch)) {
+		const field = fields[key];
+		if (field === void 0) continue;
+		const raw = patch[key];
+		const value = raw === null || raw === UNSET[key] ? void 0 : raw;
+		if (field.startsWith(STYLE)) {
+			const style = out.defaultStyle ??= {};
+			style[field.slice(13)] = value;
+		} else out[field] = value;
+	}
+	return out;
+}
+/** The control-level props an annotation shows, for the props its type supports. */
+function fromAnnotation(a) {
+	const fields = FIELDS[a.type];
+	const record = a;
+	const style = record.defaultStyle ?? {};
+	const out = {};
+	for (const key of Object.keys(fields)) {
+		const field = fields[key];
+		const value = field.startsWith(STYLE) ? style[field.slice(13)] : record[field];
+		if (value !== void 0) out[key] = value;
+		else if (key === "fill" || key === "dashes") out[key] = null;
+		else if (key === "head" || key === "tail") out[key] = "None";
+		else if (UNSET[key] !== void 0) out[key] = UNSET[key];
+	}
+	return out;
+}
+//#endregion
+//#region src/model/annotations/tool-style.ts
+const STYLE_GROUPS = [
+	"shape",
+	"ink",
+	"text",
+	"markup",
+	"redact"
+];
+/** Every prop some type in `group` supports. */
+function groupProps(group) {
+	const out = /* @__PURE__ */ new Set();
+	for (const type of typesInGroup(group)) for (const key of supportedProps(type)) out.add(key);
+	return out;
+}
+function sameValue(a, b) {
+	if (Object.is(a, b)) return true;
+	if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((v, i) => Object.is(v, b[i]));
+	return false;
+}
+function sameRecord(a, b) {
+	const ka = Object.keys(a);
+	if (ka.length !== Object.keys(b).length) return false;
+	return ka.every((k) => k in b && sameValue(a[k], b[k]));
+}
+function sameSet(a, b) {
+	return a.size === b.size && [...a].every((v) => b.has(v));
+}
+/**
+* A readable recomputed from `fn` whenever any source fires, subscribed to its sources only
+* while it has subscribers. Equal results (by `eq`) are not re-emitted and keep their identity.
+*/
+function computed(sources, fn, eq) {
+	const subs = /* @__PURE__ */ new Set();
+	let cached;
+	let stops;
+	/** Recomputes, keeping the previous value's identity when equal. True when it changed. */
+	const recompute = () => {
+		const next = fn();
+		if (cached && eq(next, cached.value)) return false;
+		cached = { value: next };
+		return true;
+	};
+	const refresh = () => {
+		if (!recompute() || !cached) return;
+		const value = cached.value;
+		for (const sub of [...subs]) sub(value);
+	};
+	return {
+		get: () => {
+			if (!stops) recompute();
+			return cached.value;
+		},
+		subscribe(sub) {
+			if (!stops) {
+				recompute();
+				stops = sources.map((s) => s.subscribe(refresh));
+			}
+			subs.add(sub);
+			return () => {
+				if (!subs.delete(sub) || subs.size > 0) return;
+				for (const stop of stops ?? []) stop();
+				stops = void 0;
+			};
+		}
+	};
+}
+function createToolStyle(deps) {
+	const { store, history, activeGroup } = deps;
+	const groups = new Map(STYLE_GROUPS.map((g) => [g, writable({})]));
+	const groupStore = (g) => {
+		const w = groups.get(g);
+		if (!w) throw new RangeError(`Unknown style group ${String(g)}`);
+		return w;
+	};
+	/** The selected annotations, including changes proposed to a controlled host. */
+	const selected = () => store.selection.get().map((id) => store._getProposed(id) ?? store.get(id)).filter((a) => a !== void 0);
+	const sources = [
+		store.list,
+		store.selection,
+		...groups.values(),
+		...deps.active ? [deps.active] : []
+	];
+	/** One value per prop over `items`, `'mixed'` where they differ. */
+	const styleOf = (items) => {
+		const out = {};
+		for (const a of items) {
+			const props = fromAnnotation(a);
+			for (const [key, value] of Object.entries(props)) if (!(key in out)) out[key] = value;
+			else if (out[key] !== "mixed" && !sameValue(out[key], value)) out[key] = "mixed";
+		}
+		return out;
+	};
+	const propsOf = (items) => {
+		const out = /* @__PURE__ */ new Set();
+		for (const a of items) for (const key of supportedProps(a.type)) out.add(key);
+		return out;
+	};
+	/** The selection, when it is non-empty and wholly in `group`. */
+	const selectedIn = (group) => {
+		const items = selected();
+		return items.length > 0 && items.every((a) => styleGroupsOf(a).includes(group)) ? items : null;
+	};
+	const current = computed(sources, () => {
+		const g = activeGroup();
+		if (!g) return styleOf(selected());
+		const items = selectedIn(g);
+		return items ? styleOf(items) : { ...groupStore(g).get() };
+	}, (a, b) => sameRecord(a, b));
+	const supported = computed(sources, () => {
+		const g = activeGroup();
+		if (!g) return propsOf(selected());
+		const items = selectedIn(g);
+		return items ? /* @__PURE__ */ new Set([...groupProps(g), ...propsOf(items)]) : groupProps(g);
+	}, sameSet);
+	const scopes = /* @__PURE__ */ new Map();
+	function scoped(group) {
+		const known = scopes.get(group);
+		if (known) return known;
+		groupStore(group);
+		const scope = {
+			group,
+			current: computed(sources, () => {
+				const items = selectedIn(group);
+				return items ? styleOf(items) : { ...groupStore(group).get() };
+			}, (a, b) => sameRecord(a, b)),
+			supported: computed(sources, () => {
+				const items = selectedIn(group);
+				return items ? propsOf(items) : groupProps(group);
+			}, sameSet),
+			set: (patch) => set(patch, {
+				group,
+				apply: selectedIn(group) !== null
+			})
+		};
+		scopes.set(group, scope);
+		return scope;
+	}
+	function set(patch, opts = {}) {
+		const items = selected();
+		const active = opts.group ?? activeGroup();
+		const keys = Object.keys(patch).filter((k) => patch[k] !== void 0);
+		const targets = /* @__PURE__ */ new Map();
+		if (active) targets.set(active, new Set(keys));
+		else for (const a of items) for (const key of keys) {
+			if (!supportedProps(a.type).has(key)) continue;
+			const g = styleGroupOf(a, key);
+			if (!g) continue;
+			const own = targets.get(g) ?? /* @__PURE__ */ new Set();
+			own.add(key);
+			targets.set(g, own);
+		}
+		for (const [g, own] of targets) {
+			const allowed = groupProps(g);
+			const next = { ...groupStore(g).get() };
+			let changed = false;
+			for (const key of own) {
+				if (!allowed.has(key)) continue;
+				next[key] = patch[key];
+				changed = true;
+			}
+			if (changed) groupStore(g).set(next);
+		}
+		if (!(opts.apply ?? (active === void 0 || selectedIn(active) !== null))) return;
+		const edits = items.filter((a) => !a.locked).map((a) => ({
+			id: a.id,
+			fields: refit(a, toFields(a.type, patch))
+		})).filter((e) => Object.keys(e.fields).length > 0);
+		if (edits.length === 0) return;
+		history.batch(() => {
+			for (const e of edits) store.update(e.id, e.fields);
+		});
+	}
+	/**
+	* `fields` with a callout's `rect` and `fringe` refit when they change its border width, so
+	* the bounds keep covering the leader, its ending and the outline.
+	*/
+	function refit(a, fields) {
+		if (!("width" in fields) || !hasCallout(a)) return fields;
+		const next = {
+			...a,
+			...fields
+		};
+		return {
+			...fields,
+			...withBox(next, freeTextBox(a))
+		};
+	}
+	/** `value`'s keys that hold something. */
+	const defined = (value) => Object.fromEntries(Object.entries(value ?? {}).filter(([, v]) => v !== void 0));
+	function resolve(group, input) {
+		const fields = toFields(input.type, groupStore(group).get());
+		const out = { ...input };
+		for (const [key, value] of Object.entries(fields)) if (key === "defaultStyle") out[key] = {
+			...defined(value),
+			...defined(out[key])
+		};
+		else if (value !== void 0 && out[key] === void 0) out[key] = value;
+		return out;
+	}
+	return {
+		get: (g) => groupStore(g).get(),
+		readable: (g) => {
+			const w = groupStore(g);
+			return {
+				get: () => w.get(),
+				subscribe: (fn) => w.subscribe(fn)
+			};
+		},
+		current,
+		supported,
+		set,
+		resolve,
+		scoped
+	};
+}
+//#endregion
+//#region src/model/annotations/suggestions.ts
+/**
+* Keeps a suggested redaction as the user's own: `origin` becomes `'user'` and the colour
+* goes from the confidence colour to the store's default redaction colour, so an accepted
+* mark looks like any other. The suggestion details stay on it. Returns the updated
+* annotation, or undefined (changing nothing) when `id` is not a suggested redaction or is
+* locked.
+*/
+function acceptSuggestion(store, id) {
+	const a = store._getProposed(id);
+	if (a?.type !== "redact" || a.origin !== "suggested" || a.locked) return void 0;
+	return store.update(id, {
+		origin: "user",
+		color: store.defaults.color("redact")
+	});
+}
+//#endregion
+//#region src/model/annotations/threads.ts
+function isThreadRoot(a) {
+	return a.type === "text" || isTextMarkup(a);
+}
+/**
+* True for a reply: an annotation whose `inReplyTo` names a thread root (a note or text markup)
+* in `list`. Replies show in the thread popover only, never on the page.
+*/
+function isReply(a, list) {
+	if (a.inReplyTo === void 0) return false;
+	const parent = list.find((x) => x.id === a.inReplyTo);
+	return parent !== void 0 && isThreadRoot(parent);
+}
+/** `list` less its replies (see `isReply`), in the same order. */
+function withoutReplies(list) {
+	const roots = new Set(list.filter(isThreadRoot).map((a) => a.id));
+	return list.filter((a) => a.inReplyTo === void 0 || !roots.has(a.inReplyTo));
+}
+/** Direct replies to `id`, in creation order. */
+function repliesTo(list, id) {
+	return list.filter((a) => a.inReplyTo === id).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+}
+/**
+* The top of a thread: follows `inReplyTo` up through notes, stopping at text markup (which
+* roots a thread of its own), a missing parent, a parent that cannot root a thread, or a
+* cycle. Null when `start` is neither a note nor text markup.
+*/
+function threadRoot(list, start) {
+	if (!isThreadRoot(start)) return null;
+	const seen = /* @__PURE__ */ new Set([start.id]);
+	let current = start;
+	while (current.type === "text" && current.inReplyTo) {
+		const id = current.inReplyTo;
+		const parent = list.find((a) => a.id === id);
+		if (!parent || !isThreadRoot(parent) || seen.has(parent.id)) break;
+		seen.add(parent.id);
+		current = parent;
+	}
+	return current;
+}
+/** The root, then every reply below it, depth first, each level in creation order. */
+function threadOf(list, root) {
+	const out = [root];
+	const seen = /* @__PURE__ */ new Set([root.id]);
+	const visit = (id) => {
+		for (const r of repliesTo(list, id)) {
+			if (seen.has(r.id)) continue;
+			seen.add(r.id);
+			out.push(r);
+			visit(r.id);
+		}
+	};
+	visit(root.id);
+	return out;
+}
+/**
+* An unlocked root note with no text and no replies: nothing a reader would miss. Always
+* false for text markup, which is worth keeping without a comment.
+*/
+function isAbandonedNote(a, list) {
+	if (a.type !== "text" || a.locked || a.inReplyTo || a.contents?.trim()) return false;
+	return repliesTo(list, a.id).length === 0;
+}
+//#endregion
+//#region src/model/annotations/shape-geometry.ts
+/** The kinds the shape menu offers today, in menu order. Later kinds extend this. */
+const SHAPE_KINDS = [
+	"line",
+	"arrow",
+	"rectangle",
+	"roundedRectangle",
+	"ellipse",
+	"bubble",
+	"star",
+	"polygon",
+	"loupe",
+	"mask",
+	"ovalMask"
+];
+const DEFAULT_SHAPE_OPTIONS = {
+	kind: "rectangle",
+	points: 5,
+	sides: 6
+};
+const POINTER_ONLY = /* @__PURE__ */ new Set([
+	"loupe",
+	"mask",
+	"ovalMask"
+]);
+/**
+* True for kinds only a pointer creates: the loupe and the mask. `Enter` with the shape tool
+* does not place them.
+*/
+function isPointerOnlyKind(kind) {
+	return POINTER_ONLY.has(kind);
+}
+/** How strongly a new mask dims the page. */
+const DEFAULT_MASK_DIM = .5;
+/** Side of the shape a click or Enter places, in points. */
+const DEFAULT_SHAPE_SIZE = 72;
+/** Corner radius of a new rounded rectangle, in points. */
+const DEFAULT_CORNER_RADIUS = 8;
+/** How far below and left of its anchor a new speech bubble's tail tip sits, in points. */
+const BUBBLE_TAIL = 24;
+/** A new speech bubble's outline width, in points, before the style group's applies. */
+const BUBBLE_WIDTH = 1;
+const clean = (n) => n + 0;
+/** The box between two corners. */
+function rectOf(a, b) {
+	return {
+		x: Math.min(a.x, b.x),
+		y: Math.min(a.y, b.y),
+		width: Math.abs(b.x - a.x),
+		height: Math.abs(b.y - a.y)
+	};
+}
+/** Vertices round the ellipse inscribed in `rect`, the first at the top centre, clockwise on the page. */
+function ring(rect, count, radius) {
+	const cx = rect.x + rect.width / 2;
+	const cy = rect.y + rect.height / 2;
+	return Array.from({ length: count }, (_, i) => {
+		const angle = i * 2 * Math.PI / count;
+		const r = radius(i);
+		return {
+			x: clean(cx + rect.width / 2 * r * Math.sin(angle)),
+			y: clean(cy + rect.height / 2 * r * Math.cos(angle))
+		};
+	});
+}
+/** A star's `2 * points` vertices, outer and inner alternating, the first at the top centre. */
+function starVertices(rect, points, innerRatio = .5) {
+	return ring(rect, Math.max(2, Math.round(points)) * 2, (i) => i % 2 === 0 ? 1 : innerRatio);
+}
+/** A regular polygon's vertices on the inscribed ellipse, the first at the top centre. */
+function polygonVertices(rect, sides) {
+	return ring(rect, Math.max(3, Math.round(sides)), () => 1);
+}
+const LINE_KINDS = /* @__PURE__ */ new Set(["line", "arrow"]);
+/** True for kinds drawn between two endpoints rather than inside a box. */
+function isLineKind(kind) {
+	return LINE_KINDS.has(kind);
+}
+const H = Math.SQRT1_2;
+/** Unit steps every 45 degrees, counter-clockwise from +x (y up). */
+const EIGHT_WAYS = [
+	{
+		x: 1,
+		y: 0
+	},
+	{
+		x: H,
+		y: H
+	},
+	{
+		x: 0,
+		y: 1
+	},
+	{
+		x: -H,
+		y: H
+	},
+	{
+		x: -1,
+		y: 0
+	},
+	{
+		x: -H,
+		y: -H
+	},
+	{
+		x: 0,
+		y: -1
+	},
+	{
+		x: H,
+		y: -H
+	}
+];
+/**
+* Where the drag ends with Shift held: a square or circle for box kinds, the nearest 45 degree
+* angle for lines.
+*/
+function constrain(kind, start, end) {
+	const dx = end.x - start.x;
+	const dy = end.y - start.y;
+	if (isLineKind(kind)) {
+		const step = Math.round(Math.atan2(dy, dx) / (Math.PI / 4));
+		const u = EIGHT_WAYS[(step % 8 + 8) % 8];
+		const length = dx * u.x + dy * u.y;
+		return {
+			x: clean(start.x + length * u.x),
+			y: clean(start.y + length * u.y)
+		};
+	}
+	const size = Math.max(Math.abs(dx), Math.abs(dy));
+	return {
+		x: clean(start.x + (dx < 0 ? -size : size)),
+		y: clean(start.y + (dy < 0 ? -size : size))
+	};
+}
+/**
+* The two drag corners of the default-size shape centred on `at`. A line or arrow runs left to
+* right on the page as the file displays it: along user space turned anticlockwise by the
+* page's /Rotate `rotation`, which undoes the page's clockwise turn, as a signature is placed.
+*/
+function defaultEnds(kind, at, rotation = 0) {
+	const half = 36;
+	if (!isLineKind(kind)) return [{
+		x: at.x - half,
+		y: at.y - half
+	}, {
+		x: at.x + half,
+		y: at.y + half
+	}];
+	const rad = rotation * Math.PI / 180;
+	const dx = Math.round(Math.cos(rad)) * half;
+	const dy = Math.round(Math.sin(rad)) * half;
+	return [{
+		x: clean(at.x - dx),
+		y: clean(at.y - dy)
+	}, {
+		x: clean(at.x + dx),
+		y: clean(at.y + dy)
+	}];
+}
+/** The annotation a shape kind creates between two points, or `undefined` for a kind without a creator yet. */
+function shapeInput(kind, page, start, end, opts) {
+	const rect = rectOf(start, end);
+	switch (kind) {
+		case "line": return {
+			type: "line",
+			page,
+			start,
+			end,
+			head: "None",
+			tail: "None"
+		};
+		case "arrow": return {
+			type: "line",
+			page,
+			start,
+			end,
+			tail: "OpenArrow",
+			intent: "LineArrow"
+		};
+		case "rectangle": return {
+			type: "square",
+			page,
+			rect
+		};
+		case "roundedRectangle": return {
+			type: "square",
+			page,
+			rect,
+			cornerRadius: 8
+		};
+		case "ellipse": return {
+			type: "circle",
+			page,
+			rect
+		};
+		case "bubble": {
+			const edge = {
+				x: clean(rect.x + rect.width / 4),
+				y: clean(rect.y)
+			};
+			const callout = [{
+				x: clean(edge.x - BUBBLE_TAIL),
+				y: clean(edge.y - BUBBLE_TAIL)
+			}, edge];
+			return {
+				type: "freetext",
+				page,
+				contents: "",
+				intent: "FreeTextCallout",
+				cornerRadius: 8,
+				width: BUBBLE_WIDTH,
+				...withCalloutBounds(rect, callout, BUBBLE_WIDTH, void 0),
+				callout
+			};
+		}
+		case "star": return {
+			type: "polygon",
+			page,
+			vertices: starVertices(rect, opts.points)
+		};
+		case "polygon": return {
+			type: "polygon",
+			page,
+			vertices: polygonVertices(rect, opts.sides)
+		};
+		case "loupe": return {
+			type: "loupe",
+			page,
+			rect: rectOf(start, constrain(kind, start, end)),
+			magnification: 2
+		};
+		case "mask":
+		case "ovalMask": return {
+			type: "mask",
+			page,
+			rect,
+			shape: kind === "mask" ? "rect" : "ellipse",
+			dim: DEFAULT_MASK_DIM
+		};
+		default: return;
+	}
+}
+//#endregion
+//#region src/model/recognise.ts
+/** The score a fit needs before a stroke is tidied into its shape. */
+const RECOGNISE_THRESHOLD = .8;
+/** Samples either side of a point that its turn is measured over. */
+const W = 3;
+/** Turns, over `2 * W` samples, that make a corner: outward, and back against the loop. */
+const CONVEX_TURN = 40 * Math.PI / 180;
+const CONCAVE_TURN = 15 * Math.PI / 180;
+/** Resampled points along the box diagonal. */
+const DENSITY = 50;
+/** A run of path is straight when its chord is at least this share of its length. */
+const STRAIGHT = .95;
+/** Corners whose neighbours this straight run through them (a turn under about 23 degrees) go. */
+const MERGE_STRAIGHT = .98;
+/** The ends of a closed stroke are within this share of the box diagonal. */
+const CLOSE_GAP = .25;
+/** Weights of a line's largest and mean straying from its chord, over its length. */
+const LINE_MAX = 2;
+const LINE_MEAN = 2;
+/** Weight of a polygon side's mean straying from its chord, over its length. */
+const SIDE_MEAN = 3;
+const dist = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
+const clamp01 = (n) => Math.min(Math.max(n, 0), 1);
+const round = (n) => Math.round(n * 100) / 100 + 0;
+const pt = (p) => ({
+	x: round(p.x),
+	y: round(p.y)
+});
+function boxOf(points) {
+	let minX = Infinity;
+	let minY = Infinity;
+	let maxX = -Infinity;
+	let maxY = -Infinity;
+	for (const p of points) {
+		minX = Math.min(minX, p.x);
+		minY = Math.min(minY, p.y);
+		maxX = Math.max(maxX, p.x);
+		maxY = Math.max(maxY, p.y);
+	}
+	return {
+		x: minX,
+		y: minY,
+		width: maxX - minX,
+		height: maxY - minY
+	};
+}
+const diagonal = (r) => Math.hypot(r.width, r.height);
+function lengthOf(points) {
+	let total = 0;
+	for (let i = 1; i < points.length; i++) total += dist(points[i - 1], points[i]);
+	return total;
+}
+/** Points every `spacing` along the path, the first and last included. */
+function resample(points, spacing) {
+	const out = [points[0]];
+	let carried = 0;
+	let prev = points[0];
+	for (let i = 1; i < points.length; i++) {
+		const next = points[i];
+		let d = dist(prev, next);
+		while (carried + d >= spacing) {
+			const t = (spacing - carried) / d;
+			const q = {
+				x: prev.x + t * (next.x - prev.x),
+				y: prev.y + t * (next.y - prev.y)
+			};
+			out.push(q);
+			prev = q;
+			d = dist(prev, next);
+			carried = 0;
+		}
+		carried += d;
+		prev = next;
+	}
+	const last = points[points.length - 1];
+	if (dist(out[out.length - 1], last) > spacing / 2) out.push(last);
+	else out[out.length - 1] = last;
+	return out;
+}
+/** Distance from `p` to the segment `a`–`b`. */
+function toSegment(p, a, b) {
+	const dx = b.x - a.x;
+	const dy = b.y - a.y;
+	const len2 = dx * dx + dy * dy;
+	const t = len2 === 0 ? 0 : clamp01(((p.x - a.x) * dx + (p.y - a.y) * dy) / len2);
+	return Math.hypot(p.x - (a.x + t * dx), p.y - (a.y + t * dy));
+}
+/** Path lengths from the first point: `cum[i]` is the length up to point `i`. */
+function cumulative(points) {
+	const cum = [0];
+	for (let i = 1; i < points.length; i++) cum.push(cum[i - 1] + dist(points[i - 1], points[i]));
+	return cum;
+}
+/**
+* Corner indices of the loop `r` (its last point joins its first), in order round it. A corner
+* is where the path turns sharply over a few samples: outward by more than `CONVEX_TURN`, or
+* back against the loop's own direction (a star's inner corner) by more than `CONCAVE_TURN`.
+*/
+function cornersOf(r) {
+	const n = r.length;
+	if (n < 8) return [];
+	const at = (i) => r[(i % n + n) % n];
+	const direction = Math.sign(winding(r, centroid(r))) || 1;
+	const turns = r.map((p, i) => {
+		const a = at(i - W);
+		const b = at(i + W);
+		const turn = Math.atan2(b.y - p.y, b.x - p.x) - Math.atan2(p.y - a.y, p.x - a.x);
+		return direction * (turn > Math.PI ? turn - 2 * Math.PI : turn < -Math.PI ? turn + 2 * Math.PI : turn);
+	});
+	/** 1 for an outward corner, -1 for an inward one, 0 for none. */
+	const kind = (i) => turns[i] > CONVEX_TURN ? 1 : turns[i] < -CONCAVE_TURN ? -1 : 0;
+	const start = turns.findIndex((_, i) => kind(i) === 0);
+	if (start < 0) return [];
+	const corners = [];
+	let best;
+	for (let k = 0; k <= n; k++) {
+		const i = (start + k) % n;
+		const c = k < n ? kind(i) : 0;
+		if (best !== void 0 && c !== kind(best)) {
+			corners.push(best);
+			best = void 0;
+		}
+		if (c !== 0 && (best === void 0 || Math.abs(turns[i]) > Math.abs(turns[best]))) best = i;
+	}
+	corners.sort((a, b) => a - b);
+	for (let k = 0; corners.length > 1 && k < corners.length;) {
+		const next = (k + 1) % corners.length;
+		if ((corners[next] - corners[k] + n) % n > 6) k++;
+		else corners.splice(Math.abs(turns[corners[k]]) < Math.abs(turns[corners[next]]) ? k : next, 1);
+	}
+	return mergeStraight(r, corners);
+}
+/** Drops corners whose neighbours run straight through them, the straightest first. */
+function mergeStraight(r, corners) {
+	const cum = cumulative(r);
+	const total = cum[cum.length - 1] + dist(r[r.length - 1], r[0]);
+	const arc = (a, b) => b > a ? cum[b] - cum[a] : total - cum[a] + cum[b];
+	const out = [...corners];
+	while (out.length > 3) {
+		let drop = -1;
+		let straightest = MERGE_STRAIGHT;
+		for (let k = 0; k < out.length; k++) {
+			const p = out[(k - 1 + out.length) % out.length];
+			const q = out[(k + 1) % out.length];
+			const a = arc(p, q);
+			const ratio = a === 0 ? 1 : dist(r[p], r[q]) / a;
+			if (ratio > straightest) {
+				straightest = ratio;
+				drop = k;
+			}
+		}
+		if (drop < 0) break;
+		out.splice(drop, 1);
+	}
+	return out;
+}
+/** Times the path winds round `c`, signed. */
+function winding(points, c) {
+	let total = 0;
+	for (let i = 0; i < points.length; i++) {
+		const a = points[i];
+		const b = points[(i + 1) % points.length];
+		let d = Math.atan2(b.y - c.y, b.x - c.x) - Math.atan2(a.y - c.y, a.x - c.x);
+		if (d > Math.PI) d -= 2 * Math.PI;
+		if (d < -Math.PI) d += 2 * Math.PI;
+		total += d;
+	}
+	return total / (2 * Math.PI);
+}
+/** Largest and mean distance of `points` from the line through `a` and `b`, over `|ab|`. */
+function deviation(points, a, b) {
+	const len = dist(a, b);
+	if (len === 0 || points.length === 0) return {
+		max: Infinity,
+		mean: Infinity
+	};
+	let max = 0;
+	let sum = 0;
+	for (const p of points) {
+		const d = Math.abs((b.x - a.x) * (a.y - p.y) - (a.x - p.x) * (b.y - a.y)) / len;
+		max = Math.max(max, d);
+		sum += d;
+	}
+	return {
+		max: max / len,
+		mean: sum / points.length / len
+	};
+}
+/** How straight a run from `a` to `b` is: 1 on the chord, falling as the path strays from it. */
+function straightness(points, a, b) {
+	const dev = deviation(points, a, b);
+	const bend = 1 - dist(a, b) / lengthOf(points);
+	return clamp01(1 - LINE_MAX * dev.max - LINE_MEAN * dev.mean - 2 * bend);
+}
+function fitLine(r) {
+	const a = r[0];
+	const b = r[r.length - 1];
+	if (dist(a, b) / lengthOf(r) < .8) return void 0;
+	return {
+		shape: {
+			kind: "line",
+			start: pt(a),
+			end: pt(b)
+		},
+		score: straightness(r, a, b)
+	};
+}
+/** An arrow whose head is drawn at the end of `r`: a straight shaft, then a short fold back. */
+function fitArrow(r) {
+	const from = r.map((p) => dist(p, r[0]));
+	const far = Math.max(...from);
+	let tipAt = from.findIndex((d) => d >= .97 * far);
+	while (tipAt + 1 < r.length && from[tipAt + 1] > from[tipAt]) tipAt++;
+	const shaft = r.slice(0, tipAt + 1);
+	const head = r.slice(tipAt + 1);
+	const tail = r[0];
+	const tip = r[tipAt];
+	const shaftLength = lengthOf(shaft);
+	const headLength = lengthOf([tip, ...head]);
+	if (shaftLength < .6 * (shaftLength + headLength) || headLength < .06 * shaftLength) return void 0;
+	const along = {
+		x: (tip.x - tail.x) / shaftLength,
+		y: (tip.y - tail.y) / shaftLength
+	};
+	const chord = dist(tail, tip);
+	if (chord / shaftLength < STRAIGHT) return void 0;
+	let off = 0;
+	for (const p of head) {
+		if (dist(p, tip) > .4 * chord) return void 0;
+		if ((p.x - tip.x) * along.x + (p.y - tip.y) * along.y > .08 * chord) return void 0;
+		off = Math.max(off, Math.abs((p.x - tip.x) * along.y - (p.y - tip.y) * along.x));
+	}
+	if (off < .04 * chord) return void 0;
+	return {
+		shape: {
+			kind: "arrow",
+			start: pt(tail),
+			end: pt(tip)
+		},
+		score: straightness(shaft, tail, tip)
+	};
+}
+/**
+* The stroke as a loop, evenly spaced all the way round (the gap between its ends bridged), an
+* overshoot past its start trimmed; undefined when the stroke is open.
+*/
+function loopOf(r, size, spacing) {
+	const n = r.length;
+	if (n < 8) return void 0;
+	let end = n - 1;
+	for (let i = Math.floor(n / 2); i < n; i++) if (dist(r[i], r[0]) < dist(r[end], r[0])) end = i;
+	if (dist(r[end], r[0]) > CLOSE_GAP * size || n - 1 - end > .25 * n) return void 0;
+	const loop = resample([...r.slice(0, end + 1), r[0]], spacing);
+	loop.pop();
+	return loop;
+}
+function fitEllipse(loop, box) {
+	const rx = box.width / 2;
+	const ry = box.height / 2;
+	if (rx === 0 || ry === 0) return void 0;
+	const cx = box.x + rx;
+	const cy = box.y + ry;
+	let sum = 0;
+	for (const p of loop) sum += Math.abs(Math.hypot((p.x - cx) / rx, (p.y - cy) / ry) - 1);
+	const mean = sum / loop.length;
+	return {
+		shape: {
+			kind: "ellipse",
+			rect: {
+				x: round(box.x),
+				y: round(box.y),
+				width: round(box.width),
+				height: round(box.height)
+			}
+		},
+		score: clamp01(1 - 3 * mean)
+	};
+}
+/** How closely the loop follows the polygon through `vertices`: 1 on it, falling with distance. */
+function polygonFit(loop, vertices, size) {
+	let sum = 0;
+	for (const p of loop) {
+		let best = Infinity;
+		for (let i = 0; i < vertices.length; i++) best = Math.min(best, toSegment(p, vertices[i], vertices[(i + 1) % vertices.length]));
+		sum += best;
+	}
+	return clamp01(1 - 12 * sum / loop.length / size);
+}
+/** Within `tolerance` radians of horizontal (0) or vertical (1); else -1. */
+function axisOf(a, b, tolerance) {
+	const angle = Math.abs(Math.atan2(b.y - a.y, b.x - a.x)) % Math.PI;
+	const fromH = Math.min(angle, Math.PI - angle);
+	const fromV = Math.abs(angle - Math.PI / 2);
+	if (fromH <= tolerance) return {
+		axis: 0,
+		off: fromH
+	};
+	if (fromV <= tolerance) return {
+		axis: 1,
+		off: fromV
+	};
+	return {
+		axis: -1,
+		off: Math.PI / 4
+	};
+}
+function fitRectangle(vertices, fit) {
+	if (vertices.length !== 4) return void 0;
+	const tolerance = 20 * Math.PI / 180;
+	let worst = 0;
+	for (let i = 0; i < 4; i++) {
+		const side = axisOf(vertices[i], vertices[(i + 1) % 4], tolerance);
+		if (side.axis < 0 || side.axis !== (axisOf(vertices[0], vertices[1], tolerance).axis + i) % 2) return void 0;
+		worst = Math.max(worst, side.off);
+	}
+	const xs = vertices.map((v) => v.x).sort((a, b) => a - b);
+	const ys = vertices.map((v) => v.y).sort((a, b) => a - b);
+	const left = (xs[0] + xs[1]) / 2;
+	const right = (xs[2] + xs[3]) / 2;
+	const bottom = (ys[0] + ys[1]) / 2;
+	const top = (ys[2] + ys[3]) / 2;
+	return {
+		shape: {
+			kind: "rectangle",
+			rect: {
+				x: round(left),
+				y: round(bottom),
+				width: round(right - left),
+				height: round(top - bottom)
+			}
+		},
+		score: clamp01(fit - worst / tolerance / 10)
+	};
+}
+/** The shape tool's star of `points` tips round `c`, tips at `radius`, the first at the top. */
+function regularStar(c, points, radius) {
+	return starVertices({
+		x: c.x - radius,
+		y: c.y - radius,
+		width: 2 * radius,
+		height: 2 * radius
+	}, points).map(pt);
+}
+const centroid = (points) => ({
+	x: points.reduce((s, p) => s + p.x, 0) / points.length,
+	y: points.reduce((s, p) => s + p.y, 0) / points.length
+});
+/** An outline star: an even number of corners alternating far from and near the centre. */
+function fitStar(vertices, fit) {
+	const k = vertices.length;
+	if (k % 2 !== 0 || k < 8 || k > 16) return void 0;
+	const c = centroid(vertices);
+	const radii = vertices.map((v) => dist(v, c));
+	const even = radii.filter((_, i) => i % 2 === 0);
+	const odd = radii.filter((_, i) => i % 2 === 1);
+	const [outer, inner] = Math.min(...even) > Math.max(...odd) ? [even, odd] : [odd, even];
+	if (Math.min(...outer) <= Math.max(...inner)) return void 0;
+	const mean = (xs) => xs.reduce((s, x) => s + x, 0) / xs.length;
+	if (mean(inner) / mean(outer) > .75) return void 0;
+	const spread = (Math.max(...outer) - Math.min(...outer)) / mean(outer);
+	return {
+		shape: {
+			kind: "star",
+			vertices: regularStar(c, k / 2, mean(outer))
+		},
+		score: clamp01(fit - Math.max(0, spread - .2))
+	};
+}
+/** A pentagram: five straight strokes that wind twice round the centre. */
+function fitPentagram(vertices, loop, size) {
+	if (vertices.length !== 5) return void 0;
+	const c = centroid(vertices);
+	const turns = Math.abs(winding(loop, c));
+	if (turns < 1.6 || turns > 2.4) return void 0;
+	const radii = vertices.map((v) => dist(v, c));
+	const mean = radii.reduce((s, x) => s + x, 0) / radii.length;
+	const spread = (Math.max(...radii) - Math.min(...radii)) / mean;
+	return {
+		shape: {
+			kind: "star",
+			vertices: regularStar(c, 5, mean)
+		},
+		score: clamp01(polygonFit(loop, vertices, size) - Math.max(0, spread - .2))
+	};
+}
+/** True when two sides of the polygon through `v` cross. */
+function crosses(v) {
+	const k = v.length;
+	const side = (a, b, c) => Math.sign((b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x));
+	for (let i = 0; i < k; i++) for (let j = i + 2; j < k; j++) {
+		if (i === 0 && j === k - 1) continue;
+		const [a, b, c, d] = [
+			v[i],
+			v[(i + 1) % k],
+			v[j],
+			v[(j + 1) % k]
+		];
+		if (side(a, b, c) * side(a, b, d) < 0 && side(c, d, a) * side(c, d, b) < 0) return true;
+	}
+	return false;
+}
+/** How straight the loop runs between consecutive corners: the worst side's score. */
+function sidesFit(loop, corners) {
+	let worst = 1;
+	for (let k = 0; k < corners.length; k++) {
+		const from = corners[k];
+		const to = corners[(k + 1) % corners.length];
+		const side = to > from ? loop.slice(from, to + 1) : [...loop.slice(from), ...loop.slice(0, to + 1)];
+		const a = side[0];
+		const b = side[side.length - 1];
+		const bend = 1 - dist(a, b) / lengthOf(side);
+		worst = Math.min(worst, clamp01(1 - SIDE_MEAN * deviation(side, a, b).mean - 2 * bend));
+	}
+	return worst;
+}
+function fitClosed(loop, size) {
+	const box = boxOf(loop);
+	const fits = [];
+	const corners = cornersOf(loop);
+	const vertices = corners.map((i) => loop[i]);
+	const pentagram = fitPentagram(vertices, loop, size);
+	if (pentagram) fits.push(pentagram);
+	const turns = Math.abs(winding(loop, {
+		x: box.x + box.width / 2,
+		y: box.y + box.height / 2
+	}));
+	if (turns < .8 || turns > 1.25) return fits;
+	const ellipse = fitEllipse(loop, box);
+	if (ellipse) fits.push(ellipse);
+	if (vertices.length < 3 || crosses(vertices)) return fits;
+	const fit = polygonFit(loop, vertices, size);
+	const rectangle = fitRectangle(vertices, fit);
+	if (rectangle) fits.push(rectangle);
+	else if (vertices.length <= 8) fits.push({
+		shape: {
+			kind: "polygon",
+			vertices: vertices.map(pt)
+		},
+		score: Math.min(fit, sidesFit(loop, corners))
+	});
+	const star = fitStar(vertices, fit);
+	if (star) fits.push(star);
+	return fits;
+}
+/**
+* The standard shape a single freehand stroke (user space points, in drawing order) is closest
+* to, and how well it fits, from 0 to 1. Tidy the stroke only when the score reaches
+* `RECOGNISE_THRESHOLD`. Undefined when no shape fits at all.
+*/
+function recogniseStroke(points) {
+	const clean = points.filter((p, i) => Number.isFinite(p.x) && Number.isFinite(p.y) && (i === 0 || p.x !== points[i - 1].x || p.y !== points[i - 1].y));
+	if (clean.length < 2) return void 0;
+	const size = diagonal(boxOf(clean));
+	if (size === 0) return void 0;
+	const spacing = Math.max(size / DENSITY, lengthOf(clean) / 1e3);
+	const r = resample(clean, spacing);
+	if (r.length < 2) return void 0;
+	const fits = [];
+	const line = fitLine(r);
+	if (line) fits.push(line);
+	const loop = loopOf(r, size, spacing);
+	if (loop) fits.push(...fitClosed(loop, size));
+	else for (const f of [fitArrow(r), fitArrow([...r].reverse())]) if (f) fits.push(f);
+	let best;
+	for (const f of fits) if (!best || f.score > best.score) best = f;
+	return best && {
+		shape: best.shape,
+		score: round(best.score)
+	};
+}
+//#endregion
+//#region src/model/signatures.ts
+/** How wide a placed signature is, in points. */
+const DEFAULT_SIGNATURE_WIDTH = 150;
+/** A placed ink signature's stroke width, in points. */
+const SIGNATURE_INK_WIDTH = 2;
+const Aspect = z.number().positive().finite();
+const TemplateSchema = z.discriminatedUnion("kind", [z.object({
+	id: z.string().min(1),
+	kind: z.literal("ink"),
+	inklist: z.array(z.array(PointSchema).min(1)).min(1),
+	pressure: z.array(z.array(z.number().min(0).max(1))).optional(),
+	aspect: Aspect
+}), z.object({
+	id: z.string().min(1),
+	kind: z.literal("image"),
+	imagedata: z.string().regex(IMAGE_DATA_URL),
+	aspect: Aspect
+})]).refine((t) => t.kind !== "ink" || !t.pressure || t.pressure.length === t.inklist.length && t.pressure.every((p, i) => p.length === t.inklist[i]?.length), {
+	message: "pressure must have the same shape as inklist",
+	path: ["pressure"]
+});
+/** The items that are valid templates; the rest are skipped. */
+function validTemplates(items) {
+	return items.flatMap((item) => {
+		const t = TemplateSchema.safeParse(item);
+		return t.success ? [t.data] : [];
+	});
+}
+const copy = (t) => JSON.parse(JSON.stringify(t));
+function upsert(list, t) {
+	const i = list.findIndex((x) => x.id === t.id);
+	return i < 0 ? [...list, copy(t)] : list.map((x, j) => j === i ? copy(t) : x);
+}
+/** Templates in memory, gone on reload. The default when a host passes no store. */
+function createMemorySignatureStore(initial = []) {
+	let items = initial.map(copy);
+	return {
+		list: () => Promise.resolve(items.map(copy)),
+		save(t) {
+			items = upsert(items, t);
+			return Promise.resolve();
+		},
+		remove(id) {
+			items = items.filter((x) => x.id !== id);
+			return Promise.resolve();
+		}
+	};
+}
+/**
+* Templates in `localStorage` under `key`, as a JSON array. Where storage is blocked (it refuses
+* even a tiny test write, as in some private windows) the templates stay in memory for the
+* page's life, so signing still works. Where storage works, or is full but holds a saved list,
+* and has no room for a change, the change is undone and `save` or `remove` rejects, so the host can say so. Stored entries it
+* cannot read, such as a later version's templates, are left out of `list` and kept on write.
+*/
+function createLocalSignatureStore(key) {
+	/** Usable storage, or undefined when it is missing or blocked. */
+	const storage = (() => {
+		try {
+			const s = globalThis.localStorage ?? void 0;
+			if (!s) return void 0;
+			const probe = `${key}:probe`;
+			try {
+				s.setItem(probe, "1");
+				s.removeItem(probe);
+			} catch {
+				return s.getItem(key) === null ? void 0 : s;
+			}
+			return s;
+		} catch {
+			return;
+		}
+	})();
+	/** The stored list; undefined when storage cannot be read. */
+	const read = () => {
+		if (!storage) return void 0;
+		try {
+			const raw = storage.getItem(key);
+			if (raw === null) return {
+				items: [],
+				unread: []
+			};
+			const parsed = JSON.parse(raw);
+			if (!Array.isArray(parsed)) return {
+				items: [],
+				unread: []
+			};
+			return {
+				items: validTemplates(parsed),
+				unread: parsed.filter((x) => validTemplates([x]).length === 0)
+			};
+		} catch (e) {
+			return e instanceof SyntaxError ? {
+				items: [],
+				unread: []
+			} : void 0;
+		}
+	};
+	let { items, unread } = read() ?? {
+		items: [],
+		unread: []
+	};
+	/** Picks up what another tab wrote. */
+	const sync = () => {
+		const stored = read();
+		if (stored) ({items, unread} = stored);
+	};
+	/** The id of an entry that may not be a template, if it has one. */
+	const idOf = (x) => typeof x === "object" && x !== null ? x.id : void 0;
+	/**
+	* Writes `next`, then adopts it; leaves everything as it was when storage refuses. Entries
+	* it cannot read go back after the templates, less any whose id a template now has.
+	*/
+	const commit = (next) => {
+		const ids = new Set(next.map((t) => t.id));
+		const kept = unread.filter((x) => idOf(x) === void 0 || !ids.has(idOf(x)));
+		if (storage) try {
+			storage.setItem(key, JSON.stringify([...next, ...kept]));
+		} catch (cause) {
+			return Promise.reject(new Error("The signature could not be saved: browser storage is full", { cause }));
+		}
+		items = next;
+		unread = kept;
+		return Promise.resolve();
+	};
+	return {
+		list() {
+			sync();
+			return Promise.resolve(items.map(copy));
+		},
+		save(t) {
+			sync();
+			return commit(upsert(items, t));
+		},
+		remove(id) {
+			sync();
+			return commit(items.filter((x) => x.id !== id));
+		}
+	};
+}
+/**
+* Fits strokes into a unit box, for an ink template. Points come in any y-up space; they go
+* out between 0 and 1 on both axes, and `aspect` is the box's width over its height. A flat
+* side is given 1% of the long side (a dot, a square), so the aspect stays finite, and the
+* strokes are centred across it.
+*/
+function normaliseInk(inklist) {
+	const all = inklist.flat();
+	const xs = all.map((p) => p.x);
+	const ys = all.map((p) => p.y);
+	const minX = Math.min(...xs);
+	const minY = Math.min(...ys);
+	const w = Math.max(...xs) - minX;
+	const h = Math.max(...ys) - minY;
+	const long = Math.max(w, h);
+	const boxW = long === 0 ? 1 : Math.max(w, long * .01);
+	const boxH = long === 0 ? 1 : Math.max(h, long * .01);
+	const map = (p) => ({
+		x: (p.x - minX + (boxW - w) / 2) / boxW,
+		y: (p.y - minY + (boxH - h) / 2) / boxH
+	});
+	return {
+		inklist: inklist.map((path) => path.map(map)),
+		aspect: boxW / boxH
+	};
+}
+/**
+* An ink template from strokes in any y-up space, with a new id. Throws a RangeError for no
+* strokes, an empty stroke, or pressure that does not have one value per point.
+*/
+function createInkTemplate(inklist, pressure) {
+	if (inklist.length === 0 || inklist.some((path) => path.length === 0)) throw new RangeError("A signature needs at least one stroke, and no empty strokes");
+	if (pressure && (pressure.length !== inklist.length || pressure.some((p, i) => p.length !== inklist[i].length))) throw new RangeError("pressure must have the same shape as inklist");
+	const fitted = normaliseInk(inklist);
+	return {
+		id: v7(),
+		kind: "ink",
+		inklist: fitted.inklist,
+		...pressure ? { pressure: pressure.map((p) => [...p]) } : {},
+		aspect: fitted.aspect
+	};
+}
+/** An image template, with a new id. Throws a TypeError unless `imagedata` is a PNG or JPEG data URL. */
+function createImageTemplate(imagedata, aspect) {
+	if (!IMAGE_DATA_URL.test(imagedata)) throw new TypeError("A signature image must be a PNG or JPEG data URL");
+	if (!(aspect > 0 && Number.isFinite(aspect))) throw new RangeError(`aspect must be positive, got ${aspect}`);
+	return {
+		id: v7(),
+		kind: "image",
+		imagedata,
+		aspect
+	};
+}
+/**
+* The annotation that places `t` on `page`, `width` points wide on screen and centred on
+* `centre` (user space). `rotation` is the page's /Rotate (clockwise): the signature is turned
+* back by as much, so it reads upright on the page as the file displays it. A viewer's view
+* rotation is left out; it turns the signature with the page like any annotation. Ink becomes `ink` with `subject: 'Signature'`, its strokes inset by half their
+* width; an image becomes a `stamp` with `subject: 'Signature'`.
+*/
+function placeSignature(t, page, centre, width = 150, rotation = 0) {
+	const height = width / t.aspect;
+	const sideways = rotation === 90 || rotation === 270;
+	const rw = sideways ? height : width;
+	const rh = sideways ? width : height;
+	const rect = {
+		x: centre.x - rw / 2,
+		y: centre.y - rh / 2,
+		width: rw,
+		height: rh
+	};
+	if (t.kind === "image") return {
+		type: "stamp",
+		page,
+		subject: "Signature",
+		imagedata: t.imagedata,
+		rect,
+		...rotation === 0 ? {} : { rotation }
+	};
+	const innerW = Math.max(width - 2, 0);
+	const innerH = Math.max(height - 2, 0);
+	const rad = rotation * Math.PI / 180;
+	const cos = Math.round(Math.cos(rad));
+	const sin = Math.round(Math.sin(rad));
+	const place = (p) => {
+		const u = (p.x - .5) * innerW;
+		const v = (p.y - .5) * innerH;
+		return {
+			x: centre.x + u * cos - v * sin,
+			y: centre.y + u * sin + v * cos
+		};
+	};
+	return {
+		type: "ink",
+		page,
+		subject: "Signature",
+		inklist: t.inklist.map((path) => path.map(place)),
+		...t.pressure ? { pressure: t.pressure.map((p) => [...p]) } : {},
+		width: 2,
+		rect
+	};
+}
+function createSignatureLibrary(store) {
+	const templates = writable([]);
+	const removeError = writable(void 0);
+	/**
+	* The newest load that succeeded writes, so a slow one cannot undo a later save, and a later
+	* one that fails does not throw away a slow success.
+	*/
+	let loads = 0;
+	let applied = 0;
+	const refresh = async () => {
+		const n = ++loads;
+		try {
+			const list = validTemplates(await store.list());
+			if (n > applied) {
+				applied = n;
+				templates.set(list);
+			}
+		} catch {}
+	};
+	return {
+		store,
+		templates: readonly(templates),
+		get: (id) => templates.get().find((t) => t.id === id),
+		refresh,
+		async save(t) {
+			await store.save(t);
+			await refresh();
+		},
+		async remove(id) {
+			removeError.set(void 0);
+			try {
+				await store.remove(id);
+			} catch (e) {
+				removeError.set("The signature could not be removed. Try again.");
+				throw e;
+			}
+			await refresh();
+		},
+		removeError: readonly(removeError),
+		clearRemoveError: () => removeError.set(void 0)
+	};
+}
+//#endregion
+export { exportAnnotations as $, derived as $t, fromAnnotation as A, RedactSchema as At, isBubble as B, isStandardCallout as Bt, repliesTo as C, NoteSchema as Ct, acceptSuggestion as D, PolylineSchema as Dt, withoutReplies as E, PolygonSchema as Et, toFields as F, TextMarkupSchema as Ft, resizedBox as G, PDF_NAME as Gt, keepsAspect as H, INTENTS as Ht, typesInGroup as I, confidenceBucket as It, translated as J, parsePdfDate as Jt, resizedRect as K, isKnown as Kt, hasCallout as L, FringeSchema as Lt, styleGroupOfType as M, SquareSchema as Mt, styleGroupsOf as N, StampSchema as Nt, STYLE_GROUPS as O, QuadSchema as Ot, supportedProps as P, SuggestionSchema as Pt, deriveRect as Q, mergeLineRects as Qt, hasCornerHandles as R, calloutStroke as Rt, isThreadRoot as S, NoteIconSchema as St, threadRoot as T, PolySchema as Tt, movedEndpoint as U, LINE_ENDINGS as Ut, isTextMarkup as V, withCalloutBounds as Vt, movedTip as W, NOTE_ICONS as Wt, openDocument as X, normalizeColor as Xt, withBox as Y, cssVariableDefaults as Yt, createAnnotationStore as Z, staticDefaults as Zt, defaultEnds as _, InkError as _n, InkSchema as _t, createLocalSignatureStore as a, multiplyMatrix as an, importedId as at, isAbandonedNote as b, LoupeSchema as bt, normaliseInk as c, quadsFromFlat as cn, ANNOTATION_FORMAT as ct, recogniseStroke as d, rectFromQuad as dn, AnnotationSchema as dt, readonly as en, importAnnotations as et, DEFAULT_CORNER_RADIUS as f, rectsIntersect as fn, CircleSchema as ft, constrain as g, Emitter as gn, IMAGE_DATA_URL as gt, SHAPE_KINDS as h, unionRects as hn, FreeTextStyleSchema as ht, createInkTemplate as i, invertMatrix as in, importEmbeddedPage as it, styleGroupOf as j, ShapeSchema as jt, createToolStyle as k, RectSchema as kt, placeSignature as l, rectContainsPoint as ln, ANNOTATION_VERSION as lt, DEFAULT_SHAPE_SIZE as m, translateRect as mn, FreeTextSchema as mt, SIGNATURE_INK_WIDTH as n, applyMatrix as nn, isProduction as nt, createMemorySignatureStore as o, pointsFromFlat as on, pdfColorToHex as ot, DEFAULT_SHAPE_OPTIONS as p, translateQuad as pn, ExportedAnnotationSchema as pt, scaled as q, pdfNameSet as qt, createImageTemplate as r, approxEqual as rn, SUPPORTED_SUBTYPES as rt, createSignatureLibrary as s, quadFromRect as sn, summarise as st, DEFAULT_SIGNATURE_WIDTH as t, writable as tn, createHistory as tt, RECOGNISE_THRESHOLD as u, rectFromPoints as un, AnnotationDocumentSchema as ut, isPointerOnlyKind as v, isInkError as vn, LineEndingSchema as vt, threadOf as w, PointSchema as wt, isReply as x, MaskSchema as xt, shapeInput as y, LineSchema as yt, hasRectGeometry as z, freeTextBox as zt };
+
+//# sourceMappingURL=signatures-DF2VmNVa.mjs.map