@embedpdf/plugin-annotation 3.0.0-next.12 → 3.0.0-next.14

package/dist/{capability-R7dgogJs.cjs → capability-Bt320iJP.cjs}

@@ -1,4 +1,5 @@
 const require_seam = require("./seam-6pJeKOOJ.cjs");
+const require_tools = require("./tools-B3i1gjRs.cjs");
 const require_types = require("./types-Dlhdw2k_.cjs");
 let _embedpdf_core = require("@embedpdf/core");
 let _embedpdf_plugin_actions_contract = require("@embedpdf/plugin-actions/contract");
@@ -106,6 +107,15 @@ const polyCloudy = (a) => a.geom.t === "poly" && a.geom.closed ? { cloudyIntensi
 /** The visual-bounds `/Rect` (stroke + border included) of a stroke geom. */
 const visualRect = (a, crop) => {
 	const g = a.geom;
+	if (a.measure) {
+		const bounds = (0, _embedpdf_core_annotation.measurementLayout)(g, a.measure, a.style)?.visualBounds;
+		if (bounds) return { rect: {
+			left: crop.left + bounds.x,
+			right: crop.left + bounds.x + bounds.width,
+			top: crop.top - bounds.y,
+			bottom: crop.top - bounds.y - bounds.height
+		} };
+	}
 	if (g.t === "line" || g.t === "ink") return { rect: (0, _embedpdf_core_annotation.geomPdfBounds)(g, a.style.strokeWidth, crop) };
 	if (g.t === "poly") return { rect: (0, _embedpdf_core_annotation.geomPdfBounds)(g, a.style.strokeWidth, crop, a.style.border) };
 	return {};
@@ -137,18 +147,29 @@ const strokeProps = {
 const line = {
 	ingest: (dto, crop) => {
 		const d = dto;
-		return { geom: {
-			t: "line",
-			a: (0, _embedpdf_core_annotation.pdfToContentPoint)(d.linePoints.start, crop),
-			b: (0, _embedpdf_core_annotation.pdfToContentPoint)(d.linePoints.end, crop),
-			ends: d.lineEndings,
-			...require_seam.rotFromDTO(d.rotation)
-		} };
+		return {
+			...d.intent === "LineDimension" ? { measure: {
+				intent: d.intent,
+				measure: d.measure ?? null,
+				caption: d.caption ?? { enabled: false },
+				leader: d.leader ?? void 0,
+				crop,
+				text: d.contents ?? ""
+			} } : {},
+			geom: {
+				t: "line",
+				a: (0, _embedpdf_core_annotation.pdfToContentPoint)(d.linePoints.start, crop),
+				b: (0, _embedpdf_core_annotation.pdfToContentPoint)(d.linePoints.end, crop),
+				ends: d.lineEndings,
+				...require_seam.rotFromDTO(d.rotation)
+			}
+		};
 	},
 	geometry: (a, crop) => {
 		const g = a.geom;
 		if (g.t !== "line") return null;
 		return {
+			...a.measure?.intent === "LineDimension" ? { contents: (0, _embedpdf_core_annotation.distanceLabel)(g, a.measure) } : {},
 			linePoints: {
 				start: (0, _embedpdf_core_annotation.contentToPdfPoint)(g.a, crop),
 				end: (0, _embedpdf_core_annotation.contentToPdfPoint)(g.b, crop)
@@ -157,29 +178,55 @@ const line = {
 			...advisoryRotation(g)
 		};
 	},
-	prop: strokeProps
+	prop: strokeProps,
+	draftExtras: (a) => a.measure?.intent === "LineDimension" ? {
+		intent: a.measure.intent,
+		measure: a.measure.measure?.subtype === "RL" ? a.measure.measure : null,
+		caption: a.measure.caption,
+		leader: a.measure.leader,
+		subject: "Distance"
+	} : {}
 };
 const polyProjection = (closed) => ({
 	ingest: (dto, crop) => {
 		const d = dto;
-		return { geom: {
-			t: "poly",
-			points: d.vertices.map((p) => (0, _embedpdf_core_annotation.pdfToContentPoint)(p, crop)),
-			closed,
-			..."lineEndings" in d ? { ends: d.lineEndings } : {},
-			...require_seam.rotFromDTO(d.rotation)
-		} };
+		return {
+			...d.intent === "PolygonDimension" || d.intent === "PolyLineDimension" ? { measure: {
+				intent: d.intent,
+				measure: d.measure ?? null,
+				caption: d.caption ?? { enabled: false },
+				crop,
+				text: d.contents ?? ""
+			} } : {},
+			geom: {
+				t: "poly",
+				points: d.vertices.map((p) => (0, _embedpdf_core_annotation.pdfToContentPoint)(p, crop)),
+				closed,
+				..."lineEndings" in d ? { ends: d.lineEndings } : {},
+				...require_seam.rotFromDTO(d.rotation)
+			}
+		};
 	},
 	geometry: (a, crop) => {
 		const g = a.geom;
 		if (g.t !== "poly") return null;
 		return {
+			...a.measure && a.measure.intent !== "LineDimension" ? {
+				contents: (0, _embedpdf_core_annotation.shapeMeasurementLabel)(g, a.measure),
+				caption: a.measure.caption
+			} : {},
 			vertices: g.points.map((p) => (0, _embedpdf_core_annotation.contentToPdfPoint)(p, crop)),
 			...visualRect(a, crop),
 			...advisoryRotation(g)
 		};
 	},
-	prop: strokeProps
+	prop: strokeProps,
+	draftExtras: (a) => a.measure && a.measure.intent !== "LineDimension" ? {
+		intent: a.measure.intent,
+		measure: a.measure.measure?.subtype === "RL" ? a.measure.measure : null,
+		caption: a.measure.caption,
+		subject: closed ? "Area" : "Perimeter"
+	} : {}
 });
 const polygon = polyProjection(true);
 const polyline = polyProjection(false);
@@ -208,18 +255,387 @@ const ink = {
 	draftExtras: (a) => a.intent === "ink-highlight" ? { intent: a.intent } : {}
 };
 //#endregion
+//#region src/rich-text.ts
+/**
+* Rich text POLICY — what the annotation plugin decides about a free-text
+* annotation's rich document, kept pure so every framework's editor glue
+* behaves identically (the mechanics live in `@embedpdf/web`'s binding, the
+* run algebra in the core):
+*
+*   • the rich document of any annot (the DTO's, or one synthesised from the
+*     plain text + the `/DA` text style for a draft that has no DTO yet)
+*   • a flat props patch → the run delta it means for a text RANGE (font,
+*     size, colour, bold/italic/underline) and the keys left for the body
+*   • what a range reads back for those keys (agree → the value, else mixed)
+*   • faces: a DTO font (standard kebab name / registered key) ↔ the face a
+*     run names (family + weight + italic) ↔ a CSS family list
+*   • the commit rule: a document nothing overrides on a plain annotation
+*     commits as `contents`; anything else as `richText`
+*/
+/** The props keys a text range takes as run deltas. */
+const RANGE_KEYS = [
+	"fontFamily",
+	"fontSize",
+	"fontColor",
+	"bold",
+	"italic",
+	"underline"
+];
+/** The engine's standard-14 vocabulary (the `StandardFont` kebab names). */
+const STANDARD_FACES = {
+	courier: {
+		family: "Courier",
+		weight: 400,
+		italic: false
+	},
+	"courier-bold": {
+		family: "Courier",
+		weight: 700,
+		italic: false
+	},
+	"courier-bold-oblique": {
+		family: "Courier",
+		weight: 700,
+		italic: true
+	},
+	"courier-oblique": {
+		family: "Courier",
+		weight: 400,
+		italic: true
+	},
+	helvetica: {
+		family: "Helvetica",
+		weight: 400,
+		italic: false
+	},
+	"helvetica-bold": {
+		family: "Helvetica",
+		weight: 700,
+		italic: false
+	},
+	"helvetica-bold-oblique": {
+		family: "Helvetica",
+		weight: 700,
+		italic: true
+	},
+	"helvetica-oblique": {
+		family: "Helvetica",
+		weight: 400,
+		italic: true
+	},
+	"times-roman": {
+		family: "Times",
+		weight: 400,
+		italic: false
+	},
+	"times-bold": {
+		family: "Times",
+		weight: 700,
+		italic: false
+	},
+	"times-bold-italic": {
+		family: "Times",
+		weight: 700,
+		italic: true
+	},
+	"times-italic": {
+		family: "Times",
+		weight: 400,
+		italic: true
+	},
+	symbol: {
+		family: "Symbol",
+		weight: 400,
+		italic: false
+	},
+	"zapf-dingbats": {
+		family: "ZapfDingbats",
+		weight: 400,
+		italic: false
+	}
+};
+/** Family names compare without case, spaces, hyphens, underscores and
+*  quotes — the engine's own rule. */
+function familyKey(family) {
+	return family.toLowerCase().replace(/[\s\-_'"]/g, "");
+}
+const STANDARD_FAMILY_KEYS = {
+	helvetica: "Helvetica",
+	arial: "Helvetica",
+	arialmt: "Helvetica",
+	sansserif: "Helvetica",
+	times: "Times",
+	timesroman: "Times",
+	timesnewroman: "Times",
+	timesnewromanpsmt: "Times",
+	serif: "Times",
+	courier: "Courier",
+	couriernew: "Courier",
+	couriernewpsmt: "Courier",
+	monospace: "Courier",
+	symbol: "Symbol",
+	zapfdingbats: "ZapfDingbats",
+	dingbats: "ZapfDingbats"
+};
+/** Web stacks with the standard families' metrics (what the DOM editor and
+*  the vector renderer show for text the engine sets in a standard font). */
+const STANDARD_STACKS = {
+	Helvetica: "Helvetica, Arial, sans-serif",
+	Times: "\"Times New Roman\", Times, serif",
+	Courier: "\"Courier New\", Courier, monospace",
+	Symbol: "serif",
+	ZapfDingbats: "serif"
+};
+/** The face a DTO font names: a standard font's family/weight/italic, a
+*  registered key's identity, else the string itself as a family. */
+function faceForFont(font, fonts) {
+	const standard = STANDARD_FACES[font];
+	if (standard) return { ...standard };
+	const registered = fonts?.().find((f) => f.key === font);
+	if (registered) return {
+		family: registered.familyName,
+		weight: registered.weight,
+		italic: registered.italic
+	};
+	return { family: font };
+}
+/** The DTO font for a face: the registered key whose identity matches (the
+*  closest weight, italic first), else the standard kebab name, else the
+*  family itself. The inverse of {@link faceForFont}. */
+function fontForFace(face, fonts) {
+	const wanted = familyKey(face.family);
+	const weight = face.weight ?? 400;
+	const italic = face.italic ?? false;
+	let best;
+	for (const f of fonts?.() ?? []) {
+		if (familyKey(f.familyName) !== wanted) continue;
+		const score = Math.abs(f.weight - weight) + (f.italic === italic ? 0 : 1e3);
+		if (!best || score < best.score) best = {
+			key: f.key,
+			score
+		};
+	}
+	if (best) return best.key;
+	const standard = STANDARD_FAMILY_KEYS[wanted];
+	if (standard) {
+		const bold = weight >= 600;
+		for (const [name, spec] of Object.entries(STANDARD_FACES)) if (spec.family === standard && spec.weight >= 600 === bold && spec.italic === italic) return name;
+		for (const [name, spec] of Object.entries(STANDARD_FACES)) if (spec.family === standard) return name;
+	}
+	return face.family;
+}
+/** The CSS family list for a face family: a standard family's web stack, a
+*  registered family's `@font-face` name (its key — see `mountWebFont`),
+*  else the family itself with a generic fallback. */
+function cssFontFamilyForFace(family, fonts) {
+	const standard = STANDARD_FAMILY_KEYS[familyKey(family)];
+	if (standard) return STANDARD_STACKS[standard];
+	const wanted = familyKey(family);
+	const registered = fonts?.().find((f) => familyKey(f.familyName) === wanted);
+	if (registered) return `"${registered.key}"`;
+	return `"${family}", sans-serif`;
+}
+/** The CSS family list for a DTO font (a standard kebab name or a key). */
+function cssFontFamilyForFont(font, fonts) {
+	const standard = STANDARD_FACES[font];
+	if (standard) return STANDARD_STACKS[standard.family];
+	return `"${font}", sans-serif`;
+}
+const hex = (css) => css.trim().toUpperCase();
+/** The rich body the `/DA` text style describes (a draft's body before its
+*  DTO exists; also the fallback for a DTO without `richText`). */
+function bodyFromTextStyle(t, fonts) {
+	const face = faceForFont(t.fontFamily, fonts);
+	return {
+		family: face.family,
+		weight: t.bold ? 700 : face.weight ?? 400,
+		italic: t.italic ?? face.italic ?? false,
+		size: t.fontSize,
+		color: hex(t.fontColor),
+		decoration: t.underline ? ["underline"] : [],
+		script: "normal",
+		letterSpacing: 0,
+		horizontalScale: 1,
+		align: t.textAlign,
+		dir: "ltr"
+	};
+}
+/** The annotation's rich document: the DTO's, else one synthesised from
+*  its plain text and text style (a draft the engine has not echoed yet). */
+function richDocOf(a, fonts) {
+	if (a.data?.subtype === "free-text" && a.data.richText) return a.data.richText;
+	return {
+		body: bodyFromTextStyle(a.text ?? {
+			fontFamily: "helvetica",
+			fontSize: 12,
+			fontColor: "#000000",
+			textAlign: "left"
+		}, fonts),
+		paragraphs: (0, _embedpdf_core_annotation.paragraphsFromPlainText)(a.data?.contents ?? "")
+	};
+}
+/**
+* The write a text edit commits: the rich paragraphs, with paragraph
+* properties equal to the body's stripped (they are inherited, not
+* overrides) and the body omitted — it stays what the props path last
+* wrote. One engine, one path: plain and formatted text alike.
+*/
+function textCommitPatch(a, paragraphs, fonts) {
+	return { richText: { paragraphs: stripBodyDefaults(paragraphs, richDocOf(a, fonts).body) } };
+}
+/**
+* Paragraph alignment/direction equal to the body's are not overrides: the
+* engine echoes them resolved, the editor renders them as inline styles and
+* serialises them back, and the commit rule must see through that (a plain
+* `/Contents` annotation must not grow an `/RC` from typing).
+*/
+function stripBodyDefaults(paragraphs, body) {
+	return paragraphs.map((p) => {
+		if ((p.align === void 0 || p.align !== body.align) && (p.dir === void 0 || p.dir !== body.dir)) return p;
+		const { align, dir, ...rest } = p;
+		return {
+			...rest,
+			...align !== void 0 && align !== body.align ? { align } : {},
+			...dir !== void 0 && dir !== body.dir ? { dir } : {}
+		};
+	});
+}
+/**
+* Split a props patch for an annotation whose editor holds a text RANGE:
+* the run delta the range takes (font → face, size, colour, bold → weight,
+* italic, underline → decoration) and the keys that still go to the body.
+*/
+function runDeltaForProps(patch, fonts) {
+	const delta = {};
+	const rest = {};
+	for (const key of Object.keys(patch)) {
+		const value = patch[key];
+		if (value === void 0) continue;
+		switch (key) {
+			case "fontFamily": {
+				const face = faceForFont(patch.fontFamily, fonts);
+				delta.family = face.family;
+				if (face.weight !== void 0) delta.weight = face.weight;
+				if (face.italic !== void 0) delta.italic = face.italic;
+				break;
+			}
+			case "fontSize":
+				delta.size = patch.fontSize;
+				break;
+			case "fontColor":
+				delta.color = hex(patch.fontColor);
+				break;
+			case "bold":
+				delta.weight = patch.bold ? 700 : 400;
+				break;
+			case "italic":
+				delta.italic = patch.italic;
+				break;
+			case "underline":
+				delta.decoration = patch.underline ? ["underline"] : [];
+				break;
+			default: rest[key] = value;
+		}
+	}
+	return {
+		delta,
+		rest
+	};
+}
+/** The style deltas of every non-empty run a range overlaps. */
+function runsInRange(doc, range) {
+	const start = Math.min(range.start, range.end);
+	const end = Math.max(range.start, range.end);
+	if (end <= start) return [];
+	const from = (0, _embedpdf_core_annotation.locateOffset)(doc, start);
+	const to = (0, _embedpdf_core_annotation.locateOffset)(doc, end);
+	const out = [];
+	for (let index = from.paragraph; index <= to.paragraph; index++) {
+		const paragraph = doc.paragraphs[index];
+		const localStart = index === from.paragraph ? from.offset : 0;
+		const localEnd = index === to.paragraph ? to.offset : paragraph.runs.reduce((n, r) => n + r.text.length, 0);
+		let pos = 0;
+		for (const run of paragraph.runs) {
+			const runEnd = pos + run.text.length;
+			if (runEnd > localStart && pos < localEnd && run.text.length > 0) out.push(run.style ?? {});
+			pos = runEnd;
+		}
+	}
+	return out;
+}
+/** The values a range reads back for the range keys — resolved against the
+*  body, one value where every run agrees, `mixed` where they don't. */
+function rangeProps(doc, range, fonts) {
+	const runs = runsInRange(doc, range);
+	const body = doc.body;
+	const resolve = (d) => ({
+		family: d.family ?? body.family,
+		weight: d.weight ?? body.weight,
+		italic: d.italic ?? body.italic,
+		size: d.size ?? body.size,
+		color: d.color ?? body.color,
+		decoration: d.decoration ?? body.decoration
+	});
+	const styles = (runs.length ? runs : [{}]).map(resolve);
+	const values = {};
+	const mixed = [];
+	const read = (key, of) => {
+		const first = of(styles[0]);
+		values[key] = first;
+		if (styles.some((s) => JSON.stringify(of(s)) !== JSON.stringify(first))) mixed.push(key);
+	};
+	read("fontFamily", (s) => fontForFace({
+		family: s.family,
+		weight: body.weight,
+		italic: body.italic
+	}, fonts));
+	read("fontSize", (s) => s.size);
+	read("fontColor", (s) => s.color.toLowerCase());
+	read("bold", (s) => (s.weight ?? 400) >= 600);
+	read("italic", (s) => !!s.italic);
+	read("underline", (s) => (s.decoration ?? []).includes("underline"));
+	return {
+		values,
+		mixed
+	};
+}
+//#endregion
 //#region src/repository/kinds/freeText.ts
 /** Free-text `/DA` fields → content {@link TextStyle}. An absent `fontColor`
 *  falls back to the `/DA` colour — the same rule the CPVT renderer applies. */
 function textFromDTO(dto) {
+	const body = dto.richText?.body;
 	return {
 		fontFamily: dto.fontFamily,
 		fontSize: dto.fontSize,
 		fontColor: require_seam.colorToCss(dto.fontColor ?? dto.color),
-		textAlign: dto.textAlign
+		textAlign: dto.textAlign,
+		...body && body.weight >= 600 ? { bold: true } : {},
+		...body?.italic ? { italic: true } : {},
+		...body?.decoration.includes("underline") ? { underline: true } : {}
 	};
 }
 /**
+* A formatting toggle is a BODY change (runs are deltas over it), so it
+* lowers as a rich write carrying the current paragraphs — and every toggle
+* lowers the same COMPLETE body (the current one with the three toggles
+* applied: a partial body means engine defaults, which would reset the
+* size, face and colour), so a patch of several merges cleanly.
+*/
+const formattingBody = (a) => {
+	const doc = richDocOf(a);
+	const t = a.text;
+	return { richText: {
+		body: {
+			...doc.body,
+			weight: t?.bold ? 700 : 400,
+			italic: !!t?.italic,
+			decoration: t?.underline ? ["underline"] : []
+		},
+		paragraphs: doc.paragraphs
+	} };
+};
+/**
 * The engine geometry for a callout: the overall `/Rect` (text box ∪ leader ∪
 * arrow), the `/RD` inset that recovers the text box from it, the `/CL` leader
 * (`[tip, knee, conn]` with the connection point derived), and the `/LE`
@@ -303,6 +719,11 @@ const freeText = {
 		if (cf) return { ...cf };
 		return boxEmit(a, crop);
 	},
+	prop: {
+		bold: formattingBody,
+		italic: formattingBody,
+		underline: formattingBody
+	},
 	draftExtras: (a, crop) => ({
 		intent: calloutFields(a, crop) ? "free-text-callout" : "free-text",
 		contents: a.data?.contents ?? ""
@@ -650,6 +1071,14 @@ function toPatch(a, crop) {
 */
 function toScopedPatch(a, scope, crop) {
 	const kind = projectionOf(a.subtype);
+	if (scope.kind === "caption") return a.measure ? {
+		subtype: wireSubtypeOf(a),
+		caption: a.measure.caption
+	} : null;
+	if (scope.kind === "leader") return a.measure?.intent === "LineDimension" ? {
+		subtype: "line",
+		leader: a.measure.leader
+	} : null;
 	if (scope.kind === "geometry") {
 		const geo = kind.geometry(a, crop);
 		return geo ? {
@@ -732,18 +1161,6 @@ function createAnnotationHoverFeed(actions, annotOf) {
 * the plugin (not the portable core) because the font→CSS stack mapping and the
 * engine `Color`→CSS seam are web concerns, shared across every web framework.
 */
-/** Map a free-text `/DA` font to a CSS font-family. A standard PDF font → a web
-*  stack with the same metrics; anything else is a registered font key → mount it
-*  as a `@font-face` of that family (see the framework `mountWebFont` helper). */
-const STANDARD_FONT_CSS = {
-	helvetica: "Helvetica, Arial, sans-serif",
-	"helvetica-bold": "Helvetica, Arial, sans-serif",
-	courier: "\"Courier New\", Courier, monospace",
-	"times-roman": "\"Times New Roman\", Times, serif",
-	symbol: "serif",
-	"zapf-dingbats": "serif"
-};
-const cssFontFor = (font) => STANDARD_FONT_CSS[font] ?? `"${font}", sans-serif`;
 /** Project the model's free-text boxes into render-ready {@link TextItem}s — the
 *  core geometry (`textBoxes`) joined with the DTO-derived CSS. Pure; memoized by
 *  model identity at the call site so selectors get a stable reference. */
@@ -752,525 +1169,29 @@ function buildTextItems(m, pon, view) {
 		const a = m.byId[tb.id];
 		const t = a?.text ?? _embedpdf_core_annotation.initialTextStyle;
 		const sw = a?.style.strokeWidth ?? 0;
-		const isCallout = a?.geom.t === "text" && !!a.geom.callout;
+		const doc = a ? richDocOf(a) : null;
 		return {
 			id: tb.id,
 			ref: a?.ref ?? null,
 			box: tb.box,
 			contents: a?.data?.contents ?? "",
+			richText: { paragraphs: doc ? stripBodyDefaults(doc.paragraphs, doc.body) : [{ runs: [{ text: "" }] }] },
 			editing: tb.editing,
 			...tb.rot ? { rot: tb.rot } : {},
 			css: {
-				fontFamily: cssFontFor(t.fontFamily),
+				fontFamily: cssFontFamilyForFont(t.fontFamily),
 				fontSize: t.fontSize,
-				lineHeight: t.fontSize,
 				color: t.fontColor,
+				fontWeight: t.bold ? 700 : 400,
+				fontStyle: t.italic ? "italic" : "normal",
+				textDecoration: t.underline ? "underline" : "none",
 				align: t.textAlign,
-				padding: isCallout ? sw + 2 : sw,
-				background: a?.style.interiorColor ?? null
+				padding: (0, _embedpdf_core_annotation.textPlateInset)(sw)
 			}
 		};
 	});
 }
 //#endregion
-//#region src/tools.ts
-/**
-* The tool `armStamp` activates — and the only tool an armed payload survives
-* onto (plus the legacy `annotation-stamp` tag, honoured for embedder configs
-* written before the tags were unified). Placement consults the armed payload
-* BEFORE the active tool's own `source` spec, so a payload must not outlive
-* its tool onto a sibling stamp preset: an `image` preset's click has to open
-* its own picker, not silently place whatever the stamp panel last armed.
-*/
-const ARMED_STAMP_TOOL_ID = "stamp";
-/**
-* The creation properties each known authoring kind actually consumes. This is
-* deliberately separate from the flat internal patch vocabulary: it gives tool
-* configuration precise compile-time and runtime validation while mixed-selection
-* edits can keep using `AnnotationPropsPatch`.
-*/
-const TOOL_DEFAULT_KEYS = {
-	square: [
-		"color",
-		"interiorColor",
-		"opacity",
-		"strokeWidth",
-		"border"
-	],
-	circle: [
-		"color",
-		"interiorColor",
-		"opacity",
-		"strokeWidth",
-		"border"
-	],
-	line: [
-		"color",
-		"interiorColor",
-		"opacity",
-		"strokeWidth",
-		"border",
-		"lineEndings"
-	],
-	polygon: [
-		"color",
-		"interiorColor",
-		"opacity",
-		"strokeWidth",
-		"border"
-	],
-	polyline: [
-		"color",
-		"interiorColor",
-		"opacity",
-		"strokeWidth",
-		"border",
-		"lineEndings"
-	],
-	ink: [
-		"color",
-		"opacity",
-		"strokeWidth",
-		"blendMode"
-	],
-	"free-text": [
-		"fontFamily",
-		"fontSize",
-		"fontColor",
-		"textAlign",
-		"opacity",
-		"interiorColor",
-		"color",
-		"strokeWidth",
-		"border"
-	],
-	"free-text-callout": [
-		"fontFamily",
-		"fontSize",
-		"fontColor",
-		"textAlign",
-		"opacity",
-		"interiorColor",
-		"color",
-		"strokeWidth",
-		"border",
-		"lineEndings"
-	],
-	highlight: [
-		"color",
-		"opacity",
-		"blendMode"
-	],
-	underline: [
-		"color",
-		"opacity",
-		"blendMode"
-	],
-	strikeout: [
-		"color",
-		"opacity",
-		"blendMode"
-	],
-	squiggly: [
-		"color",
-		"opacity",
-		"blendMode"
-	],
-	caret: ["color", "opacity"],
-	redact: [
-		"color",
-		"interiorColor",
-		"opacity",
-		"fontFamily",
-		"fontSize",
-		"fontColor",
-		"textAlign"
-	],
-	stamp: [],
-	link: ["link"],
-	text: [
-		"icon",
-		"color",
-		"opacity"
-	],
-	"file-attachment": [
-		"icon",
-		"color",
-		"opacity"
-	],
-	"widget-text": [
-		"color",
-		"interiorColor",
-		"strokeWidth",
-		"border",
-		"fontFamily",
-		"fontSize",
-		"fontColor",
-		"textAlign"
-	],
-	"widget-choice": [
-		"color",
-		"interiorColor",
-		"strokeWidth",
-		"border",
-		"fontFamily",
-		"fontSize",
-		"fontColor",
-		"textAlign"
-	],
-	"widget-toggle": [
-		"color",
-		"interiorColor",
-		"strokeWidth",
-		"border"
-	]
-};
-const DRAW_TAGS = ["annotation-draw", "annotation-edit"];
-const MARKUP_TAGS = ["text-select", "annotation-edit"];
-/**
-* Whether arming this ANNOTATION tool is touch consent (`Tool.touchDirect`):
-* drag-CREATE tools — shape/ink draw and text-markup select — take
-* single-finger touch wholesale (finger draws/marks, two fingers navigate:
-* the drawing-app convention). Click-to-PLACE tools (stamp, note) do not: a
-* tap places without any claim, and drags keep scrolling. Derived from the
-* gesture tags, so custom registered tools inherit the right behavior. Only
-* annotation-owned tools run through this — the built-in `pointer` tool also
-* enables `text-select`, but it is registered by the hub, not here.
-*/
-const isTouchDirect = (enables) => enables.has("annotation-draw") || enables.has("text-select");
-/**
-* The built-in tools — a data mirror of v2's registrations (shapes + lines + ink
-* + free text in the draw channel, text markup + caret behind text selection, and
-* the click-to-place stamp). Order is display-neutral; the toolbar owns layout.
-*/
-const DEFAULT_TOOLS = [
-	{
-		id: "square",
-		subtype: "square",
-		cursor: "crosshair",
-		enables: DRAW_TAGS,
-		defaults: { strokeWidth: 6 },
-		clickCreate: {
-			width: 80,
-			height: 60
-		}
-	},
-	{
-		id: "circle",
-		subtype: "circle",
-		cursor: "crosshair",
-		enables: DRAW_TAGS,
-		defaults: { strokeWidth: 6 },
-		clickCreate: {
-			width: 80,
-			height: 60
-		}
-	},
-	{
-		id: "line",
-		subtype: "line",
-		cursor: "crosshair",
-		enables: DRAW_TAGS,
-		defaults: { strokeWidth: 6 },
-		clickCreate: { length: 80 }
-	},
-	{
-		id: "polygon",
-		subtype: "polygon",
-		cursor: "crosshair",
-		enables: DRAW_TAGS,
-		defaults: { strokeWidth: 6 }
-	},
-	{
-		id: "polyline",
-		subtype: "polyline",
-		cursor: "crosshair",
-		enables: DRAW_TAGS,
-		defaults: { strokeWidth: 6 }
-	},
-	{
-		id: "ink",
-		subtype: "ink",
-		cursor: "crosshair",
-		enables: DRAW_TAGS,
-		defaults: {
-			color: "#ef4444",
-			strokeWidth: 6,
-			blendMode: "normal"
-		},
-		ink: { groupStrokesMs: 800 }
-	},
-	{
-		id: "ink-highlight",
-		extends: "ink",
-		intent: "ink-highlight",
-		defaults: {
-			color: "#ffcd45",
-			strokeWidth: 14,
-			blendMode: "multiply"
-		},
-		ink: { straighten: {
-			deviationThreshold: .15,
-			axisSnapDegrees: 15
-		} }
-	},
-	{
-		id: "free-text",
-		subtype: "free-text",
-		cursor: "crosshair",
-		enables: DRAW_TAGS,
-		defaults: { fontColor: "#ef4444" },
-		upright: true,
-		clickCreate: {
-			width: 180,
-			height: 40,
-			anchor: "top-left"
-		}
-	},
-	{
-		id: "free-text-callout",
-		subtype: "free-text-callout",
-		propsKind: "free-text",
-		cursor: "crosshair",
-		enables: DRAW_TAGS,
-		defaults: {
-			strokeWidth: 6,
-			lineEndings: { end: "open-arrow" }
-		},
-		upright: true
-	},
-	{
-		id: "highlight",
-		subtype: "highlight",
-		cursor: "default",
-		enables: MARKUP_TAGS,
-		defaults: {
-			color: "#ffe16a",
-			blendMode: "multiply"
-		},
-		selection: { kind: "markup" }
-	},
-	{
-		id: "redact",
-		subtype: "redact",
-		cursor: "crosshair",
-		enables: [
-			"text-select",
-			"annotation-draw",
-			"annotation-edit"
-		],
-		defaults: {
-			color: "#e44234",
-			interiorColor: "#000000",
-			fontColor: "#ffffff",
-			opacity: 1
-		},
-		selection: { kind: "markup" }
-	},
-	{
-		id: "underline",
-		subtype: "underline",
-		cursor: "default",
-		enables: MARKUP_TAGS,
-		defaults: { color: "#ef4444" },
-		selection: { kind: "markup" }
-	},
-	{
-		id: "strikeout",
-		subtype: "strikeout",
-		cursor: "default",
-		enables: MARKUP_TAGS,
-		defaults: { color: "#ef4444" },
-		selection: { kind: "markup" }
-	},
-	{
-		id: "squiggly",
-		subtype: "squiggly",
-		cursor: "default",
-		enables: MARKUP_TAGS,
-		defaults: { color: "#ef4444" },
-		selection: { kind: "markup" }
-	},
-	{
-		id: "insert-text",
-		subtype: "caret",
-		propsKind: "caret",
-		preset: "caret",
-		cursor: "default",
-		enables: MARKUP_TAGS,
-		defaults: { color: "#ef4444" },
-		selection: {
-			kind: "text-edit",
-			operation: "insert"
-		}
-	},
-	{
-		id: "replace-text",
-		subtype: "strikeout",
-		propsKind: "strikeout",
-		cursor: "default",
-		enables: MARKUP_TAGS,
-		defaults: { color: "#ef4444" },
-		selection: {
-			kind: "text-edit",
-			operation: "replace"
-		}
-	},
-	{
-		id: ARMED_STAMP_TOOL_ID,
-		subtype: "stamp",
-		cursor: "copy",
-		enables: ["annotation-place", "annotation-edit"],
-		source: {
-			kind: "prompt",
-			accept: "image/png,image/jpeg,application/pdf"
-		},
-		upright: true,
-		ghost: { mode: "footprint" }
-	},
-	{
-		id: "link",
-		subtype: "link",
-		cursor: "crosshair",
-		enables: DRAW_TAGS
-	},
-	{
-		id: "note",
-		subtype: "text",
-		cursor: "crosshair",
-		enables: ["annotation-place", "annotation-edit"],
-		defaults: {
-			icon: "comment",
-			color: "#facc15"
-		},
-		flags: {
-			noZoom: true,
-			noRotate: true
-		},
-		upright: true,
-		ghost: { mode: "footprint" }
-	},
-	{
-		id: "attachment",
-		subtype: "file-attachment",
-		cursor: "copy",
-		enables: ["annotation-place", "annotation-edit"],
-		source: { kind: "prompt" },
-		defaults: {
-			icon: "paperclip",
-			color: "#facc15"
-		},
-		flags: {
-			noZoom: true,
-			noRotate: true
-		},
-		upright: true,
-		ghost: { mode: "footprint" }
-	}
-];
-/** Merge two default patches, `b` over `a`, with line endings merged per side. */
-function mergeDefaults(a, b) {
-	if (!a) return b;
-	if (!b) return a;
-	const merged = {
-		...a,
-		...b
-	};
-	if (a.lineEndings || b.lineEndings) merged.lineEndings = {
-		...a.lineEndings,
-		...b.lineEndings
-	};
-	return merged;
-}
-/** Overlay a same-id override onto a base definition (configure a built-in). */
-function mergeDef(base, over) {
-	return {
-		...base,
-		...over,
-		enables: over.enables ?? base.enables,
-		meta: base.meta || over.meta ? {
-			...base.meta,
-			...over.meta
-		} : void 0,
-		defaults: mergeDefaults(base.defaults, over.defaults),
-		flags: base.flags || over.flags ? {
-			...base.flags,
-			...over.flags
-		} : void 0,
-		ink: base.ink || over.ink ? {
-			...base.ink,
-			...over.ink
-		} : void 0
-	};
-}
-function validateDefaults(tool) {
-	if (!tool.defaults) return;
-	const allowed = TOOL_DEFAULT_KEYS[tool.subtype];
-	if (!allowed) return;
-	const keys = new Set(allowed);
-	for (const key of Object.keys(tool.defaults)) if (!keys.has(key)) throw new Error(`[annotation] tool '${tool.id}' does not support default '${key}' for '${tool.subtype}'`);
-}
-/**
-* Resolve {@link DEFAULT_TOOLS} + embedder overrides into the ready-to-use table.
-* A same-id override merges over the built-in; a new id adds a tool; `extends`
-* inherits from an already-defined tool. Keyed by id, so lookups are O(1).
-*/
-function buildToolRegistry(overrides = []) {
-	const defs = /* @__PURE__ */ new Map();
-	for (const d of DEFAULT_TOOLS) defs.set(d.id, d);
-	for (const o of overrides) {
-		const prev = defs.get(o.id);
-		defs.set(o.id, prev ? mergeDef(prev, o) : o);
-	}
-	const out = /* @__PURE__ */ new Map();
-	const resolving = /* @__PURE__ */ new Set();
-	const resolve = (id) => {
-		const cached = out.get(id);
-		if (cached) return cached;
-		const def = defs.get(id);
-		if (!def) throw new Error(`[annotation] tool '${id}' extends an unknown tool`);
-		let base;
-		if (def.extends && def.extends !== id && !resolving.has(def.extends)) {
-			resolving.add(id);
-			base = resolve(def.extends);
-			resolving.delete(id);
-		}
-		const subtype = def.subtype ?? base?.subtype ?? def.id;
-		const resolved = {
-			id: def.id,
-			subtype,
-			preset: def.preset ?? def.id,
-			propsKind: def.propsKind ?? base?.propsKind ?? subtype,
-			cursor: def.cursor ?? base?.cursor ?? "crosshair",
-			enables: new Set(def.enables ?? (base ? [...base.enables] : [])),
-			defaults: mergeDefaults(base?.defaults, def.defaults),
-			flags: base?.flags || def.flags ? {
-				...base?.flags,
-				...def.flags
-			} : void 0,
-			source: def.source ?? base?.source,
-			selection: def.selection ?? base?.selection,
-			intent: def.intent ?? base?.intent,
-			ink: base?.ink || def.ink ? {
-				...base?.ink,
-				...def.ink
-			} : void 0,
-			upright: def.upright ?? base?.upright ?? false,
-			clickCreate: def.clickCreate ?? base?.clickCreate ?? false,
-			ghost: def.ghost ?? base?.ghost ?? false,
-			meta: base?.meta || def.meta ? {
-				...base?.meta,
-				...def.meta
-			} : void 0
-		};
-		validateDefaults(resolved);
-		out.set(id, resolved);
-		return resolved;
-	};
-	for (const id of defs.keys()) resolve(id);
-	return out;
-}
-//#endregion
 //#region src/placement.ts
 /**
 * Per-kind CODE for the click-to-place ICON kinds (note / file attachment)
@@ -1337,14 +1258,23 @@ const TEXT_COMMIT_DEBOUNCE_MS = 250;
 */
 function createAnnotationCapability(ctx, config = {}) {
 	const behaviors = [];
-	/** Per-annotation debounce timer for the engine `contents` write while typing. */
+	/** Per-annotation debounce timer for the engine text write while typing. */
 	const textTimers = /* @__PURE__ */ new Map();
+	/** The registered fonts, for face ↔ key mapping (the local engine's list;
+	*  the cloud engine registers none). */
+	const fonts = () => ctx.engine?.fonts?.list() ?? [];
 	const configTools = config.tools ?? [];
-	const registry = buildToolRegistry(configTools);
+	const registry = require_tools.buildToolRegistry(configTools);
 	/** The installed file-picker port (a DOM file dialog, wired by the framework
 	*  adapter), or null — every click-then-pick tool resolves through this ONE
 	*  slot. See {@link FilePickerProvider}. */
 	let filePickerProvider = null;
+	const pageViewports = /* @__PURE__ */ new Map();
+	const captured = /* @__PURE__ */ new Set();
+	ctx.cleanup(() => {
+		captured.clear();
+		pageViewports.clear();
+	});
 	const model = () => ctx.getState().model;
 	const actionsForHover = ctx.tryGet(_embedpdf_plugin_actions_contract.ActionsToken);
 	const hoverFeed = actionsForHover ? createAnnotationHoverFeed(actionsForHover, (id) => model().byId[id] ?? null) : null;
@@ -1462,10 +1392,18 @@ function createAnnotationCapability(ctx, config = {}) {
 		};
 		return v;
 	};
+	/** The editor's text RANGE inside the annotation being edited, or null
+	*  (no editor selection, a bare caret, or a selection left behind by a
+	*  previous edit). The one condition that routes the range keys to runs. */
+	const activeTextRange = (m) => {
+		const ts = ctx.getState().textSelection;
+		return ts && m.editing === ts.id && ts.end > ts.start && m.byId[ts.id] ? ts : null;
+	};
 	let selPropsCache = null;
 	const memoSelectionProps = () => {
 		const m = model();
-		if (selPropsCache && selPropsCache.model === m) return selPropsCache.v;
+		const range = activeTextRange(m);
+		if (selPropsCache && selPropsCache.model === m && selPropsCache.range === range) return selPropsCache.v;
 		const members = m.selected.map((id) => m.byId[id]).filter((a) => !!a);
 		const specs = (0, _embedpdf_core_annotation.sharedProps)(members.map((a) => a.subtype));
 		const values = {};
@@ -1477,6 +1415,16 @@ function createAnnotationCapability(ctx, config = {}) {
 			const firstJson = JSON.stringify(first);
 			if (members.some((a) => JSON.stringify(valueOf(a, spec.key)) !== firstJson)) mixed.push(spec.key);
 		}
+		if (range && members.length === 1 && members[0].id === range.id) {
+			const rp = rangeProps(richDocOf(members[0], fonts), range, fonts);
+			for (const spec of specs) {
+				if (!RANGE_KEYS.includes(spec.key)) continue;
+				values[spec.key] = rp.values[spec.key];
+				const i = mixed.indexOf(spec.key);
+				if (i >= 0) mixed.splice(i, 1);
+				if (rp.mixed.includes(spec.key)) mixed.push(spec.key);
+			}
+		}
 		const v = {
 			specs,
 			values,
@@ -1484,6 +1432,7 @@ function createAnnotationCapability(ctx, config = {}) {
 		};
 		selPropsCache = {
 			model: m,
+			range,
 			v
 		};
 		return v;
@@ -1625,7 +1574,7 @@ function createAnnotationCapability(ctx, config = {}) {
 			...input.subject !== void 0 ? { subject: input.subject } : {}
 		};
 		ctx.dispatch({ type: "STAMP_ARM_CHANGED" });
-		ctx.tryGet(_embedpdf_plugin_interaction_contract.InteractionToken)?.activateTool(ARMED_STAMP_TOOL_ID);
+		ctx.tryGet(_embedpdf_plugin_interaction_contract.InteractionToken)?.activateTool(require_tools.ARMED_STAMP_TOOL_ID);
 	};
 	const disarmStamp = () => {
 		if (!armedStamp) return;
@@ -1922,8 +1871,8 @@ function createAnnotationCapability(ctx, config = {}) {
 	* changed the appearance (create / restyle / resize), `'baked'` when the AP is
 	* still authoritative (a move, which preserves it, or a remote edit).
 	* `bumpAp` marks the upsert as confirming an engine /AP re-bake with new
-	* content, so the annotation's `apVersion` — and with it the page's
-	* appearance epoch — advances and the shell fetches the fresh raster.
+	* content, advancing the annotation's `apVersion`. Only baked annotations
+	* contribute to the page's appearance epoch and trigger a raster fetch.
 	*/
 	const syncDTO = (dto, source, bumpAp = false) => {
 		const crop = cropOf(dto.pageObjectNumber);
@@ -1941,7 +1890,35 @@ function createAnnotationCapability(ctx, config = {}) {
 		const pon = ponForRef(ref);
 		if (pon == null) throw new Error("[annotation] cannot resolve page for ref");
 		const res = await doc.page(pon).annotations.update(ref, patch);
-		syncDTO(res.updated, "vector");
+		syncDTO(res.updated, "vector", res.appearance?.changed);
+	};
+	const commitText = (ref) => {
+		const key = require_seam.refKey(ref);
+		clearTimeout(textTimers.get(key));
+		textTimers.delete(key);
+		const a = model().byId[key];
+		const pon = ponForRef(ref);
+		if (!a || pon == null) return;
+		const patch = textCommitPatch(a, richDocOf(a, fonts).paragraphs, fonts);
+		ctx.doc?.page(pon).annotations.update(ref, {
+			subtype: "free-text",
+			...patch
+		}).then(() => {}, () => {});
+	};
+	const scheduleTextCommit = (ref) => {
+		const key = require_seam.refKey(ref);
+		clearTimeout(textTimers.get(key));
+		textTimers.set(key, setTimeout(() => commitText(ref), TEXT_COMMIT_DEBOUNCE_MS));
+	};
+	const flushTextCommits = () => {
+		for (const key of [...textTimers.keys()]) {
+			const a = model().byId[key];
+			if (a?.ref) commitText(a.ref);
+			else {
+				clearTimeout(textTimers.get(key));
+				textTimers.delete(key);
+			}
+		}
 	};
 	function apply(msg) {
 		const [next, effects] = (0, _embedpdf_core_annotation.update)(model(), msg);
@@ -2214,7 +2191,9 @@ function createAnnotationCapability(ctx, config = {}) {
 			})).ref;
 		},
 		edit: async (ref, text) => {
-			const subtype = model().byId[require_seam.refKey(ref)]?.data?.subtype;
+			const data = model().byId[require_seam.refKey(ref)]?.data;
+			if (data && (0, _embedpdf_engine_core_runtime.isDimension)(data)) throw new Error("[annotation] measurement contents are derived");
+			const subtype = data?.subtype;
 			if (!subtype) throw new Error("[annotation] cannot edit an uncommitted annotation");
 			await updateOne(ref, {
 				subtype,
@@ -2284,7 +2263,7 @@ function createAnnotationCapability(ctx, config = {}) {
 				canSetStatus: allowsCreate(),
 				canEditText: (() => {
 					const a = model().byId[require_seam.refKey(ref)];
-					return !!a && (0, _embedpdf_core_annotation.annotContentsEditable)(a);
+					return !!a && !(a.data && (0, _embedpdf_engine_core_runtime.isDimension)(a.data)) && (0, _embedpdf_core_annotation.annotContentsEditable)(a);
 				})(),
 				canDelete: deletableOne(ref),
 				canDeleteThread: t !== null && threadMemberRefs(t).every(deletableOne)
@@ -2395,7 +2374,21 @@ function createAnnotationCapability(ctx, config = {}) {
 	function perform(fx, m) {
 		const doc = ctx.doc;
 		if (!doc) return;
-		if (fx.fx === "createGroup") {
+		if (fx.fx === "captured") {
+			const crop = cropOf(fx.pon);
+			if (crop && fx.geom.t === "line") {
+				const pdf = (p) => ({
+					x: p.x + crop.left,
+					y: crop.top - p.y
+				});
+				for (const cb of captured) cb({
+					tool: fx.tool,
+					pon: fx.pon,
+					from: pdf(fx.geom.a),
+					to: pdf(fx.geom.b)
+				});
+			}
+		} else if (fx.fx === "createGroup") {
 			const ids = [fx.primary, ...fx.members];
 			const annots = ids.map((id) => m.byId[id]);
 			const primary = annots[0];
@@ -2559,7 +2552,92 @@ function createAnnotationCapability(ctx, config = {}) {
 		if (patch.flags) out.flags = patch.flags;
 		return out;
 	};
+	const updateSelection = (patch) => {
+		const m = model();
+		const range = activeTextRange(m);
+		if (range) {
+			const a = m.byId[range.id];
+			const { delta, rest } = runDeltaForProps(patch, fonts);
+			if (Object.keys(delta).length) {
+				const next = (0, _embedpdf_core_annotation.applyStyleToRange)({ paragraphs: richDocOf(a, fonts).paragraphs }, range, delta);
+				apply({
+					t: "setRichText",
+					id: range.id,
+					doc: next
+				});
+				if (a.ref) scheduleTextCommit(a.ref);
+			}
+			if (Object.keys(rest).length) {
+				flushTextCommits();
+				apply({
+					t: "setProps",
+					patch: rest
+				});
+			}
+			return;
+		}
+		if (m.editing) flushTextCommits();
+		apply({
+			t: "setProps",
+			patch
+		});
+	};
 	return {
+		setPageViewports: (pon, viewports, fallback) => {
+			pageViewports.set(pon, {
+				viewports,
+				fallback
+			});
+		},
+		onDraftCaptured: (cb) => {
+			captured.add(cb);
+			return () => {
+				captured.delete(cb);
+			};
+		},
+		remeasurePage: async (pon, scale) => {
+			await rehydrate();
+			const report = {
+				pon,
+				scale,
+				updated: [],
+				skipped: [],
+				failed: []
+			};
+			const hydration = ctx.getState().hydration;
+			if (hydration.status !== "complete") {
+				report.error = (0, _embedpdf_engine_core_runtime.serializeError)(hydration.status === "error" ? hydration.error : /* @__PURE__ */ new Error("Annotation hydration is incomplete"));
+				return report;
+			}
+			const candidates = Object.values(model().byId).filter((a) => a.pon === pon && a.data && (0, _embedpdf_engine_core_runtime.isDimension)(a.data));
+			for (const a of candidates) {
+				const dto = a.data, ref = dto.ref;
+				const reason = a.authority?.update === false ? "no-authority" : !(0, _embedpdf_core_annotation.annotTransformable)(a) || !(0, _embedpdf_core_annotation.annotContentsEditable)(a) ? "locked" : "measure" in dto && dto.measure && dto.measure.subtype !== "RL" ? "foreign-measure" : !(0, _embedpdf_engine_core_runtime.isReadout)((0, _embedpdf_engine_core_runtime.measurementReadout)({
+					...dto,
+					measure: scale
+				})) ? "unavailable" : null;
+				if (reason) {
+					report.skipped.push({
+						ref,
+						reason
+					});
+					continue;
+				}
+				try {
+					await updateOne(ref, {
+						subtype: dto.subtype,
+						measure: scale
+					});
+					report.updated.push(ref);
+				} catch (error) {
+					report.failed.push({
+						ref,
+						error: (0, _embedpdf_engine_core_runtime.serializeError)(error)
+					});
+				}
+			}
+			return report;
+		},
 		create: async (pon, draft) => {
 			const doc = ctx.doc;
 			if (!doc) throw new Error("[annotation] no document bound");
@@ -2617,14 +2695,14 @@ function createAnnotationCapability(ctx, config = {}) {
 		tool: (id) => registry.get(id) ?? null,
 		toolSubtype: (id) => registry.get(id)?.subtype ?? id,
 		registerTool: (def) => {
-			const resolved = buildToolRegistry([...configTools, def]).get(def.id);
+			const resolved = require_tools.buildToolRegistry([...configTools, def]).get(def.id);
 			if (!resolved) throw new Error(`[annotation] could not resolve tool '${def.id}'`);
 			registry.set(resolved.id, resolved);
 			const un = ctx.tryGet(_embedpdf_plugin_interaction_contract.InteractionToken)?.registerTool({
 				id: resolved.id,
 				cursor: resolved.cursor,
 				enables: resolved.enables,
-				touchDirect: isTouchDirect(resolved.enables)
+				touchDirect: require_tools.isTouchDirect(resolved.enables)
 			});
 			if (resolved.defaults) apply({
 				t: "setDefaults",
@@ -2637,10 +2715,11 @@ function createAnnotationCapability(ctx, config = {}) {
 			};
 		},
 		update: (ref, patch) => updateOne(ref, patch),
-		updateSelection: (patch) => apply({
-			t: "setProps",
-			patch
-		}),
+		updateSelection,
+		toggleTextFormat: (format) => {
+			const current = memoSelectionProps().values[format];
+			updateSelection({ [format]: !current });
+		},
 		updateSelectionFlags: (patch) => apply({
 			t: "setFlags",
 			patch
@@ -2696,6 +2775,10 @@ function createAnnotationCapability(ctx, config = {}) {
 		chrome: (pon, scale, rotation, zoom) => memoChrome(pon, scale, rotation, zoom),
 		selectionAnchor: (scale, rotation, zoom) => memoAnchor(scale, rotation, zoom),
 		creationDraftAnchor: () => memoDraftAnchor(),
+		distanceCreationPage: () => {
+			const draft = model().draft;
+			return draft?.g === "create-distance" && draft.step === "offset" ? draft.pon : null;
+		},
 		selection: () => model().selected,
 		hitKind: (pon, point, scale, rotation, zoom, touch) => (0, _embedpdf_core_annotation.hitTest)(model(), pon, point, chromeGeomAt(scale, grabBoost(touch)), model().hitMargin, pageBoxOf(pon), inertIdsAt(pon), viewEnv(zoom, rotation)).t,
 		claimsTouchAt: (pon, point, scale, rotation, zoom) => {
@@ -2775,14 +2858,63 @@ function createAnnotationCapability(ctx, config = {}) {
 			}
 		}),
 		createPointer: (tool, phase, pon, point, finish = false, displayRotation) => {
-			if (!allowsCreate()) return;
 			const t = registry.get(tool);
+			if (t?.meta?.capture === true ? !ctx.doc?.security.allows("doc.annotate.modify") : !allowsCreate()) return;
+			const crop = cropOf(pon);
+			const cache = pageViewports.get(pon);
+			const draft = model().draft;
+			const continuingMeasurement = (draft?.g === "create-distance" || draft?.g === "create-poly") && draft.pon === pon && draft.preset === (t?.preset ?? tool);
+			const dimension = t && (0, _embedpdf_engine_core_runtime.isDimension)(t);
+			if (dimension && phase === "down" && !continuingMeasurement && (!crop || !cache?.viewports)) return;
+			const viewport = crop && cache?.viewports ? (0, _embedpdf_engine_core_runtime.viewportForPoint)(cache.viewports, {
+				x: point.x + crop.left,
+				y: crop.top - point.y
+			}) : void 0;
+			const measure = dimension && crop && cache ? {
+				intent: t.intent,
+				measure: viewport ? viewport.measure ?? null : cache.fallback,
+				caption: t.measurement?.caption ?? { enabled: true },
+				...t.intent === "LineDimension" ? { leader: t.measurement?.leader } : {},
+				crop,
+				text: ""
+			} : void 0;
+			if (measure && phase === "down" && !continuingMeasurement && !(0, _embedpdf_engine_core_runtime.isReadout)((0, _embedpdf_engine_core_runtime.measurementReadout)({
+				subtype: t.subtype,
+				intent: measure.intent,
+				measure: measure.measure,
+				linePoints: {
+					start: {
+						x: 0,
+						y: 0
+					},
+					end: {
+						x: 1,
+						y: 0
+					}
+				},
+				vertices: [
+					{
+						x: 0,
+						y: 0
+					},
+					{
+						x: 1,
+						y: 0
+					},
+					{
+						x: 1,
+						y: 1
+					}
+				]
+			}))) return;
 			apply({
 				t: "createPointer",
+				measure,
+				capture: t?.meta?.capture === true ? tool : void 0,
 				phase,
 				subtype: t?.subtype ?? tool,
 				preset: t?.preset ?? tool,
-				intent: t?.intent,
+				intent: t?.intent === "ink-highlight" ? t.intent : void 0,
 				clickCreate: t?.clickCreate,
 				flags: t?.flags,
 				deferInkCommit: (t?.ink?.groupStrokesMs ?? 0) > 0,
@@ -2798,6 +2930,7 @@ function createAnnotationCapability(ctx, config = {}) {
 				}
 			});
 		},
+		hasCreationDraft: () => model().draft?.g.startsWith("create-") ?? false,
 		finishCreationDraft: () => apply({ t: "finishCreationDraft" }),
 		finishInkDraft: () => apply({ t: "finishInkDraft" }),
 		cancelCreationDraft: () => apply({ t: "cancel" }),
@@ -2979,30 +3112,37 @@ function createAnnotationCapability(ctx, config = {}) {
 				id: require_seam.refKey(ref),
 				text
 			});
-			const key = require_seam.refKey(ref);
-			clearTimeout(textTimers.get(key));
-			textTimers.set(key, setTimeout(() => {
-				textTimers.delete(key);
-				const pon = ponForRef(ref);
-				if (pon != null) ctx.doc?.page(pon).annotations.update(ref, {
-					subtype: "free-text",
-					contents: text
-				}).then(() => {}, () => {});
-			}, TEXT_COMMIT_DEBOUNCE_MS));
+			scheduleTextCommit(ref);
+		},
+		setRichText: (ref, doc) => {
+			apply({
+				t: "setRichText",
+				id: require_seam.refKey(ref),
+				doc: { paragraphs: doc.paragraphs }
+			});
+			scheduleTextCommit(ref);
 		},
+		setTextSelection: (ref, range) => {
+			const id = require_seam.refKey(ref);
+			const prev = ctx.getState().textSelection;
+			const next = range ? {
+				id,
+				start: range.start,
+				end: range.end
+			} : null;
+			if (prev === null === (next === null) && (!prev || !next || prev.id === next.id && prev.start === next.start && prev.end === next.end)) return;
+			ctx.dispatch({
+				type: "SET_TEXT_SELECTION",
+				selection: next
+			});
+		},
+		cssFontFamily: (family) => cssFontFamilyForFace(family, fonts),
 		endTextEdit: () => {
-			for (const t of textTimers.values()) clearTimeout(t);
-			const id = model().editing;
-			const a = id ? model().byId[id] : null;
-			if (a?.ref) {
-				const pon = ponForRef(a.ref);
-				const text = a.data?.contents ?? "";
-				if (pon != null) ctx.doc?.page(pon).annotations.update(a.ref, {
-					subtype: "free-text",
-					contents: text
-				}).then(() => {}, () => {});
-			}
-			textTimers.clear();
+			flushTextCommits();
+			if (ctx.getState().textSelection) ctx.dispatch({
+				type: "SET_TEXT_SELECTION",
+				selection: null
+			});
 			apply({ t: "endTextEdit" });
 		},
 		commitScriptEffects: async (entries) => {
@@ -3081,24 +3221,6 @@ function createAnnotationCapability(ctx, config = {}) {
 	};
 }
 //#endregion
-Object.defineProperty(exports, "ARMED_STAMP_TOOL_ID", {
-	enumerable: true,
-	get: function() {
-		return ARMED_STAMP_TOOL_ID;
-	}
-});
-Object.defineProperty(exports, "DEFAULT_TOOLS", {
-	enumerable: true,
-	get: function() {
-		return DEFAULT_TOOLS;
-	}
-});
-Object.defineProperty(exports, "buildToolRegistry", {
-	enumerable: true,
-	get: function() {
-		return buildToolRegistry;
-	}
-});
 Object.defineProperty(exports, "createAnnotationCapability", {
 	enumerable: true,
 	get: function() {
@@ -3111,12 +3233,6 @@ Object.defineProperty(exports, "fromDTO", {
 		return fromDTO;
 	}
 });
-Object.defineProperty(exports, "isTouchDirect", {
-	enumerable: true,
-	get: function() {
-		return isTouchDirect;
-	}
-});
 Object.defineProperty(exports, "toCreateDraft", {
 	enumerable: true,
 	get: function() {
@@ -3130,4 +3246,4 @@ Object.defineProperty(exports, "toPatch", {
 	}
 });
 
-//# sourceMappingURL=capability-R7dgogJs.cjs.map
+//# sourceMappingURL=capability-Bt320iJP.cjs.map