@embedpdf/engine-core 3.0.0-next.12 → 3.0.0-next.14

package/dist/{builders-8Hl1AYNU.cjs → viewport-BWeNHZmb.cjs}

@@ -1,5 +1,6 @@
-const require_fold = require("./fold-C7I5GpBz.cjs");
-const require_PageInsertBlankInput = require("./PageInsertBlankInput-CzShuSJI.cjs");
+const require_derive = require("./derive-BbsDk_Kz.cjs");
+const require_format = require("./format-D_epWlob.cjs");
+const require_resolver = require("./resolver-CYVNV4hn.cjs");
 //#region src/dto/PdfAction.ts
 /**
 * The one Table-240 decode, shared by the reader, the schema's producers,
@@ -29,7 +30,7 @@ function createPageImageHandle(result, blobSource) {
 	return {
 		...result,
 		async objectUrl(signal) {
-			if (typeof Blob === "undefined" || typeof URL === "undefined" || !URL.createObjectURL) throw new require_fold.EngineError(require_PageInsertBlankInput.EngineErrorCode.RuntimeUnavailable, "Object URLs are not available in this environment");
+			if (typeof Blob === "undefined" || typeof URL === "undefined" || !URL.createObjectURL) throw new require_derive.EngineError(require_format.EngineErrorCode.RuntimeUnavailable, "Object URLs are not available in this environment");
 			const blob = await blobSource.blob(signal);
 			const url = URL.createObjectURL(blob);
 			return {
@@ -43,6 +44,18 @@ function createPageImageHandle(result, blobSource) {
 //#region src/dto/PdfSaveMode.ts
 const DEFAULT_PDF_SAVE_MODE = "incremental";
 //#endregion
+//#region src/dto/RichText.ts
+/** The plain-text projection of a rich document: paragraphs joined by `\r`,
+*  runs concatenated — what the engine writes to `/Contents`. */
+function richTextPlainText(doc) {
+	return doc.paragraphs.map((p) => p.runs.map((r) => r.text).join("")).join("\r");
+}
+/** Plain text as rich paragraphs: one per line break, one run each, no
+*  overrides (the engine's own `/Contents` fallback shape). */
+function richTextParagraphsFromPlainText(text) {
+	return text.split(/\r\n|\r|\n/).map((line) => ({ runs: [{ text: line }] }));
+}
+//#endregion
 //#region src/identity/PageObjectNumber.ts
 /**
 * Type guard for the rare malformed-PDF case where a page is a direct
@@ -259,7 +272,7 @@ function parseJpeg(buffer) {
 async function normalizeAttachmentFileSource(file, key) {
 	const resolved = await resolveBinarySource(file.data);
 	const name = file.name ?? resolved.name;
-	if (!name) throw new require_fold.EngineError(require_PageInsertBlankInput.EngineErrorCode.InvalidArg, "attachment file requires a name — pass { data, name } or a File whose name is set");
+	if (!name) throw new require_derive.EngineError(require_format.EngineErrorCode.InvalidArg, "attachment file requires a name — pass { data, name } or a File whose name is set");
 	const mimeType = file.mimeType ?? resolved.mimeType;
 	return {
 		wireFile: {
@@ -297,7 +310,7 @@ async function normalizeFileAttachmentDraft(draft, allocateKey) {
 async function resolveStampSource(source) {
 	const resolved = await resolveBinarySource(source);
 	const meta = sniffBinaryMetadata(resolved.bytes);
-	if (!meta) throw new require_fold.EngineError(require_PageInsertBlankInput.EngineErrorCode.InvalidArg, "stamp source must be PNG, JPEG, or single-page PDF bytes (format is detected from the data, not the declared mime type)");
+	if (!meta) throw new require_derive.EngineError(require_format.EngineErrorCode.InvalidArg, "stamp source must be PNG, JPEG, or single-page PDF bytes (format is detected from the data, not the declared mime type)");
 	return {
 		...resolved,
 		mimeType: meta.mimeType
@@ -360,85 +373,6 @@ async function normalizeAnnotationPatch(patch) {
 	}
 }
 //#endregion
-//#region src/annotation/relationships.ts
-/**
-* Classify one annotation by its relationship edge alone. Mirrors the
-* spec's "practical parser rule": no `/IRT` is top-level; `/RT /Group` is
-* a grouped subordinate; anything else with an `/IRT` is a reply (the
-* engine has already normalized a missing `/RT` to `'reply'`).
-*/
-function classifyRelation(a) {
-	if (!a.inReplyTo) return "top-level";
-	return a.replyType === "group" ? "grouped-subordinate" : "reply";
-}
-/**
-* Stable string key for an {@link AnnotationRef}, used to match a child's
-* `inReplyTo` against a candidate parent's `ref`. Both sides are produced
-* by the engine with the same identity precedence (objectNumber, then nm,
-* then index), so equal keys mean "same annotation".
-*/
-function refKey(ref) {
-	switch (ref.kind) {
-		case "objectNumber": return `obj:${ref.pageObjectNumber}:${ref.annotObjectNumber}`;
-		case "nm": return `nm:${ref.pageObjectNumber}:${ref.nm}`;
-		case "index": return `idx:${ref.pageObjectNumber}:${ref.index}`;
-	}
-}
-/**
-* Compose a flat annotation list (one page, or a whole document via
-* `listRawAll()` flattened) into {@link AnnotationThread}s in primary
-* order.
-*
-* Rules (ISO 32000 §12.5.6.2 + the spec's UI rule):
-*   - Annotations with no `/IRT` become thread primaries, in input order.
-*   - A `/RT /Group` child is attached to its primary's `groupedParts`.
-*   - A `/RT /R` (or default) child is attached to its primary's `replies`.
-*   - A child whose parent is not in the input set is treated as an
-*     orphan primary (defensive — e.g. a partial/filtered page slice).
-*
-* Limitations (v1, matches the legacy stack): threading is one level deep
-* — a reply-to-a-reply is keyed to its direct parent, so it only appears
-* nested if that direct parent is itself a primary. Callers that want a
-* sidebar of "most annotations, not widgets/popups" should pre-filter the
-* input; this helper is intentionally unopinionated about eligibility.
-*/
-function buildThreads(annotations) {
-	const byKey = /* @__PURE__ */ new Map();
-	for (const a of annotations) {
-		byKey.set(refKey(a.ref), a);
-		if (a.nm && a.nm.length > 0) byKey.set(`nm:${a.ref.pageObjectNumber}:${a.nm}`, a);
-	}
-	const threads = [];
-	const threadByPrimaryKey = /* @__PURE__ */ new Map();
-	const primaryThread = (primary) => {
-		const key = refKey(primary.ref);
-		let thread = threadByPrimaryKey.get(key);
-		if (!thread) {
-			thread = {
-				primary,
-				groupedParts: [],
-				replies: []
-			};
-			threadByPrimaryKey.set(key, thread);
-			threads.push(thread);
-		}
-		return thread;
-	};
-	for (const a of annotations) if (!a.inReplyTo) primaryThread(a);
-	for (const a of annotations) {
-		if (!a.inReplyTo) continue;
-		const parent = byKey.get(refKey(a.inReplyTo));
-		if (!parent || parent.inReplyTo) {
-			primaryThread(a);
-			continue;
-		}
-		const thread = primaryThread(parent);
-		if (a.replyType === "group") thread.groupedParts.push(a);
-		else thread.replies.push(a);
-	}
-	return threads;
-}
-//#endregion
 //#region src/annotation/comments.ts
 /** Subtypes that never participate in comment threads. `unsupported`
 *  covers `/Popup` dictionaries (raw code 16) and unreadable foreign
@@ -469,10 +403,10 @@ function buildCommentThreads(annotations, opts = {}) {
 	const eligible = annotations.filter((a) => !EXCLUDED_SUBTYPES.has(a.subtype));
 	const byKey = /* @__PURE__ */ new Map();
 	for (const a of eligible) {
-		const key = refKey(a.ref);
+		const key = require_derive.refKey(a.ref);
 		if (!byKey.has(key)) byKey.set(key, a);
 		if (a.nm) {
-			const aliasKey = refKey({
+			const aliasKey = require_derive.refKey({
 				kind: "nm",
 				pageObjectNumber: a.pageObjectNumber,
 				nm: a.nm
@@ -483,9 +417,9 @@ function buildCommentThreads(annotations, opts = {}) {
 	const children = /* @__PURE__ */ new Map();
 	for (const a of eligible) {
 		if (!a.inReplyTo) continue;
-		const parent = byKey.get(refKey(a.inReplyTo));
+		const parent = byKey.get(require_derive.refKey(a.inReplyTo));
 		if (!parent) continue;
-		const parentKey = refKey(parent.ref);
+		const parentKey = require_derive.refKey(parent.ref);
 		const list = children.get(parentKey);
 		if (list) list.push(a);
 		else children.set(parentKey, [a]);
@@ -496,15 +430,15 @@ function buildCommentThreads(annotations, opts = {}) {
 		const replies = [];
 		const groupedParts = [];
 		const states = [];
-		visited.add(refKey(root.ref));
-		const stack = [...children.get(refKey(root.ref)) ?? []];
+		visited.add(require_derive.refKey(root.ref));
+		const stack = [...children.get(require_derive.refKey(root.ref)) ?? []];
 		while (stack.length > 0) {
 			const a = stack.pop();
-			const key = refKey(a.ref);
+			const key = require_derive.refKey(a.ref);
 			if (visited.has(key)) continue;
 			visited.add(key);
 			if (isStateAnnotation(a)) states.push(a);
-			else if (classifyRelation(a) === "grouped-subordinate") groupedParts.push(a);
+			else if (require_derive.classifyRelation(a) === "grouped-subordinate") groupedParts.push(a);
 			else replies.push(a);
 			stack.push(...children.get(key) ?? []);
 		}
@@ -520,7 +454,7 @@ function buildCommentThreads(annotations, opts = {}) {
 	};
 	for (const a of eligible) if (!a.inReplyTo && !isStateAnnotation(a)) walk(a);
 	for (const a of eligible) {
-		if (visited.has(refKey(a.ref))) continue;
+		if (visited.has(require_derive.refKey(a.ref))) continue;
 		if (isStateAnnotation(a)) continue;
 		walk(a);
 	}
@@ -790,15 +724,22 @@ function appearanceImpactOf(current, patch) {
 	const cur = current;
 	const pat = patch;
 	const subtype = patch.subtype;
+	const caption = pat.caption === void 0 ? cur.caption : pat.caption;
+	const contentsPainted = CONTENTS_PAINTED.has(subtype) || [
+		"line",
+		"polygon",
+		"polyline"
+	].includes(subtype) && !!caption?.enabled;
 	const touched = [];
 	for (const [key, value] of Object.entries(pat)) {
 		if (value === void 0 || INERT_KEYS.has(key)) continue;
-		if (key === "contents" && !CONTENTS_PAINTED.has(subtype)) continue;
+		if (key === "contents" && !contentsPainted) continue;
 		if (key === "rotation" && ADVISORY_ROTATION.has(subtype)) continue;
 		if (!semanticEqual(value, cur[key])) touched.push(key);
 	}
 	if (touched.length === 0) return "inert";
-	const geometryKeys = TRANSLATABLE_GEOMETRY[subtype];
+	const baseGeometryKeys = TRANSLATABLE_GEOMETRY[subtype];
+	const geometryKeys = baseGeometryKeys && (subtype === "polygon" || subtype === "polyline") && cur.caption?.center ? [...baseGeometryKeys, "caption"] : baseGeometryKeys;
 	if (!geometryKeys) return "regenerate";
 	if (!touched.every((k) => geometryKeys.includes(k))) return "regenerate";
 	return isRigidTranslation(cur, pat, subtype, geometryKeys) ? "translation" : "regenerate";
@@ -855,6 +796,1336 @@ function decodeFieldRefKey(key) {
 	return null;
 }
 //#endregion
+//#region src/signature/analysis/pdf-value.ts
+/**
+* Parse the fork's canonical shallow serialisation:
+*   dict     <</Key value/Key2 value>>        (keys sorted, `#xx`-escaped)
+*   array    [item item]
+*   ref      n 0 R
+*   stream   stream(length,sha256hex)<<dict>>
+*   name     /Name (with #xx escapes)
+*   string   (literal with backslash escapes) or <hex>
+*   number   -12.5   bool  true|false   null
+*/
+function parsePdfValue(text) {
+	const parser = new Parser(text);
+	const value = parser.value();
+	parser.skipSpaces();
+	if (!parser.atEnd()) throw new Error(`trailing input at ${parser.pos}: ${text.slice(parser.pos, parser.pos + 20)}`);
+	return value;
+}
+var Parser = class {
+	constructor(text) {
+		this.text = text;
+		require_derive._defineProperty(this, "pos", 0);
+	}
+	atEnd() {
+		return this.pos >= this.text.length;
+	}
+	skipSpaces() {
+		while (this.pos < this.text.length && this.text[this.pos] === " ") this.pos++;
+	}
+	value() {
+		this.skipSpaces();
+		const t = this.text;
+		if (t.startsWith("<<", this.pos)) return this.dict();
+		if (t.startsWith("stream(", this.pos)) return this.stream();
+		if (t[this.pos] === "[") return this.array();
+		if (t[this.pos] === "/") return {
+			t: "name",
+			v: this.name()
+		};
+		if (t[this.pos] === "(") return {
+			t: "string",
+			v: this.literalString()
+		};
+		if (t[this.pos] === "<") return {
+			t: "string",
+			v: this.hexString()
+		};
+		if (t.startsWith("true", this.pos)) {
+			this.pos += 4;
+			return {
+				t: "bool",
+				v: true
+			};
+		}
+		if (t.startsWith("false", this.pos)) {
+			this.pos += 5;
+			return {
+				t: "bool",
+				v: false
+			};
+		}
+		if (t.startsWith("null", this.pos)) {
+			this.pos += 4;
+			return { t: "null" };
+		}
+		const ref = /^(\d+) 0 R(?![0-9A-Za-z])/.exec(t.slice(this.pos));
+		if (ref) {
+			this.pos += ref[0].length;
+			return {
+				t: "ref",
+				num: Number(ref[1])
+			};
+		}
+		const num = /^[+-]?(?:\d+\.?\d*|\.\d+)/.exec(t.slice(this.pos));
+		if (num) {
+			this.pos += num[0].length;
+			return {
+				t: "number",
+				v: Number(num[0])
+			};
+		}
+		throw new Error(`unexpected input at ${this.pos}: ${t.slice(this.pos, this.pos + 20)}`);
+	}
+	dict() {
+		return {
+			t: "dict",
+			entries: this.dictEntries()
+		};
+	}
+	dictEntries() {
+		this.expect("<<");
+		const entries = {};
+		for (;;) {
+			this.skipSpaces();
+			if (this.text.startsWith(">>", this.pos)) {
+				this.pos += 2;
+				return entries;
+			}
+			if (this.text[this.pos] !== "/") throw new Error(`expected a key at ${this.pos}`);
+			const key = this.name();
+			this.skipSpaces();
+			entries[key] = this.value();
+		}
+	}
+	stream() {
+		const m = /^stream\((\d+),([0-9a-fA-F]*)\)/.exec(this.text.slice(this.pos));
+		if (!m) throw new Error(`malformed stream signature at ${this.pos}`);
+		this.pos += m[0].length;
+		const dict = this.dictEntries();
+		return {
+			t: "stream",
+			length: Number(m[1]),
+			sha256: m[2].toLowerCase(),
+			dict
+		};
+	}
+	array() {
+		this.expect("[");
+		const items = [];
+		for (;;) {
+			this.skipSpaces();
+			if (this.text[this.pos] === "]") {
+				this.pos++;
+				return {
+					t: "array",
+					items
+				};
+			}
+			items.push(this.value());
+		}
+	}
+	name() {
+		this.expect("/");
+		let out = "";
+		while (this.pos < this.text.length) {
+			const ch = this.text[this.pos];
+			if (ch === " " || ch === "/" || ch === "[" || ch === "]" || ch === "<" || ch === ">" || ch === "(" || ch === ")") break;
+			if (ch === "#" && /^[0-9A-Fa-f]{2}/.test(this.text.slice(this.pos + 1, this.pos + 3))) {
+				out += String.fromCharCode(parseInt(this.text.slice(this.pos + 1, this.pos + 3), 16));
+				this.pos += 3;
+				continue;
+			}
+			out += ch;
+			this.pos++;
+		}
+		return out;
+	}
+	literalString() {
+		this.expect("(");
+		let depth = 1;
+		let out = "";
+		while (this.pos < this.text.length) {
+			const ch = this.text[this.pos++];
+			if (ch === "\\") {
+				const next = this.text[this.pos++];
+				switch (next) {
+					case "n":
+						out += "\n";
+						break;
+					case "r":
+						out += "\r";
+						break;
+					case "t":
+						out += "	";
+						break;
+					case "b":
+						out += "\b";
+						break;
+					case "f":
+						out += "\f";
+						break;
+					case "\n": break;
+					case "\r":
+						if (this.text[this.pos] === "\n") this.pos++;
+						break;
+					default: {
+						const oct = /^[0-7]{1,3}/.exec(this.text.slice(this.pos - 1));
+						if (oct) {
+							out += String.fromCharCode(parseInt(oct[0], 8));
+							this.pos += oct[0].length - 1;
+						} else out += next;
+					}
+				}
+				continue;
+			}
+			if (ch === "(") depth++;
+			if (ch === ")") {
+				depth--;
+				if (depth === 0) return out;
+			}
+			out += ch;
+		}
+		throw new Error("unterminated string");
+	}
+	hexString() {
+		this.expect("<");
+		const end = this.text.indexOf(">", this.pos);
+		if (end < 0) throw new Error("unterminated hex string");
+		const hex = this.text.slice(this.pos, end).replace(/\s+/g, "");
+		this.pos = end + 1;
+		let out = "";
+		for (let i = 0; i < hex.length; i += 2) out += String.fromCharCode(parseInt(hex.slice(i, i + 2).padEnd(2, "0"), 16));
+		return out;
+	}
+	expect(token) {
+		if (!this.text.startsWith(token, this.pos)) throw new Error(`expected ${token} at ${this.pos}`);
+		this.pos += token.length;
+	}
+};
+/** Structural equality of two parsed values. */
+function pdfValueEquals(a, b) {
+	return stableStringify(a) === stableStringify(b);
+}
+function stableStringify(value) {
+	if (value === null) return "null";
+	switch (value.t) {
+		case "dict": return `<<${Object.keys(value.entries).sort().map((k) => `/${k} ${stableStringify(value.entries[k])}`).join("")}>>`;
+		case "stream": return `stream(${value.length},${value.sha256})${stableStringify({
+			t: "dict",
+			entries: value.dict
+		})}`;
+		case "array": return `[${value.items.map(stableStringify).join(" ")}]`;
+		case "ref": return `${value.num} 0 R`;
+		case "name": return `/${encodeName(value.v)}`;
+		case "string": return `(${value.v.replace(/[\\()]/g, (ch) => `\\${ch}`)})`;
+		case "number": return String(value.v);
+		case "bool": return value.v ? "true" : "false";
+		case "null": return "null";
+	}
+}
+function dictEntries(value) {
+	if (!value) return null;
+	if (value.t === "dict") return value.entries;
+	if (value.t === "stream") return value.dict;
+	return null;
+}
+/** Keys whose value differs (added, removed, or changed) between two dictionaries. */
+function changedKeys(a, b) {
+	const ea = dictEntries(a) ?? {};
+	const eb = dictEntries(b) ?? {};
+	const out = /* @__PURE__ */ new Set();
+	for (const key of /* @__PURE__ */ new Set([...Object.keys(ea), ...Object.keys(eb)])) if (!pdfValueEquals(ea[key] ?? null, eb[key] ?? null)) out.add(key);
+	return out;
+}
+function refsOf(value) {
+	if (!value) return [];
+	if (value.t === "ref") return [value.num];
+	if (value.t === "array") return value.items.flatMap(refsOf);
+	return [];
+}
+/** `#xx`-escape a name the way the PDF writer does: delimiters, whitespace, `#`, and non-printables. */
+function encodeName(name) {
+	let out = "";
+	for (const ch of name) {
+		const code = ch.charCodeAt(0);
+		if (code < 33 || code > 126 || "#/[]<>(){}%".includes(ch)) out += `#${code.toString(16).toUpperCase().padStart(2, "0")}`;
+		else out += ch;
+	}
+	return out;
+}
+//#endregion
+//#region src/signature/analysis/verdict.ts
+const RANK = {
+	unchanged: 0,
+	permitted: 1,
+	indeterminate: 2,
+	forbidden: 3
+};
+/** The worst of several verdicts (a certification replay's steps). */
+function worstVerdict(steps) {
+	let worst = "unchanged";
+	for (const s of steps) if (RANK[s.verdict] > RANK[worst]) worst = s.verdict;
+	return worst;
+}
+/**
+* One aggregation rule everywhere: a proven violation decides, whatever
+* else could not be established; missing evidence never becomes a pass.
+*/
+function conclude(findings, hasEffectiveChanges) {
+	if (findings.some((f) => f.verdict === "forbidden")) return "forbidden";
+	if (findings.some((f) => f.verdict === "incomplete")) return "indeterminate";
+	return hasEffectiveChanges ? "permitted" : "unchanged";
+}
+/** The finding that explains a verdict: the violation, else the gap, else the most notable allowance. */
+function primaryFinding(findings) {
+	return findings.find((f) => f.verdict === "forbidden") ?? findings.find((f) => f.verdict === "incomplete") ?? findings.find((f) => f.verdict === "permitted");
+}
+function assessmentOf(step) {
+	const primary = primaryFinding(step.findings);
+	return {
+		verdict: step.verdict,
+		complete: !step.findings.some((f) => f.verdict === "incomplete"),
+		...primary ? { primary } : {},
+		findings: step.findings
+	};
+}
+/**
+* A certification window: the net verdict and every replayed step, under
+* the same rule. A step's violation is a violation of the certification
+* even when the final state no longer shows it (corpus v3/83).
+*/
+function combine(net, steps) {
+	const findings = [...net.findings];
+	for (const s of steps) {
+		if (s === net) continue;
+		for (const f of s.findings) {
+			if (f.verdict === "permitted") continue;
+			findings.push({
+				...f,
+				detail: `revision ${s.newer}: ${f.detail ?? f.rule}`
+			});
+		}
+	}
+	const verdict = conclude(findings, net.verdict !== "unchanged" || steps.some((s) => s.verdict !== "unchanged"));
+	const primary = primaryFinding(findings);
+	return {
+		verdict,
+		complete: !findings.some((f) => f.verdict === "incomplete"),
+		...primary ? { primary } : {},
+		findings
+	};
+}
+//#endregion
+//#region src/signature/analysis/evaluate.ts
+const SIDES = ["old", "new"];
+const TRAILER_KEYS = /* @__PURE__ */ new Set([
+	"Size",
+	"Prev",
+	"XRefStm",
+	"Info",
+	"ID",
+	"Root",
+	"Type",
+	"W",
+	"Index",
+	"Filter",
+	"DecodeParms",
+	"Length",
+	"Encrypt"
+]);
+const CATALOG_KEYS = /* @__PURE__ */ new Set([
+	"Metadata",
+	"Extensions",
+	"Version",
+	"DSS",
+	"AcroForm",
+	"Perms"
+]);
+const ACROFORM_KEYS = /* @__PURE__ */ new Set([
+	"DR",
+	"DA",
+	"Q",
+	"SigFlags",
+	"NeedAppearances",
+	"Fields"
+]);
+/**
+* What a form field may change after a signature, by the level in force.
+* Every key here has a corpus case behind it (`signature-compat`); a key
+* not listed is forbidden until one does.
+*
+*   annotate (an approval signature: "Form Fill-in, Signing and Commenting
+*   are allowed"): everything but the field's identity and its place in
+*   the tree. v1/08 /V+/AP, 09 /Ff, 10 /Rect, 11 /F, 18 /TU, 21 /DA; 13 /T
+*   forbidden. /AA (v1/12) and /A are accepted by Acrobat and deliberately
+*   NOT listed: an action on a signed form is executable content.
+*
+*   fill (a P=2 certification): value and appearance. v1/26 /V+/AP, v3/64
+*   /Ff (ReadOnly added), 65 /DA, 68 /AP stream; v3/66 /TU, 67 /F, v2/50
+*   /Rect forbidden.
+*/
+const FIELD_KEYS_BY_LEVEL = {
+	annotate: /* @__PURE__ */ new Set([
+		"V",
+		"AS",
+		"AP",
+		"I",
+		"DA",
+		"Ff",
+		"RV",
+		"MK",
+		"Q",
+		"TU",
+		"F",
+		"Rect",
+		"BS",
+		"Opt",
+		"DV",
+		"MaxLen"
+	]),
+	fill: /* @__PURE__ */ new Set([
+		"V",
+		"AS",
+		"AP",
+		"I",
+		"RV",
+		"DA",
+		"Ff"
+	])
+};
+/** A separate widget dictionary: the presentation subset of the same tables. */
+const WIDGET_KEYS_BY_LEVEL = {
+	annotate: /* @__PURE__ */ new Set([
+		"AS",
+		"AP",
+		"DA",
+		"MK",
+		"Q",
+		"TU",
+		"F",
+		"Rect",
+		"BS"
+	]),
+	fill: /* @__PURE__ */ new Set([
+		"AS",
+		"AP",
+		"DA"
+	])
+};
+/**
+* Signing an EXISTING field: its value, appearance and ReadOnly at any
+* level; after an approval signature also its tooltip and a /Lock installed
+* with the signature (v1/18, 19: both valid; under P=2 the combination is
+* rejected, v3/69, so neither is allowed at `fill`).
+*/
+const SIGNED_FIELD_KEYS_BY_LEVEL = {
+	annotate: /* @__PURE__ */ new Set([
+		"V",
+		"AP",
+		"AS",
+		"Ff",
+		"TU",
+		"Lock"
+	]),
+	fill: /* @__PURE__ */ new Set([
+		"V",
+		"AP",
+		"AS",
+		"Ff"
+	])
+};
+const SIGNED_WIDGET_KEYS = /* @__PURE__ */ new Set(["AP", "AS"]);
+const FF_READ_ONLY = 1;
+function fieldKeysFor(level) {
+	return level === "annotate" ? FIELD_KEYS_BY_LEVEL.annotate : FIELD_KEYS_BY_LEVEL.fill;
+}
+function widgetKeysFor(level) {
+	return level === "annotate" ? WIDGET_KEYS_BY_LEVEL.annotate : WIDGET_KEYS_BY_LEVEL.fill;
+}
+function signedFieldKeysFor(level) {
+	return level === "annotate" ? SIGNED_FIELD_KEYS_BY_LEVEL.annotate : SIGNED_FIELD_KEYS_BY_LEVEL.fill;
+}
+/**
+* Rules whose permitted findings do not make a revision a CHANGE of the
+* document: an object written again with the sealed value, an object nobody
+* references, a cross-reference container, the trailer's own bookkeeping.
+* A window with nothing else is `unchanged` (Acrobat: "not modified").
+*/
+const NON_EFFECTIVE_RULES = /* @__PURE__ */ new Set([
+	"identical-rewrite",
+	"orphan",
+	"xref-container",
+	"trailer"
+]);
+/** The level a step runs at, and the locks it enforces: what the OLDER revision's signatures established. */
+function restrictionsOf(before) {
+	const protection = require_resolver.deriveProtection(before.signatures);
+	return {
+		level: protection.judged ?? "annotate",
+		locks: protection.fieldLocks
+	};
+}
+/**
+* Judge one pairwise step. Every reference to a changed object, in the
+* older AND the newer revision, must be claimed by a rule that inspected
+* that use; an unclaimed reference is `unexplained` and forbidden. A
+* truncated value is `incomplete`, never permitted. Pure: JSON in, JSON
+* out, the same code in the browser worker, on the server and in tests.
+*/
+function evaluateStep(input) {
+	const changes = withEvidenceCheck(input.changes);
+	const { level, locks } = input.restrictions ?? restrictionsOf(input.before);
+	const levelInForce = input.levelOverride ?? level;
+	const ctx = new StepContext({
+		...input,
+		changes
+	}, levelInForce, locks);
+	ruleRevisionHealth(ctx);
+	ruleXrefContainer(ctx);
+	ruleIdenticalRewrite(ctx);
+	ruleFieldLock(ctx);
+	ruleTrailer(ctx);
+	ruleInfo(ctx);
+	ruleMetadata(ctx);
+	ruleCatalog(ctx);
+	ruleAcroForm(ctx);
+	ruleDss(ctx);
+	ruleSignatureFieldAdded(ctx);
+	ruleSignatureAdded(ctx);
+	ruleFormFill(ctx);
+	ruleAnnotation(ctx);
+	ruleUnexplained(ctx);
+	const verdict = conclude(ctx.findings, ctx.findings.some((f) => f.verdict === "permitted" && !NON_EFFECTIVE_RULES.has(f.rule)));
+	return {
+		older: input.older,
+		newer: input.newer,
+		levelInForce,
+		locks,
+		verdict,
+		findings: ctx.findings,
+		changes
+	};
+}
+/**
+* The evaluator never trusts its transport to be honest about gaps: a side
+* that exists must carry a value, and an object whose value is missing is
+* judged as truncated, whatever the flag says. Cross-reference containers
+* are exempt (their members are judged on their own).
+*/
+function withEvidenceCheck(changes) {
+	return changes.map((c) => {
+		if (c.value.truncated || c.kind === "xref" || c.kind === "objstm") return c;
+		const missingOld = c.present.old && (c.value.old === null || c.read?.old === "failed");
+		const missingNew = c.present.new && (c.value.new === null || c.read?.new === "failed");
+		return missingOld || missingNew ? {
+			...c,
+			value: {
+				...c.value,
+				truncated: true
+			}
+		} : c;
+	});
+}
+/**
+* The transport's verdict on each revision as a whole. A sealed revision
+* Acrobat cannot judge later changes to (sparse cross-reference table, a
+* reachable bare-reference object) makes every step over it indeterminate:
+* our verdict would otherwise disagree with the validator recipients use,
+* and for a reason that has nothing to do with the change. An incomplete
+* reachability walk on either side leaves every use unproven.
+*/
+function ruleRevisionHealth(ctx) {
+	const health = ctx.input.health;
+	if (!health) return;
+	const base = health.old;
+	if (base.sparseXref || base.bareReferences > 0) {
+		const why = [base.sparseXref ? "its cross-reference table has no entry for some object numbers below /Size" : null, base.bareReferences > 0 ? `${base.bareReferences} reachable indirect object(s) consist of a bare reference` : null].filter((x) => x !== null).join("; ");
+		ctx.findings.push({
+			rule: "base-unverifiable",
+			verdict: "incomplete",
+			objectNumber: 0,
+			detail: `the signed revision cannot be verified against later changes by Acrobat (${why}); no verdict is given rather than one Acrobat would contradict`
+		});
+	}
+	for (const side of SIDES) if (!health[side].referrersComplete) ctx.findings.push({
+		rule: "unexplained",
+		verdict: "incomplete",
+		objectNumber: 0,
+		detail: `the ${side === "old" ? "older" : "newer"} revision's reachability walk hit its budget; not every use of a changed object is known`
+	});
+}
+/**
+* Same effective value on both sides: same canonical serialisation (keys
+* sorted, whitespace normalised - Acrobat compares dictionaries by value,
+* corpus v3/61-62), same stream data (by bytes, v2/45), and both sides
+* actually read. A failed read serialises as "null" and would match another
+* failed read - evidence of nothing.
+*/
+function sameEffectiveValue(c) {
+	return c.change === "modified" && !c.value.truncated && c.read?.old !== "failed" && c.read?.new !== "failed" && c.raw.old !== null && c.raw.new !== null && c.raw.old === c.raw.new && !c.streamDataChanged;
+}
+function indexRoles(s) {
+	const fieldByObj = /* @__PURE__ */ new Map();
+	const widgetToField = /* @__PURE__ */ new Map();
+	const sigFields = /* @__PURE__ */ new Set();
+	for (const f of s.fields) {
+		fieldByObj.set(f.objectNumber, f);
+		if (f.family === "signature") sigFields.add(f.objectNumber);
+		for (const w of f.widgets) widgetToField.set(w, f.objectNumber);
+	}
+	const signedFields = /* @__PURE__ */ new Set();
+	for (const sig of s.signatures) if (sig.signed && sig.field.kind === "objectNumber") signedFields.add(sig.field.fieldObjectNumber);
+	return {
+		fieldByObj,
+		widgetToField,
+		pages: new Set(s.pages),
+		signedFields,
+		sigFields
+	};
+}
+function edgeKey(e) {
+	return `${e.parent}:${e.label}`;
+}
+var StepContext = class {
+	constructor(input, level, locks) {
+		this.input = input;
+		this.level = level;
+		this.locks = locks;
+		require_derive._defineProperty(this, "findings", []);
+		require_derive._defineProperty(this, "byNum", /* @__PURE__ */ new Map());
+		require_derive._defineProperty(this, "before", void 0);
+		require_derive._defineProperty(this, "after", void 0);
+		require_derive._defineProperty(this, "claims", /* @__PURE__ */ new Map());
+		require_derive._defineProperty(this, "locked", /* @__PURE__ */ new Set());
+		for (const c of input.changes) this.byNum.set(c.objectNumber, c);
+		this.before = indexRoles(input.before);
+		this.after = indexRoles(input.after);
+	}
+	get changes() {
+		return this.input.changes;
+	}
+	allows(needed) {
+		return require_resolver.levelAllows(this.level, needed);
+	}
+	claimEdge(c, side, edge, rule, allow = true) {
+		if (this.locked.has(c.objectNumber)) return;
+		const key = `${c.objectNumber}:${side}:${edgeKey(edge)}`;
+		if (!this.claims.has(key)) this.claims.set(key, {
+			rule,
+			allow
+		});
+	}
+	claimAll(c, rule, allow = true) {
+		for (const side of SIDES) for (const e of c.usage[side]) this.claimEdge(c, side, e, rule, allow);
+	}
+	/**
+	* Claim the references that are the same in both revisions; a reference
+	* gained or lost stays unexplained. `allow: false` explains a condemned
+	* object's edges (one cause in the report, not a cascade) without letting
+	* anything hang off it.
+	*/
+	claimStable(c, rule, allow = true) {
+		const oldKeys = new Set(c.usage.old.map(edgeKey));
+		const newKeys = new Set(c.usage.new.map(edgeKey));
+		for (const e of c.usage.old) if (newKeys.has(edgeKey(e))) this.claimEdge(c, "old", e, rule, allow);
+		for (const e of c.usage.new) if (oldKeys.has(edgeKey(e))) this.claimEdge(c, "new", e, rule, allow);
+	}
+	isClaimed(c, side, edge) {
+		return this.claims.has(`${c.objectNumber}:${side}:${edgeKey(edge)}`);
+	}
+	/** The use was inspected by a rule that allowed it. */
+	isAllowed(c, side, edge) {
+		return this.claims.get(`${c.objectNumber}:${side}:${edgeKey(edge)}`)?.allow === true;
+	}
+	permitted(c, rule, detail) {
+		if (this.locked.has(c.objectNumber)) return;
+		this.findings.push({
+			rule,
+			verdict: "permitted",
+			objectNumber: c.objectNumber,
+			detail
+		});
+	}
+	/**
+	* A violation is only proven on evidence: a rule condemning an object
+	* whose value could not be read or inspected is reporting what it could
+	* not see, and that is `incomplete`, never `forbidden`.
+	*/
+	forbidden(c, rule, detail, edge) {
+		this.findings.push({
+			rule,
+			verdict: c.value.truncated ? "incomplete" : "forbidden",
+			objectNumber: c.objectNumber,
+			edge: edge ? edgeKey(edge) : void 0,
+			detail: c.value.truncated ? `${detail} (judged on missing evidence: not proven)` : detail
+		});
+	}
+	/**
+	* Claim every reference under a set of parents (an appearance subtree,
+	* the DSS): objects whose references come from `parents` through labels
+	* `accept`, then everything referenced from those objects, and so on.
+	* Runs per side, because a replaced appearance stream exists on one
+	* side only.
+	*/
+	claimSubtree(side, roots, accept, rule) {
+		const joined = /* @__PURE__ */ new Set();
+		let grew = true;
+		while (grew) {
+			grew = false;
+			for (const c of this.changes) {
+				if (roots.has(c.objectNumber) || joined.has(c.objectNumber)) continue;
+				if (this.locked.has(c.objectNumber)) continue;
+				const edges = c.usage[side];
+				if (edges.length === 0) continue;
+				const inside = edges.filter((e) => roots.has(e.parent) && accept(e.label) || joined.has(e.parent));
+				if (inside.length === 0) continue;
+				for (const e of inside) this.claimEdge(c, side, e, rule);
+				if (edges.every((e) => inside.includes(e) || this.isAllowed(c, side, e))) {
+					joined.add(c.objectNumber);
+					grew = true;
+				}
+			}
+		}
+	}
+	isIdentical(c) {
+		return sameEffectiveValue(c);
+	}
+	/** Signatures signed in the newer revision but not the older: this step's signing events. */
+	newlySigned() {
+		const out = [];
+		for (const sig of this.input.after.signatures) {
+			if (!sig.signed || sig.field.kind !== "objectNumber") continue;
+			if (this.before.signedFields.has(sig.field.fieldObjectNumber)) continue;
+			out.push({
+				fieldObjectNumber: sig.field.fieldObjectNumber,
+				sig
+			});
+		}
+		return out;
+	}
+};
+function ruleXrefContainer(ctx) {
+	for (const c of ctx.changes) if (c.kind === "xref" || c.kind === "objstm") {
+		ctx.claimAll(c, "xref-container");
+		ctx.permitted(c, "xref-container", "cross-reference container; members are judged on their own");
+	}
+}
+/**
+* An object written again with the value the sealed revision holds is not
+* a modification: Acrobat compares objects by value and reports such a
+* revision as "not modified" for every role tried - document information,
+* a custom catalog entry, a page, the signed signature's own widget, a text
+* field, an annotation, the encryption dictionary, reserialised with keys
+* reordered, under a certification, under a field lock (corpus v1/02-07,
+* 23, v2/47, v3/54-62, 70, 71, 77). Under P=1 nothing is established and
+* the rewrite stays forbidden. Claimed here so the object-kind rules skip
+* it; the verdict treats it as no effective change.
+*/
+function ruleIdenticalRewrite(ctx) {
+	for (const c of ctx.changes) {
+		if (!ctx.isIdentical(c)) continue;
+		if (ctx.allows("fill")) {
+			ctx.claimAll(c, "identical-rewrite");
+			ctx.permitted(c, "identical-rewrite", "written again with the sealed value");
+		} else {
+			ctx.claimAll(c, "identical-rewrite", false);
+			ctx.forbidden(c, "identical-rewrite", `written again with the sealed value under level '${ctx.level}' (not established for this level)`);
+		}
+	}
+}
+function ruleTrailer(ctx) {
+	const c = ctx.byNum.get(0);
+	if (!c) return;
+	const changed = changedKeys(c.value.old, c.value.new);
+	const bad = [...changed].filter((k) => !TRAILER_KEYS.has(k));
+	const oldRoot = dictEntries(c.value.old)?.Root;
+	const newRoot = dictEntries(c.value.new)?.Root;
+	if (bad.length > 0) {
+		ctx.forbidden(c, "trailer", `trailer keys changed: ${bad.join(", ")}`);
+		return;
+	}
+	if (changed.has("Root") && !pdfValueEquals(oldRoot ?? null, newRoot ?? null)) {
+		ctx.forbidden(c, "trailer", "the trailer points at a different catalog");
+		return;
+	}
+	if (changed.has("Encrypt") && !pdfValueEquals(dictEntries(c.value.old)?.Encrypt ?? null, dictEntries(c.value.new)?.Encrypt ?? null)) {
+		ctx.forbidden(c, "trailer", "the trailer points at a different encryption dictionary");
+		return;
+	}
+	ctx.claimAll(c, "trailer");
+	ctx.permitted(c, "trailer");
+}
+function onlyEdges(c, test) {
+	const all = [...c.usage.old, ...c.usage.new];
+	return all.length > 0 && all.every(test);
+}
+function ruleInfo(ctx) {
+	for (const c of ctx.changes) {
+		if (ctx.isIdentical(c)) continue;
+		if (c.objectNumber !== 0 && onlyEdges(c, (e) => e.parent === 0 && e.label === "Info")) {
+			ctx.claimAll(c, "info");
+			ctx.permitted(c, "info", "document information dictionary");
+		}
+	}
+}
+function ruleMetadata(ctx) {
+	const roots = /* @__PURE__ */ new Set([ctx.input.before.root, ctx.input.after.root]);
+	for (const c of ctx.changes) {
+		if (ctx.isIdentical(c)) continue;
+		if (onlyEdges(c, (e) => roots.has(e.parent) && e.label === "Metadata")) {
+			ctx.claimAll(c, "metadata");
+			ctx.permitted(c, "metadata", "XMP metadata stream");
+		}
+	}
+}
+function ruleCatalog(ctx) {
+	const root = ctx.input.after.root;
+	const c = ctx.byNum.get(root);
+	if (!c || ctx.isIdentical(c)) return;
+	const changed = changedKeys(c.value.old, c.value.new);
+	const bad = [...changed].filter((k) => !CATALOG_KEYS.has(k));
+	if (bad.length > 0) {
+		ctx.forbidden(c, "catalog-housekeeping", `catalog keys changed: ${bad.join(", ")}`);
+		return;
+	}
+	if (changed.has("AcroForm") && !ctx.input.after.acroForm && !ctx.input.before.acroForm) {
+		const problem = acroFormProblem(ctx, dictEntries(c.value.old)?.AcroForm ?? null, dictEntries(c.value.new)?.AcroForm ?? null);
+		if (problem) {
+			ctx.forbidden(c, "acroform-housekeeping", problem);
+			return;
+		}
+		for (const side of SIDES) ctx.claimSubtree(side, /* @__PURE__ */ new Set([root]), (label) => label.startsWith("AcroForm/DR/"), "acroform-housekeeping");
+	}
+	if (changed.has("Perms")) {
+		const after = require_resolver.deriveProtection(ctx.input.after.signatures);
+		const before = require_resolver.deriveProtection(ctx.input.before.signatures);
+		if (!after.certification || before.judged !== null) {
+			ctx.forbidden(c, "catalog-housekeeping", "/Perms may only appear with the certification signature, in the first signed revision");
+			return;
+		}
+	}
+	ctx.claimAll(c, "catalog-housekeeping");
+	ctx.permitted(c, "catalog-housekeeping");
+}
+function ruleAcroForm(ctx) {
+	const acro = ctx.input.after.acroForm || ctx.input.before.acroForm;
+	if (!acro) return;
+	const c = ctx.byNum.get(acro);
+	if (!c || ctx.isIdentical(c)) return;
+	const problem = acroFormProblem(ctx, c.value.old, c.value.new);
+	if (problem) {
+		ctx.forbidden(c, "acroform-housekeeping", problem);
+		return;
+	}
+	ctx.claimAll(c, "acroform-housekeeping");
+	ctx.permitted(c, "acroform-housekeeping");
+	for (const side of SIDES) ctx.claimSubtree(side, /* @__PURE__ */ new Set([acro]), (label) => label.startsWith("DR/"), "acroform-housekeeping");
+}
+/** What is wrong with an AcroForm dictionary change, or null when it is housekeeping. */
+function acroFormProblem(ctx, oldValue, newValue) {
+	const changed = changedKeys(oldValue, newValue);
+	const bad = [...changed].filter((k) => !ACROFORM_KEYS.has(k));
+	if (bad.length > 0) return `AcroForm keys changed: ${bad.join(", ")}`;
+	if (changed.has("Fields")) {
+		const oldRefs = refsOf(dictEntries(oldValue)?.Fields);
+		const newRefs = refsOf(dictEntries(newValue)?.Fields);
+		if (oldRefs.length > newRefs.length || oldRefs.some((n, i) => newRefs[i] !== n)) return "/AcroForm /Fields is not append-only";
+		const newSigFields = newSignatureFields(ctx);
+		const strangers = newRefs.slice(oldRefs.length).filter((n) => !newSigFields.has(n));
+		if (strangers.length > 0) return `/AcroForm /Fields gained non-signature fields: ${strangers.join(", ")}`;
+	}
+	return null;
+}
+/** The refs appended to an array-valued key when the old array is a prefix of the new one; null otherwise. */
+function appendedRefs(c, key) {
+	const oldItems = dictEntries(c.value.old)?.[key];
+	const newItems = dictEntries(c.value.new)?.[key];
+	const oldRefs = refsOf(oldItems);
+	const newRefs = refsOf(newItems);
+	if (oldItems && oldItems.t !== "array") return null;
+	if (!newItems || newItems.t !== "array") return null;
+	if (oldRefs.length > newRefs.length) return null;
+	for (let i = 0; i < oldRefs.length; i++) if (oldRefs[i] !== newRefs[i]) return null;
+	return newRefs.slice(oldRefs.length);
+}
+function newSignatureFields(ctx) {
+	const out = /* @__PURE__ */ new Set();
+	for (const n of ctx.after.sigFields) if (!ctx.before.fieldByObj.has(n)) out.add(n);
+	return out;
+}
+function ruleDss(ctx) {
+	const roots = /* @__PURE__ */ new Set([ctx.input.before.root, ctx.input.after.root]);
+	for (const side of SIDES) ctx.claimSubtree(side, roots, (label) => label === "DSS" || label.startsWith("DSS/"), "dss");
+	for (const c of ctx.changes) if (c.usage.new.some((e) => roots.has(e.parent) && e.label === "DSS") && !ctx.findings.some((f) => f.objectNumber === c.objectNumber)) ctx.permitted(c, "dss", "document security store");
+}
+function ruleSignatureFieldAdded(ctx) {
+	const added = newSignatureFields(ctx);
+	if (added.size === 0) return;
+	const rule = "signature-field-added";
+	if (!ctx.allows("fill")) {
+		for (const n of added) {
+			const c = ctx.byNum.get(n);
+			if (c) ctx.forbidden(c, rule, `a signature field was added under level '${ctx.level}'`);
+		}
+		return;
+	}
+	const newWidgets = /* @__PURE__ */ new Set();
+	for (const n of added) {
+		const field = ctx.after.fieldByObj.get(n);
+		const c = ctx.byNum.get(n);
+		if (c) {
+			ctx.claimAll(c, rule);
+			ctx.permitted(c, rule, `new signature field "${field.name}"`);
+		}
+		for (const w of field.widgets) {
+			newWidgets.add(w);
+			if (w === n) continue;
+			const wc = ctx.byNum.get(w);
+			if (wc) {
+				ctx.claimAll(wc, rule);
+				ctx.permitted(wc, rule, `widget of new signature field "${field.name}"`);
+			}
+		}
+	}
+	for (const p of ctx.after.pages) {
+		const c = ctx.byNum.get(p);
+		if (!c || ctx.isIdentical(c)) continue;
+		const changed = changedKeys(c.value.old, c.value.new);
+		if (changed.size !== 1 || !changed.has("Annots")) continue;
+		const appended = appendedRefs(c, "Annots");
+		if (appended && appended.every((n) => newWidgets.has(n))) {
+			ctx.claimAll(c, rule);
+			ctx.permitted(c, rule, "page /Annots gained the new signature widget");
+		}
+	}
+	for (const c of ctx.changes) {
+		if (c.kind !== "dictionary" || ctx.isIdentical(c)) continue;
+		const changed = changedKeys(c.value.old, c.value.new);
+		if (changed.size !== 1 || !changed.has("Kids")) continue;
+		const appended = appendedRefs(c, "Kids");
+		if (appended && appended.length > 0 && appended.every((n) => added.has(n) || newWidgets.has(n))) {
+			ctx.claimAll(c, rule);
+			ctx.permitted(c, rule, "field /Kids gained the new signature field");
+		}
+	}
+}
+function ruleSignatureAdded(ctx) {
+	const rule = "signature-added";
+	const events = ctx.newlySigned();
+	if (events.length === 0) return;
+	const addedThisStep = newSignatureFields(ctx);
+	const beforeProtection = require_resolver.deriveProtection(ctx.input.before.signatures);
+	const afterProtection = require_resolver.deriveProtection(ctx.input.after.signatures);
+	const parents = /* @__PURE__ */ new Set();
+	const values = /* @__PURE__ */ new Set();
+	for (const { fieldObjectNumber, sig } of events) {
+		const needed = sig.kind === "timestamp" ? "lta" : "fill";
+		if (!ctx.allows(needed)) {
+			const c = ctx.byNum.get(fieldObjectNumber);
+			if (c) ctx.forbidden(c, rule, `a ${sig.kind} was added under level '${ctx.level}'`);
+			continue;
+		}
+		if (sig.catalogCertification && beforeProtection.judged !== null) {
+			const c = ctx.byNum.get(fieldObjectNumber);
+			if (c) ctx.forbidden(c, rule, "a certification signature after another signature");
+			continue;
+		}
+		const field = ctx.after.fieldByObj.get(fieldObjectNumber);
+		parents.add(fieldObjectNumber);
+		for (const w of field?.widgets ?? []) parents.add(w);
+		const fieldIsNew = addedThisStep.has(fieldObjectNumber);
+		const allowedFieldKeys = beforeProtection.judged === null ? /* @__PURE__ */ new Set([...signedFieldKeysFor(ctx.level), "Lock"]) : signedFieldKeysFor(ctx.level);
+		const fc = ctx.byNum.get(fieldObjectNumber);
+		if (fc && fieldIsNew) ctx.permitted(fc, rule, `new field "${sig.fieldName}" signed`);
+		else if (fc && !ctx.isIdentical(fc)) {
+			const changed = changedKeys(fc.value.old, fc.value.new);
+			const bad = [...changed].filter((k) => !allowedFieldKeys.has(k));
+			if (bad.length > 0) {
+				ctx.forbidden(fc, rule, `signature field keys changed: ${bad.join(", ")}`);
+				ctx.claimStable(fc, rule, false);
+			} else if (changed.has("Ff") && !readOnlyOnlyChange(fc, ctx.before.fieldByObj.get(fieldObjectNumber)?.flags)) {
+				ctx.forbidden(fc, rule, "signature field flags changed beyond ReadOnly");
+				ctx.claimStable(fc, rule, false);
+			} else {
+				ctx.claimStable(fc, rule);
+				ctx.permitted(fc, rule, `field "${sig.fieldName}" signed`);
+			}
+		}
+		for (const w of field?.widgets ?? []) {
+			if (w === fieldObjectNumber || fieldIsNew) continue;
+			const wc = ctx.byNum.get(w);
+			if (!wc || ctx.isIdentical(wc)) continue;
+			const bad = [...changedKeys(wc.value.old, wc.value.new)].filter((k) => !SIGNED_WIDGET_KEYS.has(k));
+			if (bad.length > 0) {
+				ctx.forbidden(wc, rule, `signature widget keys changed: ${bad.join(", ")}`);
+				ctx.claimStable(wc, rule, false);
+				continue;
+			}
+			ctx.claimStable(wc, rule);
+			ctx.permitted(wc, rule, "signature widget appearance");
+		}
+		for (const c of ctx.changes) {
+			if (c.change !== "added") continue;
+			const asValue = c.usage.new.filter((e) => e.parent === fieldObjectNumber && e.label === "V");
+			const asLock = c.usage.new.filter((e) => e.parent === fieldObjectNumber && e.label === "Lock");
+			const type = dictEntries(c.value.new)?.Type;
+			if (asValue.length > 0) {
+				if (!(type?.t === "name" && (type.v === "Sig" || type.v === "DocTimeStamp")) && type !== void 0) continue;
+				for (const e of c.usage.new) if (e.parent === fieldObjectNumber && e.label === "V" || e.label === "DocMDP") ctx.claimEdge(c, "new", e, rule);
+				ctx.permitted(c, rule, "signature value");
+				values.add(c.objectNumber);
+			} else if (asLock.length > 0) {
+				if (!(type === void 0 || type.t === "name" && type.v === "SigFieldLock")) continue;
+				for (const e of asLock) ctx.claimEdge(c, "new", e, rule);
+				ctx.permitted(c, rule, "field lock installed with the signature");
+			}
+		}
+	}
+	if (afterProtection.certification && beforeProtection.judged === null) {
+		const root = ctx.input.after.root;
+		for (const c of ctx.changes) if (c.change === "added" && onlyEdges(c, (e) => e.parent === root && e.label === "Perms")) {
+			ctx.claimAll(c, rule);
+			ctx.permitted(c, rule, "certification permissions");
+		}
+	}
+	for (const side of SIDES) ctx.claimSubtree(side, parents, (label) => label === "AP" || label.startsWith("AP/"), rule);
+	if (values.size > 0) ctx.claimSubtree("new", values, () => true, rule);
+}
+/**
+* Did `/Ff` change by gaining ReadOnly and nothing else? `/Ff` is
+* inheritable, and a lock writes `effective | ReadOnly` into the terminal
+* dictionary, so a terminal that carried no `/Ff` of its own is judged
+* against the effective flags the older revision's form model reported.
+*/
+function readOnlyOnlyChange(c, effectiveBefore) {
+	const oldFf = dictEntries(c.value.old)?.Ff;
+	const newFf = dictEntries(c.value.new)?.Ff;
+	const before = oldFf?.t === "number" ? oldFf.v : effectiveBefore ?? 0;
+	const after = newFf?.t === "number" ? newFf.v : 0;
+	return (before | FF_READ_ONLY) === after;
+}
+function ruleFormFill(ctx) {
+	const rule = "form-fill";
+	const fieldKeys = fieldKeysFor(ctx.level);
+	const widgetKeys = widgetKeysFor(ctx.level);
+	const parents = /* @__PURE__ */ new Set();
+	const fields = new Map([...ctx.before.fieldByObj, ...ctx.after.fieldByObj]);
+	for (const [num, field] of fields) {
+		if (field.family === "signature") continue;
+		const fc = ctx.byNum.get(num);
+		const widgetChanges = field.widgets.filter((w) => w !== num).map((w) => ctx.byNum.get(w)).filter(Boolean);
+		const owners = /* @__PURE__ */ new Set([num, ...field.widgets]);
+		const isAp = (label) => label === "AP" || label.startsWith("AP/");
+		const appearanceOnly = !fc && widgetChanges.length === 0 ? ctx.changes.filter((c) => SIDES.some((side) => c.usage[side].some((e) => owners.has(e.parent) && isAp(e.label))) && SIDES.every((side) => c.usage[side].every((e) => !isAp(e.label) || owners.has(e.parent)))) : [];
+		if (!fc && widgetChanges.length === 0 && appearanceOnly.length === 0) continue;
+		if (!ctx.allows("fill")) {
+			for (const c of [
+				fc,
+				...widgetChanges,
+				...appearanceOnly
+			]) if (c && !ctx.isIdentical(c)) ctx.forbidden(c, rule, `form fill under level '${ctx.level}'`);
+			continue;
+		}
+		if (appearanceOnly.length > 0) {
+			for (const c of appearanceOnly) ctx.permitted(c, rule, `appearance of field "${field.name}" regenerated`);
+			parents.add(num);
+			for (const w of field.widgets) parents.add(w);
+			continue;
+		}
+		let ok = true;
+		if (fc && !ctx.isIdentical(fc)) {
+			const changed = changedKeys(fc.value.old, fc.value.new);
+			const bad = [...changed].filter((k) => !fieldKeys.has(k));
+			if (bad.length > 0) {
+				ctx.forbidden(fc, rule, `field "${field.name}" keys changed: ${bad.join(", ")}`);
+				ctx.claimStable(fc, rule, false);
+				ok = false;
+			} else if (changed.has("Ff") && !readOnlyOnlyChange(fc, ctx.before.fieldByObj.get(num)?.flags)) {
+				ctx.forbidden(fc, rule, `field "${field.name}" flags changed beyond adding ReadOnly`);
+				ctx.claimStable(fc, rule, false);
+				ok = false;
+			} else {
+				ctx.claimStable(fc, rule);
+				const properties = [...changed].filter((k) => k !== "V" && k !== "AP" && k !== "AS" && k !== "I" && k !== "RV");
+				ctx.permitted(fc, rule, properties.length > 0 ? `field "${field.name}" ${changed.has("V") || changed.has("AS") ? "filled, " : ""}properties changed: ${properties.join(", ")}` : `field "${field.name}" filled`);
+			}
+		}
+		for (const wc of widgetChanges) {
+			if (ctx.isIdentical(wc)) continue;
+			const bad = [...changedKeys(wc.value.old, wc.value.new)].filter((k) => !widgetKeys.has(k));
+			if (bad.length > 0) {
+				ctx.forbidden(wc, rule, `widget of "${field.name}" keys changed: ${bad.join(", ")}`);
+				ctx.claimStable(wc, rule, false);
+				ok = false;
+				continue;
+			}
+			ctx.claimStable(wc, rule);
+			ctx.permitted(wc, rule, `widget of "${field.name}" appearance`);
+		}
+		if (ok) {
+			parents.add(num);
+			for (const w of field.widgets) parents.add(w);
+		}
+	}
+	for (const side of SIDES) ctx.claimSubtree(side, parents, (label) => label === "AP" || label.startsWith("AP/"), rule);
+}
+function ruleAnnotation(ctx) {
+	const rule = "annotation";
+	const pages = /* @__PURE__ */ new Set([...ctx.before.pages, ...ctx.after.pages]);
+	const widgets = /* @__PURE__ */ new Set([...ctx.before.widgetToField.keys(), ...ctx.after.widgetToField.keys()]);
+	const isWidget = (c) => {
+		if (widgets.has(c.objectNumber)) return true;
+		const sub = dictEntries(c.value.new ?? c.value.old)?.Subtype;
+		return sub?.t === "name" && sub.v === "Widget";
+	};
+	const annots = [];
+	for (const c of ctx.changes) {
+		if (c.kind !== "dictionary" || ctx.isIdentical(c)) continue;
+		if ([...c.usage.old, ...c.usage.new].some((e) => pages.has(e.parent) && e.label.startsWith("Annots/")) && !isWidget(c)) annots.push(c);
+	}
+	if (annots.length === 0) {}
+	if (!ctx.allows("annotate")) {
+		for (const c of annots) ctx.forbidden(c, rule, `annotation change under level '${ctx.level}'`);
+		return;
+	}
+	const parents = /* @__PURE__ */ new Set();
+	for (const c of annots) {
+		ctx.claimAll(c, rule);
+		ctx.permitted(c, rule, `${c.change} annotation`);
+		parents.add(c.objectNumber);
+	}
+	for (const p of pages) {
+		const c = ctx.byNum.get(p);
+		if (!c || ctx.isIdentical(c)) continue;
+		const changed = changedKeys(c.value.old, c.value.new);
+		if (changed.size === 1 && changed.has("Annots")) {
+			const removed = refsOf(dictEntries(c.value.old)?.Annots).filter((n) => !refsOf(dictEntries(c.value.new)?.Annots).includes(n));
+			const added = refsOf(dictEntries(c.value.new)?.Annots).filter((n) => !refsOf(dictEntries(c.value.old)?.Annots).includes(n));
+			if ([...removed, ...added].some((n) => widgets.has(n) && !ctx.findings.some((f) => f.objectNumber === n && f.verdict === "permitted"))) {
+				ctx.forbidden(c, rule, "page /Annots added or removed a form widget");
+				continue;
+			}
+			ctx.claimAll(c, rule);
+			ctx.permitted(c, rule, "page /Annots changed");
+		}
+	}
+	for (const side of SIDES) ctx.claimSubtree(side, parents, (label) => label === "AP" || label.startsWith("AP/") || label === "Popup" || label === "IRT", rule);
+}
+function ruleFieldLock(ctx) {
+	if (ctx.locks.length === 0) return;
+	const lockedFields = ctx.input.before.fields.filter((f) => ctx.locks.some((l) => require_resolver.lockCovers(l.spec, f.name)));
+	const lockedObjects = /* @__PURE__ */ new Set();
+	for (const f of lockedFields) {
+		lockedObjects.add(f.objectNumber);
+		for (const w of f.widgets) lockedObjects.add(w);
+	}
+	const frontier = new Set(lockedObjects);
+	let grew = true;
+	while (grew) {
+		grew = false;
+		for (const c of ctx.changes) {
+			if (frontier.has(c.objectNumber)) continue;
+			if (c.usage.old.length > 0 && c.usage.old.every((e) => frontier.has(e.parent))) {
+				frontier.add(c.objectNumber);
+				grew = true;
+			}
+		}
+	}
+	for (const c of ctx.changes) {
+		if (!frontier.has(c.objectNumber) || ctx.isIdentical(c)) continue;
+		const field = lockedFields.find((f) => f.objectNumber === c.objectNumber || f.widgets.includes(c.objectNumber));
+		if (field && field.objectNumber === c.objectNumber) {
+			const changed = changedKeys(c.value.old, c.value.new);
+			if (changed.size === 1 && changed.has("Ff") && readOnlyOnlyChange(c, ctx.before.fieldByObj.get(c.objectNumber)?.flags)) {
+				ctx.claimStable(c, "field-lock");
+				ctx.permitted(c, "field-lock", `ReadOnly set on locked field "${field.name}"`);
+				continue;
+			}
+		}
+		ctx.locked.add(c.objectNumber);
+		ctx.forbidden(c, "field-lock", field ? `field "${field.name}" is locked by the signature` : "part of a locked field changed");
+	}
+}
+function ruleUnexplained(ctx) {
+	for (const c of ctx.changes) {
+		if (c.value.truncated) {
+			ctx.findings.push({
+				rule: "unexplained",
+				verdict: "incomplete",
+				objectNumber: c.objectNumber,
+				detail: "value too large to inspect"
+			});
+			continue;
+		}
+		if (c.usageIncomplete) {
+			ctx.findings.push({
+				rule: "unexplained",
+				verdict: "incomplete",
+				objectNumber: c.objectNumber,
+				detail: "references could not be resolved within budget (depth, fan-out or total reads)"
+			});
+			continue;
+		}
+		if (ctx.locked.has(c.objectNumber)) continue;
+		for (const side of SIDES) for (const e of c.usage[side]) if (!ctx.isClaimed(c, side, e)) ctx.forbidden(c, "unexplained", `${side === "old" ? "was" : "is"} referenced from object ${e.parent} at ${e.label} and no rule explains it`, e);
+		if (c.usage.old.length === 0 && c.usage.new.length === 0 && !ctx.findings.some((f) => f.objectNumber === c.objectNumber)) ctx.permitted(c, "orphan", "referenced from nowhere reachable");
+	}
+}
+//#endregion
+//#region src/signature/analysis/restrictions.ts
+/**
+* The restrictions a window is judged under, read from the SEALED
+* revision's structure (what that revision declared, not what the final
+* file says).
+*
+*   - `judged` given (a signature-anchored analysis): its own FieldMDP and
+*     /Lock bind the window; other signatures' locks do not (corpus v3/85:
+*     a second signature is valid with a fill of a field the first locked).
+*     Every certification's level, own or earlier, applies (inherited:
+*     conservative until observed otherwise), as does a /Lock's /P.
+*   - no `judged` (a revision-anchored analysis): every signed signature's
+*     locks and levels, as before.
+*/
+function restrictionsFor(before, judged) {
+	const anchors = [];
+	const locks = [];
+	let enforced = null;
+	let signed = false;
+	for (const sig of before.signatures) {
+		if (!sig.signed || sig.revisionIndex === null) continue;
+		signed = true;
+		const own = judged !== null && sig.index === judged.index;
+		if (sig.catalogCertification && sig.docMdp !== null) {
+			anchors.push({
+				signatureIndex: sig.index,
+				revisionIndex: sig.revisionIndex,
+				source: "docmdp",
+				own,
+				permission: sig.docMdp
+			});
+			enforced = require_resolver.minLevel(enforced ?? "annotate", require_resolver.levelFromPermission(sig.docMdp));
+		}
+		if (sig.lock?.permission !== void 0) enforced = require_resolver.minLevel(enforced ?? "annotate", require_resolver.levelFromPermission(sig.lock.permission));
+		if (judged !== null && !own) continue;
+		if (sig.fieldMdp) {
+			anchors.push({
+				signatureIndex: sig.index,
+				revisionIndex: sig.revisionIndex,
+				source: "fieldmdp",
+				own,
+				fields: sig.fieldMdp
+			});
+			locks.push({
+				signatureIndex: sig.index,
+				source: "fieldmdp",
+				spec: sig.fieldMdp
+			});
+		}
+		if (sig.lock) {
+			anchors.push({
+				signatureIndex: sig.index,
+				revisionIndex: sig.revisionIndex,
+				source: "lock",
+				own,
+				fields: sig.lock
+			});
+			locks.push({
+				signatureIndex: sig.index,
+				source: "lock",
+				spec: sig.lock
+			});
+		}
+	}
+	return {
+		anchors,
+		level: signed ? enforced ?? "annotate" : "annotate",
+		locks
+	};
+}
+//#endregion
+//#region src/signature/analysis/resolve.ts
+const DEFAULT_EDGE_RESOLVER_BUDGET = {
+	maxDepth: 16,
+	maxEdgesPerObject: 256,
+	maxReads: 2e4
+};
+const USAGE_INCOMPLETE = "incomplete";
+/**
+* Resolves the raw inbound edges of an object (from the fork's referrer
+* index, which covers every reachable object of a revision) into edges
+* from *anchors*: the changed objects and the structural objects of the
+* revision (trailer, catalog, AcroForm, page tree root, pages, fields,
+* widgets). An edge from an unchanged, non-structural parent is replaced by
+* that parent's own anchored edges with the labels joined, so an
+* appearance stream under an unchanged indirect `/AP` dictionary reads
+* `widget:AP/N` rather than `apDict:N`.
+*
+* A graph traversal, not a path enumeration: results are memoised per
+* object, so a lattice of shared unchanged objects costs its size, not the
+* number of paths through it. Cycle edges contribute no anchors and are
+* skipped; a result computed while skipping one is not memoised.
+*/
+var EdgeResolver = class {
+	constructor(read, anchors, budget = DEFAULT_EDGE_RESOLVER_BUDGET) {
+		this.read = read;
+		this.anchors = anchors;
+		this.budget = budget;
+		require_derive._defineProperty(this, "memo", /* @__PURE__ */ new Map());
+		require_derive._defineProperty(this, "reads", 0);
+		require_derive._defineProperty(this, "exhausted", false);
+	}
+	/** Anchored edges of `objectNumber`, or `incomplete` when a budget was exceeded. */
+	resolve(objectNumber) {
+		if (this.exhausted) return USAGE_INCOMPLETE;
+		const result = this.resolveInner(objectNumber, /* @__PURE__ */ new Set());
+		return result === null ? USAGE_INCOMPLETE : result.edges;
+	}
+	resolveInner(n, active) {
+		const hit = this.memo.get(n);
+		if (hit) return hit;
+		if (active.size >= this.budget.maxDepth) return null;
+		if (this.reads >= this.budget.maxReads) {
+			this.exhausted = true;
+			return null;
+		}
+		this.reads += 1;
+		const raw = this.read(n);
+		active.add(n);
+		const edges = [];
+		let cyclic = false;
+		try {
+			for (const e of raw) {
+				if (this.anchors.has(e.parent)) edges.push(e);
+				else if (active.has(e.parent)) {
+					cyclic = true;
+					continue;
+				} else {
+					const up = this.resolveInner(e.parent, active);
+					if (up === null) return null;
+					cyclic || (cyclic = up.cyclic);
+					for (const u of up.edges) edges.push({
+						parent: u.parent,
+						label: `${u.label}/${e.label}`,
+						via: [...u.via ?? [], e.parent]
+					});
+				}
+				if (edges.length > this.budget.maxEdgesPerObject) return null;
+			}
+		} finally {
+			active.delete(n);
+		}
+		const resolution = {
+			edges,
+			cyclic
+		};
+		if (!cyclic) this.memo.set(n, resolution);
+		return resolution;
+	}
+};
+//#endregion
 //#region src/search/literal.ts
 /**
 * The fold flavor a literal query needs. Haystack and needle MUST be
@@ -865,7 +2136,8 @@ function decodeFieldRefKey(key) {
 function foldOptionsFor(query) {
 	return {
 		keepCase: !!query.matchCase,
-		keepMarks: !!query.matchDiacritics
+		keepMarks: !!query.matchDiacritics,
+		dropWhitespace: !!query.ignoreWhitespace
 	};
 }
 const WORD_UNIT = /[\p{L}\p{N}_]/u;
@@ -883,18 +2155,29 @@ function wordAt(text, index) {
 	return WORD_UNIT.test(String.fromCodePoint(text.codePointAt(index)));
 }
 /**
+* Whether the folded hit at `at` sits on word boundaries. Checked on the
+* folded plane, except under `ignoreWhitespace`: dropping whitespace glues
+* neighbouring words together ("i n v o i c e 42" folds to "invoice42"), so there the
+* boundaries are read off the ORIGINAL text around the mapped range.
+*/
+function isWholeWordHit(haystack, at, needleLength, query) {
+	if (!query.ignoreWhitespace) return !wordBefore(haystack.folded, at) && !wordAt(haystack.folded, at + needleLength);
+	const { start, length } = require_derive.toOriginalRange(haystack, at, needleLength);
+	return !wordBefore(haystack.original, start) && !wordAt(haystack.original, start + length);
+}
+/**
 * All non-overlapping literal matches, in original code-unit space.
 * `haystack` must have been folded with `foldOptionsFor(query)`.
 */
 function matchLiteral(haystack, query) {
-	const needle = require_fold.foldText(query.text, foldOptionsFor(query)).folded;
+	const needle = require_derive.foldText(query.text, foldOptionsFor(query)).folded;
 	if (needle.trim().length === 0) return [];
 	const out = [];
 	let from = 0;
 	while (from <= haystack.folded.length - needle.length) {
 		const at = haystack.folded.indexOf(needle, from);
 		if (at < 0) break;
-		if (query.wholeWord && (wordBefore(haystack.folded, at) || wordAt(haystack.folded, at + needle.length))) {
+		if (query.wholeWord && !isWholeWordHit(haystack, at, needle.length, query)) {
 			from = at + 1;
 			continue;
 		}
@@ -905,7 +2188,7 @@ function matchLiteral(haystack, query) {
 				continue;
 			}
 		}
-		out.push(require_fold.toOriginalRange(haystack, at, needle.length));
+		out.push(require_derive.toOriginalRange(haystack, at, needle.length));
 		from = at + needle.length;
 	}
 	return out;
@@ -995,6 +2278,11 @@ function validateSearchQuery(query) {
 		issue: "diacritics-with-regex",
 		message: "Diacritic-sensitive matching is not available for regex patterns (regex runs on the raw text plane)."
 	};
+	if (query.ignoreWhitespace) return {
+		ok: false,
+		issue: "ignore-whitespace-with-regex",
+		message: "Whitespace-insensitive matching is not available for regex patterns (regex runs on the raw text plane; use \\s* in the pattern)."
+	};
 	return validateSearchRegex(query.text);
 }
 /**
@@ -1042,7 +2330,7 @@ function matchRegex(text, query) {
 */
 function matchPageText(text, query) {
 	if (query.regex) return matchRegex(text, query);
-	return matchLiteral(require_fold.foldText(text, foldOptionsFor(query)), query);
+	return matchLiteral(require_derive.foldText(text, foldOptionsFor(query)), query);
 }
 //#endregion
 //#region src/search/snippet.ts
@@ -1182,7 +2470,7 @@ function buildPageTextLayout(snapshot) {
 	const runs = [];
 	const frames = [IDENTITY_FRAME];
 	for (const run of snapshot.runs) {
-		if (!require_fold.isRotatedGeometryRun(run)) {
+		if (!require_derive.isRotatedGeometryRun(run)) {
 			for (const g of run.glyphs) glyphs.push({
 				loose: g.looseBox,
 				tight: g.tightBox,
@@ -1578,8 +2866,8 @@ function fnv1a64(input) {
 * untouched (their raw form IS the query).
 */
 function canonicalSearchQuery(query) {
-	if (query.regex || query.matchCase || query.matchDiacritics) return query;
-	const canonical = { text: require_fold.foldText(query.text).folded };
+	if (query.regex || query.matchCase || query.matchDiacritics || query.ignoreWhitespace) return query;
+	const canonical = { text: require_derive.foldText(query.text).folded };
 	if (query.wholeWord) canonical.wholeWord = true;
 	return canonical;
 }
@@ -1765,17 +3053,38 @@ function materializePdfPermissions(b) {
 	}
 	if (b.bit11) out.add("doc.pages.assemble");
 	if (b.bit6) out.add("doc.annotate.modify");
-	if (b.bit6 || b.bit9) out.add("doc.forms.fill");
+	if (b.bit6 || b.bit9) {
+		out.add("doc.forms.fill");
+		out.add("doc.sign");
+	}
 	if (b.bit6 && b.bit4) out.add("doc.forms.modify");
 	return [...out];
 }
 //#endregion
+//#region src/measure/viewport.ts
+/** Last containing viewport wins. A foreign measure still wins; never guess a fallback. */
+function viewportForPoint(viewports, point) {
+	return [...viewports].reverse().find(({ bbox: b }) => point.x >= b.left && point.x <= b.right && point.y >= b.bottom && point.y <= b.top);
+}
+//#endregion
+Object.defineProperty(exports, "DEFAULT_EDGE_RESOLVER_BUDGET", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_EDGE_RESOLVER_BUDGET;
+	}
+});
 Object.defineProperty(exports, "DEFAULT_PDF_SAVE_MODE", {
 	enumerable: true,
 	get: function() {
 		return DEFAULT_PDF_SAVE_MODE;
 	}
 });
+Object.defineProperty(exports, "EdgeResolver", {
+	enumerable: true,
+	get: function() {
+		return EdgeResolver;
+	}
+});
 Object.defineProperty(exports, "NO_ANNOTATION_FLAGS", {
 	enumerable: true,
 	get: function() {
@@ -1806,12 +3115,24 @@ Object.defineProperty(exports, "UNKNOWN_WEAK_ANNOTATION_STATE", {
 		return UNKNOWN_WEAK_ANNOTATION_STATE;
 	}
 });
+Object.defineProperty(exports, "USAGE_INCOMPLETE", {
+	enumerable: true,
+	get: function() {
+		return USAGE_INCOMPLETE;
+	}
+});
 Object.defineProperty(exports, "appearanceImpactOf", {
 	enumerable: true,
 	get: function() {
 		return appearanceImpactOf;
 	}
 });
+Object.defineProperty(exports, "assessmentOf", {
+	enumerable: true,
+	get: function() {
+		return assessmentOf;
+	}
+});
 Object.defineProperty(exports, "buildCommentThreads", {
 	enumerable: true,
 	get: function() {
@@ -1830,12 +3151,6 @@ Object.defineProperty(exports, "buildSnippet", {
 		return buildSnippet;
 	}
 });
-Object.defineProperty(exports, "buildThreads", {
-	enumerable: true,
-	get: function() {
-		return buildThreads;
-	}
-});
 Object.defineProperty(exports, "canonicalSearchQuery", {
 	enumerable: true,
 	get: function() {
@@ -1848,16 +3163,16 @@ Object.defineProperty(exports, "caps", {
 		return caps;
 	}
 });
-Object.defineProperty(exports, "changesAnnotationList", {
+Object.defineProperty(exports, "changedKeys", {
 	enumerable: true,
 	get: function() {
-		return changesAnnotationList;
+		return changedKeys;
 	}
 });
-Object.defineProperty(exports, "classifyRelation", {
+Object.defineProperty(exports, "changesAnnotationList", {
 	enumerable: true,
 	get: function() {
-		return classifyRelation;
+		return changesAnnotationList;
 	}
 });
 Object.defineProperty(exports, "collab", {
@@ -1866,6 +3181,18 @@ Object.defineProperty(exports, "collab", {
 		return collab;
 	}
 });
+Object.defineProperty(exports, "combine", {
+	enumerable: true,
+	get: function() {
+		return combine;
+	}
+});
+Object.defineProperty(exports, "conclude", {
+	enumerable: true,
+	get: function() {
+		return conclude;
+	}
+});
 Object.defineProperty(exports, "createPageImageHandle", {
 	enumerable: true,
 	get: function() {
@@ -1896,6 +3223,12 @@ Object.defineProperty(exports, "decodeSubmitFormFlags", {
 		return decodeSubmitFormFlags;
 	}
 });
+Object.defineProperty(exports, "dictEntries", {
+	enumerable: true,
+	get: function() {
+		return dictEntries;
+	}
+});
 Object.defineProperty(exports, "encodeFieldRefKey", {
 	enumerable: true,
 	get: function() {
@@ -1908,6 +3241,12 @@ Object.defineProperty(exports, "encodeStableIdKey", {
 		return encodeStableIdKey;
 	}
 });
+Object.defineProperty(exports, "evaluateStep", {
+	enumerable: true,
+	get: function() {
+		return evaluateStep;
+	}
+});
 Object.defineProperty(exports, "expandTextRangeToLine", {
 	enumerable: true,
 	get: function() {
@@ -1992,16 +3331,34 @@ Object.defineProperty(exports, "normalizeAttachmentFileSource", {
 		return normalizeAttachmentFileSource;
 	}
 });
+Object.defineProperty(exports, "parsePdfValue", {
+	enumerable: true,
+	get: function() {
+		return parsePdfValue;
+	}
+});
 Object.defineProperty(exports, "pdfPermissions", {
 	enumerable: true,
 	get: function() {
 		return pdfPermissions;
 	}
 });
-Object.defineProperty(exports, "refKey", {
+Object.defineProperty(exports, "pdfValueEquals", {
+	enumerable: true,
+	get: function() {
+		return pdfValueEquals;
+	}
+});
+Object.defineProperty(exports, "primaryFinding", {
+	enumerable: true,
+	get: function() {
+		return primaryFinding;
+	}
+});
+Object.defineProperty(exports, "refsOf", {
 	enumerable: true,
 	get: function() {
-		return refKey;
+		return refsOf;
 	}
 });
 Object.defineProperty(exports, "resolveBinarySource", {
@@ -2010,12 +3367,42 @@ Object.defineProperty(exports, "resolveBinarySource", {
 		return resolveBinarySource;
 	}
 });
+Object.defineProperty(exports, "restrictionsFor", {
+	enumerable: true,
+	get: function() {
+		return restrictionsFor;
+	}
+});
+Object.defineProperty(exports, "restrictionsOf", {
+	enumerable: true,
+	get: function() {
+		return restrictionsOf;
+	}
+});
 Object.defineProperty(exports, "revisionTokensEqual", {
 	enumerable: true,
 	get: function() {
 		return revisionTokensEqual;
 	}
 });
+Object.defineProperty(exports, "richTextParagraphsFromPlainText", {
+	enumerable: true,
+	get: function() {
+		return richTextParagraphsFromPlainText;
+	}
+});
+Object.defineProperty(exports, "richTextPlainText", {
+	enumerable: true,
+	get: function() {
+		return richTextPlainText;
+	}
+});
+Object.defineProperty(exports, "sameEffectiveValue", {
+	enumerable: true,
+	get: function() {
+		return sameEffectiveValue;
+	}
+});
 Object.defineProperty(exports, "searchContentEpoch", {
 	enumerable: true,
 	get: function() {
@@ -2052,6 +3439,12 @@ Object.defineProperty(exports, "sniffBinaryMetadata", {
 		return sniffBinaryMetadata;
 	}
 });
+Object.defineProperty(exports, "stableStringify", {
+	enumerable: true,
+	get: function() {
+		return stableStringify;
+	}
+});
 Object.defineProperty(exports, "textGlyphAt", {
 	enumerable: true,
 	get: function() {
@@ -2082,6 +3475,12 @@ Object.defineProperty(exports, "validateSearchRegex", {
 		return validateSearchRegex;
 	}
 });
+Object.defineProperty(exports, "viewportForPoint", {
+	enumerable: true,
+	get: function() {
+		return viewportForPoint;
+	}
+});
 Object.defineProperty(exports, "wordAt", {
 	enumerable: true,
 	get: function() {
@@ -2094,5 +3493,11 @@ Object.defineProperty(exports, "wordBefore", {
 		return wordBefore;
 	}
 });
+Object.defineProperty(exports, "worstVerdict", {
+	enumerable: true,
+	get: function() {
+		return worstVerdict;
+	}
+});
 
-//# sourceMappingURL=builders-8Hl1AYNU.cjs.map
+//# sourceMappingURL=viewport-BWeNHZmb.cjs.map