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

package/dist/{builders-DOjcKDWQ.js → viewport-CvMcadfQ.js}

@@ -1,5 +1,6 @@
-import { i as EngineError, n as foldText, r as toOriginalRange, u as isRotatedGeometryRun } from "./fold-BfyxxwS6.js";
-import { f as EngineErrorCode } from "./PageInsertBlankInput-WKY0tr6S.js";
+import { A as isRotatedGeometryRun, C as refKey, D as _defineProperty, S as classifyRelation, b as toOriginalRange, w as EngineError, y as foldText } from "./derive-DAFJolWu.js";
+import { m as EngineErrorCode } from "./format-Bbphf4zR.js";
+import { _ as levelAllows, h as deriveProtection, v as levelFromPermission, x as minLevel, y as lockCovers } from "./resolver-inAVzsWt.js";
 //#region src/dto/PdfAction.ts
 /**
 * The one Table-240 decode, shared by the reader, the schema's producers,
@@ -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
@@ -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
@@ -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;
+		_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 = 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;
+		_defineProperty(this, "findings", []);
+		_defineProperty(this, "byNum", /* @__PURE__ */ new Map());
+		_defineProperty(this, "before", void 0);
+		_defineProperty(this, "after", void 0);
+		_defineProperty(this, "claims", /* @__PURE__ */ new Map());
+		_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 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 = deriveProtection(ctx.input.after.signatures);
+		const before = 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 = deriveProtection(ctx.input.before.signatures);
+	const afterProtection = 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) => 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 = minLevel(enforced ?? "annotate", levelFromPermission(sig.docMdp));
+		}
+		if (sig.lock?.permission !== void 0) enforced = minLevel(enforced ?? "annotate", 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;
+		_defineProperty(this, "memo", /* @__PURE__ */ new Map());
+		_defineProperty(this, "reads", 0);
+		_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,6 +2155,17 @@ 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 } = 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)`.
 */
@@ -894,7 +2177,7 @@ function matchLiteral(haystack, query) {
 	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;
 		}
@@ -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);
 }
 /**
@@ -1578,7 +2866,7 @@ function fnv1a64(input) {
 * untouched (their raw form IS the query).
 */
 function canonicalSearchQuery(query) {
-	if (query.regex || query.matchCase || query.matchDiacritics) return query;
+	if (query.regex || query.matchCase || query.matchDiacritics || query.ignoreWhitespace) return query;
 	const canonical = { text: foldText(query.text).folded };
 	if (query.wholeWord) canonical.wholeWord = true;
 	return canonical;
@@ -1765,11 +3053,20 @@ 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
-export { createPageImageHandle as $, appearanceImpactOf as A, normalizeAnnotationDraft as B, validateSearchRegex as C, wordBefore as D, wordAt as E, buildCommentThreads as F, NO_ANNOTATION_FLAGS as G, normalizeAttachmentFileSource as H, isStateAnnotation as I, revisionTokensEqual as J, UNKNOWN_WEAK_ANNOTATION_STATE as K, buildThreads as L, changesAnnotationList as M, invalidatesWeakIndexRefs as N, decodeFieldRefKey as O, shiftsExistingAnnotationIndices as P, DEFAULT_PDF_SAVE_MODE as Q, classifyRelation as R, validateSearchQuery as S, matchLiteral as T, sniffBinaryMetadata as U, normalizeAnnotationPatch as V, resolveBinarySource as W, encodeStableIdKey as X, decodeStableIdKey as Y, isValidPageObjectNumber as Z, SEARCH_SNIPPET_CONTEXT as _, PDF_BITS as a, SEARCH_REGEX_MAX_LENGTH as b, searchContentEpoch as c, buildPageTextLayout as d, decodeSubmitFormFlags as et, expandTextRangeToLine as f, textSegmentsForRange as g, textGlyphQuad as h, pdfPermissions as i, semanticEqual as j, encodeFieldRefKey as k, searchRectsForRange as l, textGlyphAt as m, collab as n, decodePdfBits as o, expandTextRangeToWord as p, knownWeakAnnotationState as q, materializePdfPermissions as r, canonicalSearchQuery as s, caps as t, searchSegmentsForRange as u, buildSnippet as v, foldOptionsFor as w, matchRegex as x, matchPageText as y, refKey as z };
+//#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
+export { shiftsExistingAnnotationIndices as $, EdgeResolver as A, worstVerdict as B, validateSearchQuery as C, wordAt as D, matchLiteral as E, sameEffectiveValue as F, refsOf as G, dictEntries as H, assessmentOf as I, encodeFieldRefKey as J, stableStringify as K, combine as L, restrictionsFor as M, evaluateStep as N, wordBefore as O, restrictionsOf as P, invalidatesWeakIndexRefs as Q, conclude as R, matchRegex as S, foldOptionsFor as T, parsePdfValue as U, changedKeys as V, pdfValueEquals as W, semanticEqual as X, appearanceImpactOf as Y, changesAnnotationList as Z, textSegmentsForRange as _, createPageImageHandle as _t, pdfPermissions as a, sniffBinaryMetadata as at, matchPageText as b, canonicalSearchQuery as c, UNKNOWN_WEAK_ANNOTATION_STATE as ct, searchSegmentsForRange as d, decodeStableIdKey as dt, buildCommentThreads as et, buildPageTextLayout as f, encodeStableIdKey as ft, textGlyphQuad as g, DEFAULT_PDF_SAVE_MODE as gt, textGlyphAt as h, richTextPlainText as ht, materializePdfPermissions as i, normalizeAttachmentFileSource as it, USAGE_INCOMPLETE as j, DEFAULT_EDGE_RESOLVER_BUDGET as k, searchContentEpoch as l, knownWeakAnnotationState as lt, expandTextRangeToWord as m, richTextParagraphsFromPlainText as mt, caps as n, normalizeAnnotationDraft as nt, PDF_BITS as o, resolveBinarySource as ot, expandTextRangeToLine as p, isValidPageObjectNumber as pt, decodeFieldRefKey as q, collab as r, normalizeAnnotationPatch as rt, decodePdfBits as s, NO_ANNOTATION_FLAGS as st, viewportForPoint as t, isStateAnnotation as tt, searchRectsForRange as u, revisionTokensEqual as ut, SEARCH_SNIPPET_CONTEXT as v, decodeSubmitFormFlags as vt, validateSearchRegex as w, SEARCH_REGEX_MAX_LENGTH as x, buildSnippet as y, primaryFinding as z };
 
-//# sourceMappingURL=builders-DOjcKDWQ.js.map
+//# sourceMappingURL=viewport-CvMcadfQ.js.map