@inkbar/core 0.4.0 → 0.6.0

package/dist/{signatures-DF2VmNVa.mjs → signatures-D68fuLlt.mjs}

@@ -1,3 +1,4 @@
+import { Circle, Color, FreeText, FreeTextStyle, Fringe, GLOSS_FORMAT, GLOSS_FORMAT as GLOSS_FORMAT$1, GLOSS_MEDIA_TYPE, GLOSS_SCHEMA_ID, GLOSS_VERSION, GLOSS_VERSION as GLOSS_VERSION$1, Highlight, IMAGE_DATA_URL, INTENTS, Ink, LINE_ENDINGS, Line, LineEnding, NOTE_ICONS, Note, NoteIcon, PDF_NAME, PDF_NAME as PDF_NAME$1, Point, Polygon, Polyline, Rect, Redact, Square, Stamp, commonFields } from "gloss-format";
 import { z } from "zod";
 import { v7 } from "uuid";
 //#region src/model/errors.ts
@@ -95,6 +96,15 @@ function quadFromRect(r) {
 		}
 	};
 }
+/** One quad covering `r`, in the corner order of `quadFromRect`. */
+function quadsFromRect(r) {
+	return [quadFromRect(r)];
+}
+/** The bounding box of every corner of `quads`. */
+function rectFromQuads(quads) {
+	if (quads.length === 0) throw new RangeError("rectFromQuads needs at least one quad");
+	return unionRects(quads.map(rectFromQuad));
+}
 function unionRects(rects) {
 	if (rects.length === 0) throw new RangeError("unionRects needs at least one rect");
 	let x1 = Infinity;
@@ -250,6 +260,102 @@ function readonly(w) {
 	};
 }
 //#endregion
+//#region src/model/records.ts
+/**
+* A keyed list of plain records. Records are stored as frozen copies, so a change's `before` and `after` can be
+* kept as history entries without copying.
+*/
+function createRecordStore(key, opts = {}) {
+	const list = writable((opts.initial ?? []).map(frozen));
+	const emitter = new Emitter();
+	let destroyed = false;
+	function commit(next, change) {
+		if (destroyed) return;
+		list.set(next);
+		emitter.emit("change", change);
+		opts.onChange?.(next, change);
+	}
+	return {
+		key,
+		list: readonly(list),
+		get: (id) => list.get().find((r) => r.id === id),
+		add(record) {
+			if (list.get().some((r) => r.id === record.id)) throw new InkError("DuplicateId", `A record with id ${record.id} already exists`, {
+				key,
+				id: record.id
+			});
+			const stored = frozen(record);
+			commit([...list.get(), stored], {
+				kind: "add",
+				record: stored
+			});
+			return stored;
+		},
+		update(id, patch) {
+			const before = list.get().find((r) => r.id === id);
+			if (destroyed || !before) return void 0;
+			const after = Object.freeze({
+				...before,
+				...patch,
+				id: before.id
+			});
+			commit(list.get().map((r) => r.id === id ? after : r), {
+				kind: "update",
+				id,
+				before,
+				after
+			});
+			return after;
+		},
+		remove(id) {
+			const record = list.get().find((r) => r.id === id);
+			if (destroyed || !record) return void 0;
+			commit(list.get().filter((r) => r.id !== id), {
+				kind: "remove",
+				record
+			});
+			return record;
+		},
+		replaceAll(incoming, reason) {
+			const prev = new Map(list.get().map((r) => [r.id, r]));
+			const added = [];
+			const updated = [];
+			const next = incoming.map((r) => {
+				const old = prev.get(r.id);
+				if (!old) {
+					added.push(r.id);
+					return frozen(r);
+				}
+				if (shallowEqual(old, r)) return old;
+				updated.push(r.id);
+				return frozen(r);
+			});
+			const kept = new Set(next.map((r) => r.id));
+			commit(next, {
+				kind: "replace",
+				reason,
+				added,
+				updated,
+				removed: [...prev.keys()].filter((id) => !kept.has(id))
+			});
+		},
+		on: (event, fn) => emitter.on(event, fn),
+		destroy() {
+			destroyed = true;
+			emitter.clear();
+		}
+	};
+}
+/** Freezes a copy, so the caller's object stays theirs; an already frozen record is kept. */
+function frozen(record) {
+	return Object.isFrozen(record) ? record : Object.freeze({ ...record });
+}
+function shallowEqual(a, b) {
+	const ka = Object.keys(a);
+	const kb = Object.keys(b);
+	return ka.length === kb.length && ka.every((k) => Object.hasOwn(b, k) && a[k] === b[k]);
+}
+//#endregion
 //#region src/model/selection.ts
 const union = (a, b) => {
 	const x = Math.min(a.x, b.x);
@@ -422,20 +528,10 @@ const COLORS = {
 	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]
+	opacity: (type) => type === "highlight" ? .4 : 1
 };
 const VARIABLES = {
 	highlight: "--ink-highlight",
@@ -465,8 +561,7 @@ function cssVariableDefaults(el) {
 	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)
+		opacity: (type) => staticDefaults.opacity(type)
 	};
 }
 /** Accepts `#rgb`, `#rrggbb`, `rgb(r, g, b)` and `rgb(r g b)`; returns `#RRGGBB` or undefined. */
@@ -507,51 +602,12 @@ function parsePdfDate(value, fallback) {
 //#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);
@@ -562,12 +618,7 @@ function isKnown(list, v) {
 * 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()
-});
+const FringeSchema = z.object(Fringe.shape);
 /** An ending's length, and its full width, as a multiple of the stroke width. */
 const ENDING_SCALE = 3;
 /**
@@ -640,73 +691,48 @@ function withCalloutBounds(box, callout, width, head) {
 }
 //#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 PointSchema = z.object(Point.shape);
+const RectSchema = z.object(Rect.shape);
 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(),
+/** What Inkbar adds to every Gloss type: the fields it always fills in, and its viewer state. */
+const Base = {
 	/** 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 }),
+	color: Color,
+	opacity: commonFields.opacity.removeDefault(),
+	createdAt: commonFields.createdAt.unwrap(),
+	modifiedAt: commonFields.modifiedAt.unwrap(),
 	/** 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({
+	locked: z.boolean().optional()
+};
+const Quads = z.array(QuadSchema).min(1);
+const TextMarkupSchema = z.object({
+	...Highlight.shape,
+	...Base,
 	type: z.enum([
 		"highlight",
 		"underline",
 		"strikeout",
 		"squiggly"
 	]),
-	quads: z.array(QuadSchema).min(1)
+	quads: Quads
 });
 /** 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")
+const NoteIconSchema = NoteIcon;
+const NoteSchema = z.object({
+	...Note.shape,
+	...Base
 });
 /** 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();
+const LineEndingSchema = LineEnding;
 /**
 * 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
@@ -718,20 +744,9 @@ const Refused = z.never().optional();
 * `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),
+	...FreeTextStyle.shape,
 	/** 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(),
+	color: Color,
 	align: Refused
 });
 /**
@@ -739,88 +754,56 @@ const FreeTextStyleSchema = z.object({
 * `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(),
+const FreeTextSchema = z.object({
+	...FreeText.shape,
+	...Base,
 	/** 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(),
+	color: FreeText.shape.color,
+	/** The box's border colour. Absent means the text colour. */
+	borderColor: Color.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 SquareSchema = z.object({
+	...Square.shape,
+	...Base
 });
-const CircleSchema = Base.extend({
-	type: z.literal("circle"),
-	...ShapeFields,
+const CircleSchema = z.object({
+	...Circle.shape,
+	...Base,
 	cornerRadius: Refused
 });
 const ShapeSchema = z.discriminatedUnion("type", [SquareSchema, CircleSchema]);
-const LineSchema = Base.extend({
-	type: z.literal("line"),
+const LineSchema = z.object({
+	...Line.shape,
+	...Base,
 	start: PointSchema,
-	end: PointSchema,
-	width: z.number().nonnegative().default(1),
-	dashes: DashesSchema,
-	head: LineEndingSchema.optional(),
-	tail: LineEndingSchema.optional()
+	end: PointSchema
 });
-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 Vertices = z.array(PointSchema).min(2);
+const PolylineSchema = z.object({
+	...Polyline.shape,
+	...Base,
+	vertices: Vertices
 });
-const PolygonSchema = Base.extend({
-	type: z.literal("polygon"),
-	...PolyFields,
+const PolygonSchema = z.object({
+	...Polygon.shape,
+	...Base,
+	vertices: Vertices,
 	head: Refused,
 	tail: Refused
 });
 const PolySchema = z.discriminatedUnion("type", [PolylineSchema, PolygonSchema]);
-const InkShape = Base.extend({
-	type: z.literal("ink"),
+const InkShape = z.object({
+	...Ink.shape,
+	...Base,
 	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
+	/** Pen pressure from 0 to 1, one value per point of each stroke. Absent means even pressure. */
+	pressure: z.array(z.array(z.number().min(0).max(1))).optional()
 });
 /** Pressure must have one value per point of each stroke. */
 function checkPressure(a, ctx) {
@@ -832,70 +815,48 @@ function checkPressure(a, ctx) {
 	});
 }
 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()
+const StampSchema = z.object({
+	...Stamp.shape,
+	...Base
 });
 /**
-* 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.
+* A loupe (Inkbar's own type, a circle with `custom.inkbar.type: 'loupe'` in a file): 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({
+const LoupeSchema = z.object({
 	type: z.literal("loupe"),
+	...commonFields,
 	/** 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)
+	width: z.number().nonnegative().default(2),
+	...Base
 });
 /**
-* 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.
+* A mask (Inkbar's own type, a circle or square with `custom.inkbar.type: 'mask'` in a file):
+* dims everything on the page outside `shape` drawn in `rect`, an ellipse inscribed in it or the
+* rectangle itself. `color` is the dimming colour and `dim` how strongly it covers, from 0 to 1.
+* One per page: adding a second replaces the first.
 */
-const MaskSchema = Base.extend({
+const MaskSchema = z.object({
 	type: z.literal("mask"),
+	...commonFields,
 	shape: z.enum(["rect", "ellipse"]),
-	/** Opacity of the dimming, 0 (none) to 1 (opaque). */
-	dim: z.number().min(0).max(1).default(.5)
+	dim: z.number().min(0).max(1).default(.5),
+	...Base
 });
-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"),
+const RedactSchema = z.object({
+	...Redact.shape,
+	...Base,
 	/** 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(),
+	quads: Quads.optional(),
 	/** Colour the redaction will be filled with when applied. */
-	interiorColor: Hex
+	interiorColor: Color
 });
 const AnnotationSchema = z.discriminatedUnion("type", [
 	TextMarkupSchema,
@@ -934,17 +895,12 @@ const ExportedAnnotationSchema = z.discriminatedUnion("type", [
 	RedactSchema.omit(VIEWER_STATE)
 ]);
 const AnnotationDocumentSchema = z.object({
-	format: z.literal(ANNOTATION_FORMAT),
-	version: z.literal(1),
+	format: z.literal(GLOSS_FORMAT),
+	version: z.literal(GLOSS_VERSION),
 	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([
@@ -982,7 +938,7 @@ function rectFromPdf(r) {
 }
 /** 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;
+	return raw !== void 0 && PDF_NAME$1.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) {
@@ -1000,18 +956,43 @@ function lineEndingsOf(raw) {
 function importedId(page, pdfjsId) {
 	return `pdf:${page}:${pdfjsId}`;
 }
+/**
+* Imports one page's PDF.js annotation data. `targets` is @internal: the annotations whose
+* missing fields the document reads from the file after `ready`.
+*/
 function importEmbeddedPage(page, raw, importedAt) {
 	const counts = {};
 	const annotations = [];
+	const targets = [];
 	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);
+		if (!converted) continue;
+		annotations.push(converted);
+		const target = targetOf(converted.id, data);
+		if (target) targets.push(target);
 	}
 	return {
 		annotations,
-		counts
+		counts,
+		targets
+	};
+}
+function targetOf(id, d) {
+	const rect = Array.from(d.rect);
+	if (d.subtype === "Text") return d.name === "NoIcon" ? {
+		id,
+		subtype: "Text",
+		rect
+	} : void 0;
+	if (d.subtype !== "FreeText") return void 0;
+	const daFont = d.defaultAppearanceData?.fontName;
+	return {
+		id,
+		subtype: "FreeText",
+		rect,
+		...daFont ? { daFont } : {}
 	};
 }
 function summarise(perPage) {
@@ -1152,7 +1133,6 @@ function convert(page, d, importedAt) {
 			candidate = {
 				...base("redact"),
 				type: "redact",
-				origin: "user",
 				interiorColor: pdfColorToHex(d.interiorColor, staticDefaults.fill()),
 				...quads.length > 0 ? { quads } : {}
 			};
@@ -1163,6 +1143,749 @@ function convert(page, d, importedAt) {
 	return parsed.success ? parsed.data : void 0;
 }
 //#endregion
+//#region src/pdf/lexer.ts
+/** Thrown when the bytes are not valid PDF object syntax. */
+var PdfSyntaxError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "PdfSyntaxError";
+	}
+};
+const isWhite$1 = (c) => c === 0 || c === 9 || c === 10 || c === 12 || c === 13 || c === 32;
+const isDelimiter = (c) => c === 40 || c === 41 || c === 60 || c === 62 || c === 91 || c === 93 || c === 123 || c === 125 || c === 47 || c === 37;
+const isRegular = (c) => !isWhite$1(c) && !isDelimiter(c);
+const isDigit = (c) => c >= 48 && c <= 57;
+const latin1$1 = (bytes, from, to) => {
+	let out = "";
+	for (let i = from; i < to; i++) out += String.fromCharCode(bytes[i]);
+	return out;
+};
+function skipSpace(bytes, offset) {
+	let i = offset;
+	while (i < bytes.length) {
+		const c = bytes[i];
+		if (isWhite$1(c)) i++;
+		else if (c === 37) while (i < bytes.length && bytes[i] !== 10 && bytes[i] !== 13) i++;
+		else break;
+	}
+	return i;
+}
+function tokenEnd(bytes, offset) {
+	let i = offset;
+	while (i < bytes.length && isRegular(bytes[i])) i++;
+	return i;
+}
+const hexValue = (c) => {
+	if (c === void 0) return -1;
+	if (c >= 48 && c <= 57) return c - 48;
+	if (c >= 65 && c <= 70) return c - 65 + 10;
+	if (c >= 97 && c <= 102) return c - 97 + 10;
+	return -1;
+};
+function parseName(bytes, offset) {
+	const end = tokenEnd(bytes, offset + 1);
+	let name = "";
+	for (let i = offset + 1; i < end; i++) {
+		const c = bytes[i];
+		const hi = c === 35 ? hexValue(bytes[i + 1]) : -1;
+		const lo = hi >= 0 ? hexValue(bytes[i + 2]) : -1;
+		if (hi >= 0 && lo >= 0 && i + 2 < end) {
+			name += String.fromCharCode(hi * 16 + lo);
+			i += 2;
+		} else name += String.fromCharCode(c);
+	}
+	return {
+		value: {
+			kind: "name",
+			name
+		},
+		end
+	};
+}
+function skipLiteralString(bytes, offset) {
+	let depth = 0;
+	for (let i = offset; i < bytes.length; i++) {
+		const c = bytes[i];
+		if (c === 92) i++;
+		else if (c === 40) depth++;
+		else if (c === 41 && --depth === 0) return i + 1;
+	}
+	throw new PdfSyntaxError("Unterminated string");
+}
+/** After a non-negative integer ending at `end`, looks for `gen R`. */
+function tryReference(bytes, num, end) {
+	let i = end;
+	if (i >= bytes.length || !isWhite$1(bytes[i])) return void 0;
+	i = skipSpace(bytes, i);
+	const genStart = i;
+	while (i < bytes.length && isDigit(bytes[i])) i++;
+	if (i === genStart || i >= bytes.length || !isWhite$1(bytes[i])) return void 0;
+	const gen = Number(latin1$1(bytes, genStart, i));
+	i = skipSpace(bytes, i);
+	if (bytes[i] !== 82 || i + 1 < bytes.length && isRegular(bytes[i + 1])) return;
+	return {
+		value: {
+			kind: "ref",
+			num,
+			gen
+		},
+		end: i + 1
+	};
+}
+function parseNumberOrKeyword(bytes, offset) {
+	const end = tokenEnd(bytes, offset);
+	const token = latin1$1(bytes, offset, end);
+	if (token === "true") return {
+		value: true,
+		end
+	};
+	if (token === "false") return {
+		value: false,
+		end
+	};
+	if (token === "null") return {
+		value: null,
+		end
+	};
+	if (/^[+-]?(\d+\.?\d*|\.\d+)$/.test(token)) {
+		const n = Number(token);
+		if (/^\d+$/.test(token)) {
+			const ref = tryReference(bytes, n, end);
+			if (ref) return ref;
+		}
+		return {
+			value: n,
+			end
+		};
+	}
+	throw new PdfSyntaxError(`Unexpected token "${token}" at ${offset}`);
+}
+/** Parses one value at `offset`, skipping whitespace and comments first. */
+function parseValue(bytes, offset) {
+	const i = skipSpace(bytes, offset);
+	if (i >= bytes.length) throw new PdfSyntaxError("Unexpected end of data");
+	const c = bytes[i];
+	if (c === 47) return parseName(bytes, i);
+	if (c === 40) return {
+		value: { kind: "string" },
+		end: skipLiteralString(bytes, i)
+	};
+	if (c === 60 && bytes[i + 1] === 60) return parseDict(bytes, i + 2);
+	if (c === 60) {
+		let j = i + 1;
+		while (j < bytes.length && bytes[j] !== 62) j++;
+		if (j >= bytes.length) throw new PdfSyntaxError("Unterminated hex string");
+		return {
+			value: { kind: "string" },
+			end: j + 1
+		};
+	}
+	if (c === 91) return parseArray(bytes, i + 1);
+	if (isRegular(c)) return parseNumberOrKeyword(bytes, i);
+	throw new PdfSyntaxError(`Unexpected "${String.fromCharCode(c)}" at ${i}`);
+}
+function parseArray(bytes, offset) {
+	const items = [];
+	let i = offset;
+	for (;;) {
+		i = skipSpace(bytes, i);
+		if (i >= bytes.length) throw new PdfSyntaxError("Unterminated array");
+		if (bytes[i] === 93) return {
+			value: items,
+			end: i + 1
+		};
+		const item = parseValue(bytes, i);
+		items.push(item.value);
+		i = item.end;
+	}
+}
+function parseDict(bytes, offset) {
+	const entries = /* @__PURE__ */ new Map();
+	let i = offset;
+	for (;;) {
+		i = skipSpace(bytes, i);
+		if (i >= bytes.length) throw new PdfSyntaxError("Unterminated dictionary");
+		if (bytes[i] === 62 && bytes[i + 1] === 62) return {
+			value: {
+				kind: "dict",
+				entries
+			},
+			end: i + 2
+		};
+		if (bytes[i] !== 47) throw new PdfSyntaxError(`Expected a name key at ${i}`);
+		const key = parseName(bytes, i);
+		const val = parseValue(bytes, key.end);
+		entries.set(key.value.name, val.value);
+		i = val.end;
+	}
+}
+function readInteger(bytes, offset) {
+	const i = skipSpace(bytes, offset);
+	let end = i;
+	while (end < bytes.length && isDigit(bytes[end])) end++;
+	if (end === i) throw new PdfSyntaxError(`Expected an integer at ${i}`);
+	return {
+		n: Number(latin1$1(bytes, i, end)),
+		end
+	};
+}
+/** Parses `num gen obj <value> [stream]` at `offset`. `streamStart` is the first data byte after `stream` and its EOL. */
+function parseIndirect(bytes, offset) {
+	const num = readInteger(bytes, offset);
+	const gen = readInteger(bytes, num.end);
+	const kw = skipSpace(bytes, gen.end);
+	if (latin1$1(bytes, kw, tokenEnd(bytes, kw)) !== "obj") throw new PdfSyntaxError(`Expected "obj" at ${kw}`);
+	const { value, end } = parseValue(bytes, kw + 3);
+	const result = {
+		num: num.n,
+		gen: gen.n,
+		value
+	};
+	const next = skipSpace(bytes, end);
+	if (latin1$1(bytes, next, next + 6) === "stream" && !isRegular(bytes[next + 6] ?? 32)) {
+		let start = next + 6;
+		if (bytes[start] === 13 && bytes[start + 1] === 10) start += 2;
+		else if (bytes[start] === 10 || bytes[start] === 13) start += 1;
+		result.streamStart = start;
+	}
+	return result;
+}
+/** Reads a dictionary entry. */
+const dictGet = (d, key) => d.entries.get(key);
+/** True for a name object, optionally one with the given spelling. */
+const isName = (v, name) => typeof v === "object" && v !== null && v.kind === "name" && (name === void 0 || v.name === name);
+/** True for a dictionary object. */
+const isDict = (v) => typeof v === "object" && v !== null && !Array.isArray(v) && v.kind === "dict";
+/** True for an indirect reference. */
+const isRef = (v) => typeof v === "object" && v !== null && !Array.isArray(v) && v.kind === "ref";
+//#endregion
+//#region src/pdf/annotation-fields.ts
+/** `12R` → {num:12,gen:0}, `12R3` → {num:12,gen:3}; anything else undefined. */
+function refOfPdfjsId(id) {
+	const m = /^(\d+)R(\d+)?$/.exec(id);
+	if (!m) return void 0;
+	return {
+		kind: "ref",
+		num: Number(m[1]),
+		gen: m[2] === void 0 ? 0 : Number(m[2])
+	};
+}
+const FAMILIES = [
+	[/^(helvetica|helv)/i, "Helvetica"],
+	[/^(times|tiro)/i, "Times"],
+	[/^cour(ier|$)/i, "Courier"]
+];
+/**
+* BaseFont (or bare resource name) → Inkbar font fields; undefined for Symbol and ZapfDingbats.
+* A family matches by prefix, so `HelveticaNeue` reads as Helvetica and `CourierNewPS` as
+* Courier. Any other name keeps its own family, minus a trailing `MT` or `PSMT`.
+* With `knownOnly`, a name outside Helvetica, Times and Courier gives undefined: a bare
+* resource id such as `F1` is not a family.
+*/
+function fontFromBaseName(name, knownOnly = false) {
+	const bare = name.replace(/^[A-Z]{6}\+/, "");
+	if (/^(symbol|zapfdingbats|zadb)/i.test(bare)) return void 0;
+	const cut = bare.search(/[-,]/);
+	const base = cut < 0 ? bare : bare.slice(0, cut);
+	const style = cut < 0 ? "" : bare.slice(cut + 1);
+	const known = FAMILIES.find(([re]) => re.test(base));
+	if (knownOnly && !known) return void 0;
+	const fontFamily = known ? known[1] : base.replace(/(PS)?MT$/, "");
+	if (!fontFamily) return void 0;
+	const font = { fontFamily };
+	if (/bold|black|heavy/i.test(style)) font.fontWeight = "bold";
+	if (/italic|oblique/i.test(style)) font.fontStyle = "italic";
+	return font;
+}
+const finite = (v) => typeof v === "number" && Number.isFinite(v);
+async function numbers$1(objs, v, counts) {
+	const arr = await objs.resolve(v);
+	if (!Array.isArray(arr) || !counts.includes(arr.length)) return void 0;
+	const out = await Promise.all(arr.map((n) => objs.resolve(n)));
+	return out.every(finite) ? out : void 0;
+}
+async function dictOf(objs, v) {
+	const d = await objs.resolve(v);
+	return isDict(d) ? d : void 0;
+}
+/** The font's /BaseFont, looked up in a /DR resource dictionary. */
+async function baseFontIn(objs, dr, resource) {
+	const res = await dictOf(objs, dr);
+	const fonts = res && await dictOf(objs, dictGet(res, "Font"));
+	const font = fonts && await dictOf(objs, dictGet(fonts, resource));
+	const base = font && await objs.resolve(dictGet(font, "BaseFont"));
+	return isName(base) ? base.name : void 0;
+}
+async function readFont(objs, annot, daFont) {
+	const root = await dictOf(objs, dictGet(objs.trailer, "Root"));
+	const acroForm = root && await dictOf(objs, dictGet(root, "AcroForm"));
+	const sources = [dictGet(annot, "DR"), acroForm && dictGet(acroForm, "DR")];
+	for (const dr of sources) {
+		const base = await baseFontIn(objs, dr, daFont);
+		if (base !== void 0) return fontFromBaseName(base);
+	}
+	return fontFromBaseName(daFont, true);
+}
+async function readHead(objs, le) {
+	let v = await objs.resolve(le);
+	if (Array.isArray(v)) v = await objs.resolve(v[0]);
+	return isName(v) && PDF_NAME$1.test(v.name) ? v.name : void 0;
+}
+/** `rect` is the annotation's [x1 y1 x2 y2], used to reject a fringe that leaves no box. */
+async function readFreeTextFields(objs, ref, rect, daFont) {
+	const fields = {};
+	try {
+		const annot = await objs.get(ref);
+		if (!isDict(annot)) return fields;
+		const cl = await numbers$1(objs, dictGet(annot, "CL"), [4, 6]);
+		if (cl) {
+			fields.callout = [];
+			for (let i = 0; i < cl.length; i += 2) fields.callout.push({
+				x: cl[i],
+				y: cl[i + 1]
+			});
+		}
+		const rd = await numbers$1(objs, dictGet(annot, "RD"), [4]);
+		if (rd && rect.length === 4 && rd.every((n) => n >= 0)) {
+			const [left, top, right, bottom] = rd;
+			const width = Math.abs(rect[2] - rect[0]);
+			const height = Math.abs(rect[3] - rect[1]);
+			if (left + right < width && top + bottom < height) fields.fringe = {
+				left,
+				top,
+				right,
+				bottom
+			};
+		}
+		const head = await readHead(objs, dictGet(annot, "LE"));
+		if (head !== void 0) fields.head = head;
+		if (daFont !== void 0) {
+			const font = await readFont(objs, annot, daFont);
+			if (font) fields.font = font;
+		}
+	} catch {}
+	return fields;
+}
+async function readTextIcon(objs, ref) {
+	try {
+		const annot = await objs.get(ref);
+		if (!isDict(annot)) return void 0;
+		const name = await objs.resolve(dictGet(annot, "Name"));
+		return isName(name) && PDF_NAME$1.test(name.name) ? name.name : void 0;
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/pdf/stream.ts
+const ENDSTREAM = Uint8Array.from("endstream", (c) => c.charCodeAt(0));
+function matchesAt(bytes, at, pattern) {
+	if (at < 0 || at + pattern.length > bytes.length) return false;
+	for (let i = 0; i < pattern.length; i++) if (bytes[at + i] !== pattern[i]) return false;
+	return true;
+}
+function findEndstream(bytes, from) {
+	for (let i = from; i + ENDSTREAM.length <= bytes.length; i++) if (matchesAt(bytes, i, ENDSTREAM)) return i;
+	return bytes.length;
+}
+/** Raw stream bytes: trusts `length` when `endstream` follows it, otherwise scans. */
+function rawData(bytes, start, length) {
+	if (length !== void 0 && Number.isInteger(length) && length >= 0) {
+		let i = start + length;
+		while (i < bytes.length && (bytes[i] === 10 || bytes[i] === 13 || bytes[i] === 32)) i++;
+		if (matchesAt(bytes, i, ENDSTREAM)) return bytes.subarray(start, start + length);
+	}
+	let end = findEndstream(bytes, start);
+	if (end > start && bytes[end - 1] === 10) end--;
+	if (end > start && bytes[end - 1] === 13) end--;
+	return bytes.subarray(start, end);
+}
+/** The single filter parameter dictionary, if any. Anything else that is defined is an error. */
+function decodeParms(dict) {
+	const parms = dictGet(dict, "DecodeParms") ?? dictGet(dict, "DP");
+	const first = Array.isArray(parms) ? parms[0] : parms;
+	if (first === void 0 || first === null) return void 0;
+	if (!isDict(first)) throw new PdfSyntaxError("Unsupported /DecodeParms");
+	return first;
+}
+function numberParam(parms, key, fallback) {
+	const v = parms ? dictGet(parms, key) : void 0;
+	return typeof v === "number" ? v : fallback;
+}
+async function inflate(data) {
+	const stream = new Blob([data]).stream().pipeThrough(new DecompressionStream("deflate"));
+	return new Uint8Array(await new Response(stream).arrayBuffer());
+}
+function paeth(a, b, c) {
+	const p = a + b - c;
+	const pa = Math.abs(p - a);
+	const pb = Math.abs(p - b);
+	const pc = Math.abs(p - c);
+	if (pa <= pb && pa <= pc) return a;
+	return pb <= pc ? b : c;
+}
+function undoPngPredictor(data, columns, colors, bits) {
+	const bpp = Math.max(1, Math.ceil(colors * bits / 8));
+	const rowBytes = Math.ceil(columns * colors * bits / 8);
+	const rows = Math.floor(data.length / (rowBytes + 1));
+	const out = new Uint8Array(rows * rowBytes);
+	for (let r = 0; r < rows; r++) {
+		const type = data[r * (rowBytes + 1)];
+		const src = r * (rowBytes + 1) + 1;
+		const dst = r * rowBytes;
+		for (let x = 0; x < rowBytes; x++) {
+			const raw = data[src + x];
+			const left = x >= bpp ? out[dst + x - bpp] : 0;
+			const up = r > 0 ? out[dst - rowBytes + x] : 0;
+			const upLeft = r > 0 && x >= bpp ? out[dst - rowBytes + x - bpp] : 0;
+			let value;
+			switch (type) {
+				case 0:
+					value = raw;
+					break;
+				case 1:
+					value = raw + left;
+					break;
+				case 2:
+					value = raw + up;
+					break;
+				case 3:
+					value = raw + (left + up >> 1);
+					break;
+				case 4:
+					value = raw + paeth(left, up, upLeft);
+					break;
+				default: throw new PdfSyntaxError(`Unknown PNG filter type ${type}`);
+			}
+			out[dst + x] = value & 255;
+		}
+	}
+	return out;
+}
+/** The decoded data of the stream whose dictionary is `dict` and whose data starts at `start`. `length` is `/Length`, already resolved. */
+async function decodeStream(bytes, dict, start, length) {
+	const filter = dictGet(dict, "Filter") ?? dictGet(dict, "F");
+	const filters = Array.isArray(filter) ? filter : filter === void 0 ? [] : [filter];
+	if (filters.length === 0) return rawData(bytes, start, length);
+	if (filters.length > 1 || !isName(filters[0], "FlateDecode")) throw new PdfSyntaxError("Unsupported stream filter");
+	const inflated = await inflate(rawData(bytes, start, length));
+	const parms = decodeParms(dict);
+	const predictor = numberParam(parms, "Predictor", 1);
+	if (predictor === 1) return inflated;
+	if (predictor < 10) throw new PdfSyntaxError(`Unsupported predictor ${predictor}`);
+	return undoPngPredictor(inflated, numberParam(parms, "Columns", 1), numberParam(parms, "Colors", 1), numberParam(parms, "BitsPerComponent", 8));
+}
+//#endregion
+//#region src/pdf/xref.ts
+const isWhite = (c) => c === 0 || c === 9 || c === 10 || c === 12 || c === 13 || c === 32;
+const latin1 = (bytes, from, to) => {
+	let out = "";
+	for (let i = from; i < to; i++) out += String.fromCharCode(bytes[i]);
+	return out;
+};
+function readToken(bytes, offset) {
+	let i = offset;
+	while (i < bytes.length && isWhite(bytes[i])) i++;
+	const start = i;
+	while (i < bytes.length && !isWhite(bytes[i])) i++;
+	return {
+		token: latin1(bytes, start, i),
+		end: i
+	};
+}
+function readInt(bytes, offset) {
+	const { token, end } = readToken(bytes, offset);
+	if (!/^\d+$/.test(token)) throw new Error(`Expected an integer at ${offset}`);
+	return {
+		n: Number(token),
+		end
+	};
+}
+function findStartxref(bytes) {
+	const tail = latin1(bytes, Math.max(0, bytes.length - 1024), bytes.length);
+	const at = tail.lastIndexOf("startxref");
+	if (at < 0) throw new Error("No startxref");
+	return readInt(bytes, bytes.length - tail.length + at + 9).n;
+}
+function readTable(bytes, offset) {
+	const entries = /* @__PURE__ */ new Map();
+	let i = readToken(bytes, offset).end;
+	for (;;) {
+		const head = readToken(bytes, i);
+		if (head.token.startsWith("trailer")) {
+			const trailer = parseValue(bytes, head.end - (head.token.length - 7)).value;
+			if (!isDict(trailer)) throw new Error("Trailer is not a dictionary");
+			return {
+				entries,
+				trailer
+			};
+		}
+		const first = readInt(bytes, i);
+		const count = readInt(bytes, first.end);
+		i = count.end;
+		for (let k = 0; k < count.n; k++) {
+			const off = readInt(bytes, i);
+			const gen = readInt(bytes, off.end);
+			const kind = readToken(bytes, gen.end);
+			i = kind.end;
+			if (kind.token === "n") entries.set(first.n + k, {
+				type: "offset",
+				offset: off.n,
+				gen: gen.n
+			});
+			else if (kind.token === "f") entries.set(first.n + k, { type: "free" });
+			else throw new Error(`Bad xref entry type "${kind.token}"`);
+		}
+	}
+}
+const numbers = (v) => Array.isArray(v) && v.every((x) => typeof x === "number" && x >= 0) ? v : void 0;
+async function readStream(bytes, offset) {
+	const obj = parseIndirect(bytes, offset);
+	const dict = obj.value;
+	if (!isDict(dict) || obj.streamStart === void 0) throw new Error("Xref stream expected");
+	const length = dict.entries.get("Length");
+	const data = await decodeStream(bytes, dict, obj.streamStart, typeof length === "number" ? length : void 0);
+	const w = numbers(dict.entries.get("W"));
+	if (!w || w.length !== 3 || w.some((x) => x > 8)) throw new Error("Bad /W");
+	const size = dict.entries.get("Size");
+	const index = numbers(dict.entries.get("Index")) ?? [0, typeof size === "number" ? size : 0];
+	const [w0, w1, w2] = w;
+	const rowLength = w0 + w1 + w2;
+	if (rowLength === 0) throw new Error("Empty xref rows");
+	const field = (at, width) => {
+		let n = 0;
+		for (let k = 0; k < width; k++) n = n * 256 + data[at + k];
+		return n;
+	};
+	const entries = /* @__PURE__ */ new Map();
+	let row = 0;
+	for (let s = 0; s + 1 < index.length; s += 2) for (let k = 0; k < index[s + 1]; k++, row++) {
+		const at = row * rowLength;
+		if (at + rowLength > data.length) return {
+			entries,
+			trailer: dict
+		};
+		const type = w0 === 0 ? 1 : field(at, w0);
+		const a = field(at + w0, w1);
+		const b = field(at + w0 + w1, w2);
+		const num = index[s] + k;
+		if (type === 0) entries.set(num, { type: "free" });
+		else if (type === 1) entries.set(num, {
+			type: "offset",
+			offset: a,
+			gen: b
+		});
+		else if (type === 2) entries.set(num, {
+			type: "compressed",
+			stream: a,
+			index: b
+		});
+	}
+	return {
+		entries,
+		trailer: dict
+	};
+}
+async function readSection(bytes, offset) {
+	if (!Number.isInteger(offset) || offset < 0 || offset >= bytes.length) throw new Error("Xref offset out of range");
+	return readToken(bytes, offset).token === "xref" ? readTable(bytes, offset) : readStream(bytes, offset);
+}
+/** Newest entry wins along the /Prev chain (and a hybrid file's /XRefStm). Undefined when startxref or a section cannot be read. */
+async function readXref(bytes) {
+	try {
+		const entries = /* @__PURE__ */ new Map();
+		const visited = /* @__PURE__ */ new Set();
+		let trailer;
+		let next = findStartxref(bytes);
+		while (next !== void 0 && !visited.has(next)) {
+			visited.add(next);
+			const section = await readSection(bytes, next);
+			trailer ??= section.trailer;
+			const hybrid = section.trailer.entries.get("XRefStm");
+			if (typeof hybrid === "number" && !visited.has(hybrid)) {
+				visited.add(hybrid);
+				const extra = await readSection(bytes, hybrid);
+				for (const [num, e] of extra.entries) if (!entries.has(num)) entries.set(num, e);
+			}
+			for (const [num, e] of section.entries) if (!entries.has(num)) entries.set(num, e);
+			const prev = section.trailer.entries.get("Prev");
+			next = typeof prev === "number" ? prev : void 0;
+		}
+		return trailer ? {
+			entries,
+			trailer
+		} : void 0;
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/pdf/objects.ts
+var Reader = class {
+	bytes;
+	xref;
+	trailer;
+	objectStreams = /* @__PURE__ */ new Map();
+	constructor(bytes, xref) {
+		this.bytes = bytes;
+		this.xref = xref;
+		this.trailer = xref.trailer;
+	}
+	async get(ref) {
+		try {
+			return await this.load(ref, true);
+		} catch {
+			return;
+		}
+	}
+	async resolve(v) {
+		return isRef(v) ? this.get(v) : v;
+	}
+	/** `followLength` is false while resolving a /Length, so a self-referencing length cannot recurse. */
+	async load(ref, followLength) {
+		const entry = this.xref.entries.get(ref.num);
+		if (!entry || entry.type === "free") return void 0;
+		if (entry.type === "offset") {
+			if (entry.gen !== ref.gen) return void 0;
+			const obj = parseIndirect(this.bytes, entry.offset);
+			return obj.num === ref.num && obj.gen === ref.gen ? obj.value : void 0;
+		}
+		if (ref.gen !== 0) return void 0;
+		const container = await this.objectStream(entry.stream, followLength);
+		if (!container) return void 0;
+		let pair = container.pairs[entry.index];
+		if (pair?.num !== ref.num) pair = container.pairs.find((p) => p.num === ref.num);
+		if (!pair) return void 0;
+		return parseValue(container.decoded, container.first + pair.offset).value;
+	}
+	objectStream(num, followLength) {
+		let cached = this.objectStreams.get(num);
+		if (!cached) {
+			cached = this.readObjectStream(num, followLength).catch(() => void 0);
+			this.objectStreams.set(num, cached);
+		}
+		return cached;
+	}
+	async readObjectStream(num, followLength) {
+		const entry = this.xref.entries.get(num);
+		if (entry?.type !== "offset") return void 0;
+		const obj = parseIndirect(this.bytes, entry.offset);
+		const dict = obj.value;
+		if (obj.num !== num || !isDict(dict) || obj.streamStart === void 0) return void 0;
+		const n = dict.entries.get("N");
+		const first = dict.entries.get("First");
+		if (typeof n !== "number" || typeof first !== "number") return void 0;
+		let length = dict.entries.get("Length");
+		if (isRef(length)) length = followLength ? await this.loadLength(length) : void 0;
+		const decoded = await decodeStream(this.bytes, dict, obj.streamStart, typeof length === "number" ? length : void 0);
+		const pairs = [];
+		let at = 0;
+		for (let i = 0; i < n; i++) {
+			const a = parseValue(decoded, at);
+			const b = parseValue(decoded, a.end);
+			if (typeof a.value !== "number" || typeof b.value !== "number") return void 0;
+			pairs.push({
+				num: a.value,
+				offset: b.value
+			});
+			at = b.end;
+		}
+		return {
+			decoded,
+			first,
+			pairs
+		};
+	}
+	async loadLength(ref) {
+		try {
+			return await this.load(ref, false);
+		} catch {
+			return;
+		}
+	}
+};
+/** Undefined when the file is encrypted (`/Encrypt` in the trailer) or its xref cannot be read. */
+async function openPdfObjects(bytes) {
+	try {
+		const xref = await readXref(bytes);
+		if (!xref || xref.trailer.entries.has("Encrypt")) return void 0;
+		return new Reader(bytes, xref);
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/model/annotations/embedded-fields.ts
+/**
+* `a` with `fields` merged in: `callout`, `fringe`, `head` and the font keys of `defaultStyle`
+* on a FreeText, `icon` on a note. Undefined when `a` is not embedded, the fields do not fit its
+* type, or the result fails the schema.
+*/
+function withEmbeddedFields(a, fields) {
+	if (a.source !== "pdf") return void 0;
+	const { callout, fringe, head, icon, font } = fields;
+	let candidate;
+	if (a.type === "text") {
+		if (icon === void 0 || callout || fringe || head !== void 0 || font) return void 0;
+		candidate = {
+			...a,
+			icon
+		};
+	} else if (a.type === "freetext") {
+		if (icon !== void 0) return void 0;
+		candidate = {
+			...a,
+			...callout ? { callout } : {},
+			...fringe ? { fringe } : {},
+			...head !== void 0 ? { head } : {},
+			defaultStyle: {
+				...a.defaultStyle,
+				...font
+			}
+		};
+	} else return;
+	const parsed = AnnotationSchema.safeParse(candidate);
+	return parsed.success ? parsed.data : void 0;
+}
+/**
+* Reads every target once, calling `getData` only if a target names an annotation in
+* `annotations` by an object reference, and returns the fields read, by id. A target the file
+* adds nothing to, or whose fields would fail the schema, is left out. Never throws: any
+* failure leaves the annotations as they are.
+*/
+async function readEmbeddedFields(annotations, targets, getData) {
+	const read = /* @__PURE__ */ new Map();
+	if (targets.length === 0) return read;
+	try {
+		const byId = new Map(annotations.map((a) => [a.id, a]));
+		const work = targets.flatMap((target) => {
+			const current = byId.get(target.id);
+			const ref = refOfPdfjsId(target.id.split(":")[2] ?? "");
+			return current && ref ? [{
+				target,
+				current,
+				ref
+			}] : [];
+		});
+		if (work.length === 0) return read;
+		const objs = await openPdfObjects(await getData());
+		if (!objs) return read;
+		for (const { target, current, ref } of work) try {
+			const fields = await readFields(objs, target, ref);
+			if (fields && withEmbeddedFields(current, fields)) read.set(current.id, fields);
+		} catch {}
+	} catch {}
+	return read;
+}
+async function readFields(objs, target, ref) {
+	if (target.subtype === "Text") {
+		const icon = await readTextIcon(objs, ref);
+		return icon === void 0 ? void 0 : { icon };
+	}
+	const fields = await readFreeTextFields(objs, ref, target.rect, target.daFont);
+	return Object.keys(fields).length > 0 ? fields : 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() {
@@ -1174,6 +1897,7 @@ function isProduction() {
 }
 //#endregion
 //#region src/model/annotations/history.ts
+const noop = () => {};
 /**
 * Snapshot-based undo and redo over an uncontrolled store.
 *
@@ -1193,6 +1917,8 @@ function createHistory(store, opts = {}) {
 		batch(fn) {
 			fn();
 		},
+		track: () => noop,
+		react: () => noop,
 		destroy() {}
 	};
 	const limit = opts.limit ?? 200;
@@ -1200,14 +1926,84 @@ function createHistory(store, opts = {}) {
 	const redoStack = [];
 	let previous = store.list.get();
 	let replaying = false;
-	/** Open batch depth; while above zero, changes update `previous` but push no entry. */
+	/**
+	* Open step depth (batches, and an edit while its reactions run); while above zero, changes
+	* update the baselines but push no entry.
+	*/
 	let depth = 0;
-	/** The list when the outermost batch opened (or was restarted by a replace). */
-	let batchStart = null;
+	/** The lists when the outermost step opened (or were restarted by a replace). */
+	let start = null;
+	/** Each tracked store with its list as of the last change history saw. */
+	const tracked = /* @__PURE__ */ new Map();
+	const reactions = /* @__PURE__ */ new Set();
 	const sync = () => {
 		canUndo.set(undoStack.length > 0);
 		canRedo.set(redoStack.length > 0);
 	};
+	const push = (entry) => {
+		undoStack.push(entry);
+		if (undoStack.length > limit) undoStack.shift();
+		redoStack.length = 0;
+		sync();
+	};
+	/**
+	* Forgets `recordStore`'s records in every entry, so undo and redo leave it alone. An entry
+	* left with nothing to replay (no annotation change, no other store) is dropped.
+	*/
+	const dropEntries = (recordStore) => {
+		for (const stack of [undoStack, redoStack]) {
+			const kept = stack.filter((entry) => {
+				if (!entry.records.delete(recordStore)) return true;
+				const { before, after } = entry.annotations;
+				return entry.records.size > 0 || !sameList(before, after);
+			});
+			stack.splice(0, stack.length, ...kept);
+		}
+		sync();
+	};
+	const resetStacks = () => {
+		undoStack.length = 0;
+		redoStack.length = 0;
+		sync();
+	};
+	/** Opens the outermost step from `annotations` and every tracked store's baseline. */
+	const open = (annotations) => {
+		const records = /* @__PURE__ */ new Map();
+		for (const [s, t] of tracked) records.set(s, t.previous);
+		start = {
+			annotations,
+			records
+		};
+	};
+	/**
+	* Closes the outermost step: one entry for everything that changed since it opened. A step
+	* whose lists end where they began (the same objects in the same order) records nothing.
+	*/
+	const close = () => {
+		const from = start;
+		start = null;
+		if (!from) return;
+		const annotations = {
+			before: from.annotations,
+			after: store.list.get()
+		};
+		previous = annotations.after;
+		const records = /* @__PURE__ */ new Map();
+		for (const [s, t] of tracked) {
+			const before = from.records.get(s) ?? t.previous;
+			const after = s.list.get();
+			t.previous = after;
+			if (!sameList(before, after)) records.set(s, {
+				before,
+				after
+			});
+		}
+		if (records.size === 0 && sameList(annotations.before, annotations.after)) return;
+		push({
+			annotations,
+			records
+		});
+	};
 	let destroyed = false;
 	const unsubscribe = store.on("change", (change) => {
 		const current = store.list.get();
@@ -1215,31 +2011,45 @@ function createHistory(store, opts = {}) {
 			previous = current;
 			return;
 		}
+		if (change.kind === "replace" && change.reason === "embedded") {
+			const fill = (list) => list.map((a) => {
+				const f = change.fields.get(a.id);
+				return f && withEmbeddedFields(a, f) || a;
+			});
+			for (const { annotations } of [...undoStack, ...redoStack]) {
+				annotations.before = fill(annotations.before);
+				annotations.after = fill(annotations.after);
+			}
+			if (start) start.annotations = fill(start.annotations);
+			previous = current;
+			return;
+		}
 		if (change.kind === "replace") {
-			undoStack.length = 0;
-			redoStack.length = 0;
 			previous = current;
-			if (depth > 0) batchStart = current;
-			sync();
+			if (depth > 0) open(current);
+			resetStacks();
 			return;
 		}
 		if (depth > 0) {
 			previous = current;
+			for (const fn of [...reactions]) fn(change);
 			return;
 		}
-		undoStack.push({
-			before: previous,
-			after: current
-		});
-		if (undoStack.length > limit) undoStack.shift();
-		redoStack.length = 0;
-		previous = current;
-		sync();
+		open(previous);
+		depth++;
+		try {
+			for (const fn of [...reactions]) fn(change);
+		} finally {
+			if (--depth === 0 && !destroyed) close();
+		}
 	});
-	const apply = (list) => {
+	/** Replays a step's lists under the `replaying` guard, skipping stores no longer tracked. */
+	const apply = (entry, side) => {
 		replaying = true;
 		try {
-			store.replaceAll([...list], "history");
+			const { annotations } = entry;
+			if (!sameList(annotations.before, annotations.after)) store.replaceAll([...annotations[side]], "history");
+			for (const [s, snapshot] of entry.records) if (tracked.has(s)) s.replaceAll([...snapshot[side]], "history");
 		} finally {
 			replaying = false;
 		}
@@ -1251,14 +2061,14 @@ function createHistory(store, opts = {}) {
 			const entry = undoStack.pop();
 			if (destroyed || !entry) return;
 			redoStack.push(entry);
-			apply(entry.before);
+			apply(entry, "before");
 			sync();
 		},
 		redo() {
 			const entry = redoStack.pop();
 			if (destroyed || !entry) return;
 			undoStack.push(entry);
-			apply(entry.after);
+			apply(entry, "after");
 			sync();
 		},
 		batch(fn) {
@@ -1266,50 +2076,202 @@ function createHistory(store, opts = {}) {
 				fn();
 				return;
 			}
-			if (depth++ === 0) batchStart = store.list.get();
+			if (depth++ === 0) open(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();
-					}
-				}
+				if (--depth === 0 && !destroyed) close();
 			}
 		},
+		track(recordStore) {
+			if (destroyed || tracked.has(recordStore)) return noop;
+			const unsubscribeStore = recordStore.on("change", (change) => {
+				const t = tracked.get(recordStore);
+				if (!t) return;
+				const before = t.previous;
+				const current = recordStore.list.get();
+				t.previous = current;
+				if (replaying || change.kind === "replace" && change.reason === "history") return;
+				if (change.kind === "replace") {
+					if (depth > 0 && start) start.records.set(recordStore, current);
+					dropEntries(recordStore);
+					return;
+				}
+				if (depth > 0) return;
+				push({
+					annotations: {
+						before: previous,
+						after: previous
+					},
+					records: /* @__PURE__ */ new Map([[recordStore, {
+						before,
+						after: current
+					}]])
+				});
+			});
+			tracked.set(recordStore, {
+				previous: recordStore.list.get(),
+				unsubscribe: unsubscribeStore
+			});
+			if (start) start.records.set(recordStore, recordStore.list.get());
+			return () => {
+				if (tracked.get(recordStore)?.unsubscribe !== unsubscribeStore) return;
+				unsubscribeStore();
+				tracked.delete(recordStore);
+				start?.records.delete(recordStore);
+			};
+		},
+		react(fn) {
+			if (destroyed) return noop;
+			const run = (edit) => fn(edit);
+			reactions.add(run);
+			return () => {
+				reactions.delete(run);
+			};
+		},
 		destroy() {
 			destroyed = true;
-			batchStart = null;
+			start = null;
 			unsubscribe();
-			undoStack.length = 0;
-			redoStack.length = 0;
-			sync();
+			for (const t of tracked.values()) t.unsubscribe();
+			tracked.clear();
+			reactions.clear();
+			resetStacks();
 		},
 		clear() {
-			undoStack.length = 0;
-			redoStack.length = 0;
 			previous = store.list.get();
-			sync();
+			for (const [s, t] of tracked) t.previous = s.list.get();
+			resetStacks();
 		}
 	};
 }
-/** The same annotation objects in the same order. */
-function sameAnnotations(a, b) {
+/** The same objects in the same order. */
+function sameList(a, b) {
 	return a === b || a.length === b.length && a.every((x, i) => x === b[i]);
 }
 //#endregion
+//#region src/model/annotations/gloss-mapping.ts
+const isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+/** `rest` with `own` merged into a copy of its `custom.inkbar`; `own` wins. */
+function withCustom(rest, own) {
+	const custom = isObject(rest.custom) ? rest.custom : {};
+	const inkbar = isObject(custom.inkbar) ? custom.inkbar : {};
+	return {
+		...rest,
+		custom: {
+			...custom,
+			inkbar: {
+				...inkbar,
+				...own
+			}
+		}
+	};
+}
+/**
+* An annotation as a Gloss file writes it. Gloss has no loupe or mask and no pen pressure or
+* free-text border colour, so these go under `custom.inkbar`, with loupes and masks written as
+* the circle or square they draw.
+*/
+function toFile(annotation) {
+	switch (annotation.type) {
+		case "ink": {
+			const { pressure, ...rest } = annotation;
+			return pressure ? withCustom(rest, { pressure }) : rest;
+		}
+		case "freetext": {
+			const { borderColor, ...rest } = annotation;
+			return borderColor ? withCustom(rest, { borderColor }) : rest;
+		}
+		case "loupe": {
+			const { magnification, ...rest } = annotation;
+			return withCustom({
+				...rest,
+				type: "circle"
+			}, {
+				type: "loupe",
+				magnification
+			});
+		}
+		case "mask": {
+			const { shape, dim, ...rest } = annotation;
+			return withCustom({
+				...rest,
+				type: shape === "ellipse" ? "circle" : "square"
+			}, {
+				type: "mask",
+				dim
+			});
+		}
+		default: return annotation;
+	}
+}
+/**
+* Moves `keys` from `custom.inkbar` to the top level of `raw`, replacing any top-level value
+* (an absent key deletes it), then drops `custom.inkbar`, and `custom`, if that leaves them
+* empty. Everything else under `custom` stays as it was.
+*/
+function lift(raw, inkbar, keys, extra = {}) {
+	const item = {
+		...raw,
+		...extra
+	};
+	const left = { ...inkbar };
+	let consumed = false;
+	for (const key of keys) {
+		delete item[key];
+		if (key in left) {
+			item[key] = left[key];
+			delete left[key];
+			consumed = true;
+		}
+	}
+	if (!consumed || !isObject(raw.custom)) return item;
+	const { inkbar: _inkbar, ...others } = raw.custom;
+	const custom = Object.keys(left).length > 0 ? {
+		...others,
+		inkbar: left
+	} : others;
+	if (Object.keys(custom).length > 0) item.custom = custom;
+	else delete item.custom;
+	return item;
+}
+/**
+* A raw file item as Inkbar parses it: Inkbar's own data moves out of `custom.inkbar`. An item
+* it doesn't recognise passes through unchanged.
+*/
+function fromFile(raw) {
+	const inkbar = isObject(raw.custom) && isObject(raw.custom.inkbar) ? raw.custom.inkbar : {};
+	const from = (keys, extra) => ({
+		item: lift(raw, inkbar, keys, extra),
+		lifted: keys
+	});
+	const unchanged = {
+		item: raw,
+		lifted: []
+	};
+	switch (raw.type) {
+		case "ink": return from(["pressure"]);
+		case "freetext": return from(["borderColor"]);
+		case "circle":
+			if (inkbar.type === "loupe") return from(["type", "magnification"]);
+			if (inkbar.type === "mask") return from(["type", "dim"], { shape: "ellipse" });
+			return unchanged;
+		case "square":
+			if (inkbar.type === "mask") return from(["type", "dim"], { shape: "rect" });
+			return unchanged;
+		default: return unchanged;
+	}
+}
+//#endregion
 //#region src/model/annotations/json.ts
-const KNOWN_TYPES = new Set(ExportedAnnotationSchema.options.flatMap((o) => [...o.shape.type._zod.values]));
+/**
+* @internal The Gloss types this core parses, taken from its own schemas rather than Gloss's
+* list, so a type a later Gloss adds is still treated as foreign here. Loupes and masks are
+* Inkbar's own types: a file writes them as circles and squares, so a `loupe` or `mask` item is
+* foreign too.
+*/
+const KNOWN_TYPES = new Set(ExportedAnnotationSchema.options.flatMap((o) => [...o.shape.type._zod.values]).filter((type) => type !== "loupe" && type !== "mask"));
 /**
 * 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.
@@ -1318,21 +2280,24 @@ const KNOWN_TYPES = new Set(ExportedAnnotationSchema.options.flatMap((o) => [...
 * 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.
+* Gloss has no loupe or mask, pen pressure or free-text border colour, so Inkbar writes these
+* under `custom.inkbar`, with loupes and masks as the circle or square they draw. Every other key
+* under `custom` goes out as it is.
+*
+* The result validates against the Gloss schema (`gloss-format/schema.json`). Foreign items
+* validate as unknown annotations while their type is one Gloss does not define.
 */
 function exportAnnotations(store, preserved = [], documentKey) {
-	const session = store.list.get().filter((a) => a.source === "session").map(({ source: _source, locked: _locked, ...rest }) => rest);
+	const session = store.list.get().filter((a) => a.source === "session").map(({ source: _source, locked: _locked, ...rest }) => toFile(rest));
 	return {
-		format: ANNOTATION_FORMAT,
-		version: 1,
+		format: GLOSS_FORMAT$1,
+		version: GLOSS_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),
+* Validates the envelope (throws a TypeError when it is not a gloss v1 document),
 * then each item on its own. Embedded annotations are never touched; imported items become
 * session annotations.
 */
@@ -1353,7 +2318,7 @@ function importAnnotations(store, data, opts) {
 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("; ")}`);
+	if (!envelope.success) throw new TypeError(`Expected a ${GLOSS_FORMAT$1} v${GLOSS_VERSION$1} 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,
@@ -1389,21 +2354,28 @@ function planImport(store, data, opts) {
 		accepted.add(id);
 		return true;
 	};
-	envelope.data.annotations.forEach((item, index) => {
-		const type = item?.type;
+	envelope.data.annotations.forEach((raw, index) => {
+		const type = raw?.type;
 		if (typeof type === "string" && !KNOWN_TYPES.has(type)) {
-			if (!isForeign(item)) result.errors.push({
+			if (!isForeign(raw)) 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);
+			else if (claim(raw.id, index)) result.unknown.push(raw);
 			return;
 		}
+		const { item, lifted } = isRecord(raw) && typeof type === "string" ? fromFile(raw) : {
+			item: raw,
+			lifted: []
+		};
 		const parsed = ExportedAnnotationSchema.safeParse(item);
 		if (!parsed.success) {
 			result.errors.push({
 				index,
-				issues: parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`)
+				issues: parsed.error.issues.map((i) => {
+					const path = i.path.join(".");
+					return `${typeof i.path[0] === "string" && lifted.includes(i.path[0]) ? `custom.inkbar.${path}` : path}: ${i.message}`;
+				})
 			});
 			return;
 		}
@@ -1435,8 +2407,11 @@ function planImport(store, data, opts) {
 		}
 	};
 }
+function isRecord(item) {
+	return typeof item === "object" && item !== null && !Array.isArray(item);
+}
 function isForeign(item) {
-	if (typeof item !== "object" || item === null || Array.isArray(item)) return false;
+	if (!isRecord(item)) return false;
 	const { type, id, page } = item;
 	return typeof type === "string" && typeof id === "string" && typeof page === "number";
 }
@@ -1600,7 +2575,6 @@ function createAnnotationStore(opts) {
 		}
 		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);
 	}
@@ -1615,10 +2589,12 @@ function createAnnotationStore(opts) {
 		if (!entry) return;
 		pending.delete(key);
 		if (pending.size === 0) proposed = void 0;
+		pruneSelection(basis());
 		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 (change.kind !== "replace") emitter.emit("edit", change);
 		if (controlled) {
 			if (change.kind !== "replace") {
 				const key = changeKey(change);
@@ -1717,6 +2693,7 @@ function createAnnotationStore(opts) {
 				after
 			};
 			if (controlled && before.source === "pdf") {
+				emitter.emit("edit", change);
 				list.set(swap(list.get()));
 				if (proposed) proposed = next;
 				emitter.emit("change", change);
@@ -1785,6 +2762,26 @@ function createAnnotationStore(opts) {
 				reason: "import"
 			});
 		},
+		_patchEmbedded(fields) {
+			if (destroyed) return;
+			const applied = /* @__PURE__ */ new Map();
+			const merge = (items) => items.map((a) => {
+				const f = a.source === "pdf" ? fields.get(a.id) : void 0;
+				const merged = f && withEmbeddedFields(a, f);
+				if (!merged) return a;
+				applied.set(a.id, f);
+				return merged;
+			});
+			const next = merge(list.get());
+			if (applied.size === 0) return;
+			list.set(next);
+			if (proposed) proposed = merge(proposed);
+			emitter.emit("change", {
+				kind: "replace",
+				reason: "embedded",
+				fields: applied
+			});
+		},
 		on: (event, fn) => emitter.on(event, fn),
 		destroy() {
 			destroyed = true;
@@ -2019,6 +3016,8 @@ async function openDocument(source, options) {
 	});
 	const embedded = [];
 	let preserved = [];
+	/** Embedded annotations whose PDF.js data lacks fields the file holds; read after `ready`. */
+	const targets = [];
 	const destroyedError = () => new InkError("DocumentDestroyed", "The document has been destroyed");
 	const ready = (async () => {
 		const pdfjs = await loadPdfjs(options.assets);
@@ -2059,6 +3058,7 @@ async function openDocument(source, options) {
 		});
 		embedded.push(...summarise(perPage.map((r) => r.counts)));
 		const fromFile = perPage.flatMap((r) => r.annotations);
+		targets.push(...perPage.flatMap((r) => r.targets));
 		if (fromFile.length > 0) store._setEmbedded(fromFile);
 	})().then(() => {
 		status.set({ state: "ready" });
@@ -2075,7 +3075,14 @@ async function openDocument(source, options) {
 	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 {
+	ready.then(() => {
+		if (destroyed || !handles) return;
+		const { proxy } = handles;
+		readEmbeddedFields(store.list.get(), targets, () => proxy.getData()).then((patched) => {
+			if (!destroyed && patched.size > 0) store._patchEmbedded(patched);
+		}).catch(() => void 0);
+	}, () => void 0);
+	const doc = {
 		key: resolved.key,
 		status: readonly(status),
 		ready,
@@ -2086,6 +3093,9 @@ async function openDocument(source, options) {
 			if (!handles) throw statusError(status.get());
 			return textContentFromPdfjs(page, await (await handles.getPage(page)).getTextContent());
 		},
+		async pageText(page) {
+			return (await doc.text(page)).items.map((item) => item.str).join(" ");
+		},
 		annotations: store,
 		embedded,
 		history,
@@ -2115,6 +3125,7 @@ async function openDocument(source, options) {
 			return handles;
 		}
 	};
+	return doc;
 }
 const EMBEDDED_CONCURRENCY = 8;
 /** Runs `task(0..count-1)` with at most `limit` in flight; results come back in index order. */
@@ -2835,23 +3846,6 @@ function createToolStyle(deps) {
 	};
 }
 //#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);
@@ -2968,24 +3962,41 @@ function rectOf(a, b) {
 		height: Math.abs(b.y - a.y)
 	};
 }
-/** Vertices round the ellipse inscribed in `rect`, the first at the top centre, clockwise on the page. */
+/**
+* Vertices round a circle, the first at the top centre, clockwise on the page, stretched so their
+* bounds fill `rect`.
+*/
 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 unit = 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))
+			x: r * Math.sin(angle),
+			y: r * Math.cos(angle)
 		};
 	});
+	const xs = unit.map((p) => p.x);
+	const ys = unit.map((p) => p.y);
+	const fit = (v, min, max, start, size) => clean(max > min ? start + (v - min) / (max - min) * size : start + size / 2);
+	const [minX, maxX, minY, maxY] = [
+		Math.min(...xs),
+		Math.max(...xs),
+		Math.min(...ys),
+		Math.max(...ys)
+	];
+	return unit.map((p) => ({
+		x: fit(p.x, minX, maxX, rect.x, rect.width),
+		y: fit(p.y, minY, maxY, rect.y, rect.height)
+	}));
 }
-/** A star's `2 * points` vertices, outer and inner alternating, the first at the top centre. */
+/**
+* A star's `2 * points` vertices, outer and inner alternating, stretched to fill `rect`, 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. */
+/** A regular polygon's vertices, stretched to fill `rect`, the first at the top centre. */
 function polygonVertices(rect, sides) {
 	return ring(rect, Math.max(3, Math.round(sides)), () => 1);
 }
@@ -3085,16 +4096,13 @@ function shapeInput(kind, page, start, end, opts) {
 			type: "line",
 			page,
 			start,
-			end,
-			head: "None",
-			tail: "None"
+			end
 		};
 		case "arrow": return {
 			type: "line",
 			page,
 			start,
 			end,
-			tail: "OpenArrow",
 			intent: "LineArrow"
 		};
 		case "rectangle": return {
@@ -3917,6 +4925,6 @@ function createSignatureLibrary(store) {
 	};
 }
 //#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 };
+export { importAnnotations as $, derived as $t, styleGroupOf as A, RectSchema as At, isTextMarkup as B, withCalloutBounds as Bt, repliesTo as C, NoteIconSchema as Ct, STYLE_GROUPS as D, PolygonSchema as Dt, withoutReplies as E, PolySchema as Et, typesInGroup as F, TextMarkupSchema as Ft, resizedRect as G, isKnown as Gt, movedEndpoint as H, LINE_ENDINGS as Ht, hasCallout as I, FringeSchema as It, withBox as J, cssVariableDefaults as Jt, scaled as K, pdfNameSet as Kt, hasCornerHandles as L, calloutStroke as Lt, styleGroupsOf as M, ShapeSchema as Mt, supportedProps as N, SquareSchema as Nt, createToolStyle as O, PolylineSchema as Ot, toFields as P, StampSchema as Pt, exportAnnotations as Q, createRecordStore as Qt, hasRectGeometry as R, freeTextBox as Rt, isThreadRoot as S, MaskSchema as St, threadRoot as T, PointSchema as Tt, movedTip as U, NOTE_ICONS as Ut, keepsAspect as V, INTENTS as Vt, resizedBox as W, PDF_NAME$1 as Wt, createAnnotationStore as X, staticDefaults as Xt, openDocument as Y, normalizeColor as Yt, deriveRect as Z, mergeLineRects as Zt, defaultEnds as _, unionRects as _n, IMAGE_DATA_URL as _t, createLocalSignatureStore as a, multiplyMatrix as an, pdfColorToHex as at, isAbandonedNote as b, isInkError as bn, LineSchema as bt, normaliseInk as c, quadsFromFlat as cn, AnnotationSchema as ct, recogniseStroke as d, rectFromPoints as dn, FreeTextSchema as dt, readonly as en, createHistory as et, DEFAULT_CORNER_RADIUS as f, rectFromQuad as fn, FreeTextStyleSchema as ft, constrain as g, translateRect as gn, GLOSS_VERSION$1 as gt, SHAPE_KINDS as h, translateQuad as hn, GLOSS_SCHEMA_ID as ht, createInkTemplate as i, invertMatrix as in, importedId as it, styleGroupOfType as j, RedactSchema as jt, fromAnnotation as k, QuadSchema as kt, placeSignature as l, quadsFromRect as ln, CircleSchema as lt, DEFAULT_SHAPE_SIZE as m, rectsIntersect as mn, GLOSS_MEDIA_TYPE as mt, SIGNATURE_INK_WIDTH as n, applyMatrix as nn, SUPPORTED_SUBTYPES as nt, createMemorySignatureStore as o, pointsFromFlat as on, summarise as ot, DEFAULT_SHAPE_OPTIONS as p, rectFromQuads as pn, GLOSS_FORMAT$1 as pt, translated as q, parsePdfDate as qt, createImageTemplate as r, approxEqual as rn, importEmbeddedPage as rt, createSignatureLibrary as s, quadFromRect as sn, AnnotationDocumentSchema as st, DEFAULT_SIGNATURE_WIDTH as t, writable as tn, isProduction as tt, RECOGNISE_THRESHOLD as u, rectContainsPoint as un, ExportedAnnotationSchema as ut, isPointerOnlyKind as v, Emitter as vn, InkSchema as vt, threadOf as w, NoteSchema as wt, isReply as x, LoupeSchema as xt, shapeInput as y, InkError as yn, LineEndingSchema as yt, isBubble as z, isStandardCallout as zt };
 
-//# sourceMappingURL=signatures-DF2VmNVa.mjs.map
+//# sourceMappingURL=signatures-D68fuLlt.mjs.map