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

package/dist/runtime.cjs

@@ -1,129 +1,413 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_viewport = require("./viewport-BWeNHZmb.cjs");
-const require_derive = require("./derive-BbsDk_Kz.cjs");
-const require_format = require("./format-D_epWlob.cjs");
-const require_resolver = require("./resolver-CYVNV4hn.cjs");
-const require_AbortError = require("./AbortError-P0RU0Mgg.cjs");
-//#region src/promise/AbortablePromise.ts
-let _Symbol$species;
-_Symbol$species = Symbol.species;
+const require_Change = require("./Change-Ct-dB8D5.cjs");
+const require_calibrate = require("./calibrate-DJbi1wuK.cjs");
+const require_value = require("./value-BFS1R8ek.cjs");
+const require_resolveAnnotationDraft = require("./resolveAnnotationDraft-7Ke4nV7F.cjs");
+const require_format = require("./format-Bp3QFSH1.cjs");
+const require_authority = require("./authority-BFp6XM04.cjs");
+const require_resolver = require("./resolver-BWSWSF6R.cjs");
+const require_viewport = require("./viewport-CHG9qQUb.cjs");
+const require_charmap = require("./charmap-aYlefQP9.cjs");
+const require_subtype = require("./subtype-aDt5TFmK.cjs");
+const require_pageRefs = require("./pageRefs-B3ur7Ckm.cjs");
+const require_PageInsertBlankInput = require("./PageInsertBlankInput-CXHAM7l6.cjs");
+const require_builders = require("./builders-DgTAj_tP.cjs");
+const require_LocalDocumentHandle = require("./LocalDocumentHandle-D02FMm-Z.cjs");
+const require_DocumentRenderService = require("./DocumentRenderService-9IjSQEIU.cjs");
+//#region src/events/DocumentEventStream.ts
 /**
-* Awaitable Promise subclass with abort and progress.
-*
-* Symbol.species returns plain Promise so chained .then/.catch/.finally
-* return regular promises and never try to synthesize a new
-* AbortablePromise (which would have no executor).
+* `on(type, listener)` built on a stream's `subscribe`, so both engines
+* filter the same way and a type listener counts as a subscriber (the cloud
+* opens its live stream for the first one).
+*/
+function subscribeToType(subscribe, type, listener) {
+	return subscribe((event) => {
+		if (event.type === type) listener(event);
+	});
+}
+//#endregion
+//#region src/events/EventHub.ts
+/**
+* The in-process implementation of `DocumentEventStream`, shared by both
+* engine shells (one hub per open `DocumentHandle`). The engine that
+* performs a mutation publishes here at confirmation time; the cloud
+* engine's remote channel will also publish here for other sessions'
+* mutations — listeners never learn which transport delivered an event.
 *
-* Settlement contract:
-*   - The first settlement wins. resolve/reject handed to the executor
-*     are wrapped so that any subsequent call (whether by the executor,
-*     by abort(), or by both racing) becomes a silent no-op.
-*   - abort() rejects the public promise with AbortError immediately,
-*     even if the executor never observes the AbortSignal. The executor
-*     still receives the AbortSignal so it can stop real work
-*     cooperatively (release a queue slot, abort fetch, post a worker
-*     abort, etc.). Anything the executor does after that — including
-*     a late resolve(value), a late reject(error), or a rejected inner
-*     Promise inside AbortablePromise.run — is dropped silently.
-*   - abort() after settlement is a no-op.
+* Delivery contract:
+*   - synchronous fan-out in subscription order;
+*   - error isolation: a throwing listener is re-thrown on a microtask
+*     (so it surfaces to the host's unhandled-error reporting) without
+*     blocking other listeners or failing the mutation path;
+*   - `lastServerId` tracks the highest remote cursor seen, for the
+*     remote channel's reconnect/backfill.
 */
-var AbortablePromise = class AbortablePromise extends Promise {
-	static get [_Symbol$species]() {
-		return Promise;
-	}
-	constructor(executor) {
-		const ctrl = new AbortController();
-		const progressCbs = /* @__PURE__ */ new Set();
-		const state = { settled: false };
-		let capturedReject;
-		super((resolve, reject) => {
-			capturedReject = reject;
-			const wrappedResolve = (value) => {
-				if (state.settled) return;
-				state.settled = true;
-				resolve(value);
-			};
-			const wrappedReject = (reason) => {
-				if (state.settled) return;
-				state.settled = true;
-				reject(reason);
-			};
-			const progress = (p) => {
-				if (state.settled) return;
-				for (const cb of progressCbs) try {
-					cb(p);
-				} catch {}
-			};
-			executor(wrappedResolve, wrappedReject, progress, ctrl.signal);
+var EventHub = class {
+	constructor(onListenerError = (err) => {
+		queueMicrotask(() => {
+			throw err;
 		});
-		require_derive._defineProperty(this, "signal", void 0);
-		require_derive._defineProperty(this, "_ctrl", void 0);
-		require_derive._defineProperty(this, "_progressCbs", void 0);
-		require_derive._defineProperty(this, "_state", void 0);
-		require_derive._defineProperty(this, "_internalReject", void 0);
-		this._ctrl = ctrl;
-		this.signal = ctrl.signal;
-		this._progressCbs = progressCbs;
-		this._state = state;
-		this._internalReject = capturedReject;
-	}
-	/**
-	* Abort the underlying operation.
-	*
-	* - If the promise has already settled, this is a no-op.
-	* - Otherwise the public promise rejects synchronously with an
-	*   AbortError (wrapping the supplied reason if it is not already an
-	*   AbortError) and the AbortSignal fires for any cooperative
-	*   cancellation the executor wired up.
-	*/
-	abort(reason) {
-		if (this._state.settled) return;
-		if (this._ctrl.signal.aborted) return;
-		const err = reason instanceof require_AbortError.AbortError ? reason : new require_AbortError.AbortError(reason);
-		this._state.settled = true;
-		this._ctrl.abort(err);
-		this._internalReject(err);
+	}) {
+		this.onListenerError = onListenerError;
+		require_format._defineProperty(this, "listeners", /* @__PURE__ */ new Set());
+		require_format._defineProperty(this, "serverId", null);
 	}
-	/**
-	* Subscribe to progress events. Returns an unsubscribe function.
-	*/
-	onProgress(cb) {
-		this._progressCbs.add(cb);
+	subscribe(listener) {
+		this.listeners.add(listener);
 		return () => {
-			this._progressCbs.delete(cb);
+			this.listeners.delete(listener);
 		};
 	}
-	/**
-	* Wrap a value in an already-resolved AbortablePromise. Mirrors Promise.resolve.
-	*/
-	static resolveValue(value) {
-		return new AbortablePromise((resolve) => resolve(value));
+	on(type, listener) {
+		return subscribeToType((all) => this.subscribe(all), type, listener);
+	}
+	publish(event) {
+		if ("origin" in event) {
+			const { serverId } = event.origin;
+			if (serverId !== null) this.serverId = this.serverId === null ? serverId : Math.max(this.serverId, serverId);
+		}
+		for (const listener of [...this.listeners]) try {
+			listener(event);
+		} catch (err) {
+			this.onListenerError(err);
+		}
+	}
+	lastServerId() {
+		return this.serverId;
+	}
+	/** Drop every listener (handle close). Idempotent. */
+	clear() {
+		this.listeners.clear();
+	}
+};
+/**
+* Stamps provenance onto events a mutation path produces. One per open
+* handle: the engine shell constructs it with the instance's `sessionId`
+* (and, on cloud, the authenticated `sub` when known) and hands it to the
+* mutation services — they publish results, never build origins.
+*/
+var SessionEventPublisher = class {
+	constructor(hub, sessionId, sub = null) {
+		this.hub = hub;
+		this.sessionId = sessionId;
+		this.sub = sub;
 	}
 	/**
-	* Wrap a thrown reason in an already-rejected AbortablePromise.
+	* Publish what one write of this session just committed: one
+	* event per fact, in order, all carrying the write's `opId` as
+	* `origin.tx`.
 	*/
-	static rejectReason(reason) {
-		return new AbortablePromise((_resolve, reject) => reject(reason));
+	publishWrite(opId, ...events) {
+		this.publishChange(opId, events);
 	}
 	/**
-	* Run an async function as an AbortablePromise so callers get .abort() and .signal.
-	* The async function receives the AbortSignal (and a progress emitter) so it can
-	* cooperate with the abort.
-	*
-	* If abort() fires while the inner async function is still running, the
-	* public promise rejects with AbortError immediately. The inner async
-	* function's eventual settlement (resolve or reject) is funneled through
-	* the wrapped settlers and silently dropped — including a late rejection
-	* from the underlying work, which prevents an UnhandledRejection because
-	* the .then(resolve, reject) below "handles" it via the no-op.
+	* Publish what one change committed: its events as {@link publishWrite}
+	* does, and for an undo, the `opId` of the change it undid.
 	*/
-	static run(fn) {
-		return new AbortablePromise((resolve, reject, progress, signal) => {
-			fn(signal, progress).then(resolve, reject);
+	publishChange(opId, events, undoOf) {
+		const ts = Date.now();
+		events.forEach((event, index) => {
+			this.hub.publish({
+				...event,
+				origin: {
+					kind: "local",
+					sessionId: this.sessionId,
+					sub: this.sub,
+					ts,
+					serverId: null,
+					tx: {
+						id: opId,
+						index,
+						count: events.length
+					},
+					...undoOf !== void 0 ? { undoOf } : {}
+				}
+			});
 		});
 	}
 };
 //#endregion
+//#region src/events/changeEvents.ts
+/**
+* The events a change publishes: each op's events as its single verb
+* publishes them, in op order. An op an undo left alone entirely publishes
+* nothing. The publisher stamps them all with the change's `opId`.
+*/
+function changeEvents(result) {
+	return result.items.flatMap(itemEvents);
+}
+function itemEvents(item) {
+	if (require_Change.isSkippedItem(item)) return [];
+	switch (item.type) {
+		case "annotations.create": {
+			const { type: _type, ...result } = item;
+			return [{
+				type: "annotations.created",
+				...result
+			}];
+		}
+		case "annotations.update": {
+			const { type: _type, skipped: _skipped, ...result } = item;
+			return [{
+				type: "annotations.updated",
+				...result
+			}];
+		}
+		case "annotations.delete": {
+			const { type: _type, ...result } = item;
+			return [{
+				type: "annotations.deleted",
+				deleted: require_authority.deletedAnnotationsOf(result),
+				...result
+			}];
+		}
+		case "annotations.reorder": {
+			const { type: _type, ...result } = item;
+			return [{
+				type: "annotations.reordered",
+				...result
+			}];
+		}
+		case "annotations.restore": {
+			const { type: _type, ...result } = item;
+			return [{
+				type: "annotations.restored",
+				...result
+			}];
+		}
+		case "annotations.import": {
+			const { type: _type, ...result } = item;
+			return require_authority.annotationImportFacts(result).map((fact) => ({
+				type: "annotations.created",
+				...fact
+			}));
+		}
+		case "forms.import": {
+			const { type: _type, ...result } = item;
+			return require_value.formImportFacts(result).map((fact) => ({
+				type: "forms.created",
+				...fact
+			}));
+		}
+		case "forms.importValues": {
+			const { type: _type, ...result } = item;
+			return require_value.formValuesImportFacts(result).map((fact) => ({
+				type: "forms.valueSet",
+				...fact
+			}));
+		}
+		case "forms.setValue": {
+			const { type: _type, ...result } = item;
+			return [{
+				type: "forms.valueSet",
+				...result
+			}];
+		}
+		case "forms.reset": {
+			const { type: _type, skipped: _skipped, ...result } = item;
+			return require_value.formResetFacts(result).map((fact) => ({
+				type: "forms.valueSet",
+				...fact
+			}));
+		}
+		case "forms.setDisplay":
+		case "forms.setAppearanceText":
+		case "forms.setSignatureAppearance": {
+			const { type: _type, ...result } = item;
+			return [{
+				type: "forms.updated",
+				...result
+			}];
+		}
+		case "forms.update": {
+			const { type: _type, skipped: _skipped, ...result } = item;
+			return [{
+				type: "forms.updated",
+				...result
+			}];
+		}
+		case "forms.create": {
+			const { type: _type, ...result } = item;
+			return [{
+				type: "forms.created",
+				...result
+			}];
+		}
+		case "forms.delete": {
+			const { type: _type, ...result } = item;
+			return [{
+				type: "forms.deleted",
+				deleted: require_value.deletedFieldOf(result),
+				...result
+			}];
+		}
+		case "forms.restore": {
+			const { type: _type, ...result } = item;
+			return [{
+				type: "forms.restored",
+				...result
+			}];
+		}
+		case "forms.addWidget": {
+			const { type: _type, ...result } = item;
+			return [{
+				type: "forms.widgetAdded",
+				...result
+			}];
+		}
+		case "forms.removeWidget": {
+			const { type: _type, ...result } = item;
+			return [{
+				type: "forms.widgetRemoved",
+				...result
+			}];
+		}
+		case "forms.deleteWidget": {
+			const { type: _type, ...result } = item;
+			return [{
+				type: "forms.widgetDeleted",
+				...result
+			}];
+		}
+		case "forms.restoreWidget": {
+			const { type: _type, ...result } = item;
+			return [{
+				type: "forms.widgetRestored",
+				...result
+			}];
+		}
+		case "forms.reorderWidgets": {
+			const { type: _type, ...result } = item;
+			return [{
+				type: "forms.widgetsReordered",
+				...result
+			}];
+		}
+		case "forms.reorderCalculations": {
+			const { type: _type, ...result } = item;
+			return [{
+				type: "forms.calculationsReordered",
+				...result
+			}];
+		}
+		case "forms.updateWidget": {
+			const { type: _type, skipped: _skipped, ...result } = item;
+			return [{
+				type: "forms.widgetUpdated",
+				...result
+			}];
+		}
+		case "metadata.update": {
+			const { type: _type, skipped: _skipped, ...result } = item;
+			return [{
+				type: "metadata.updated",
+				...result
+			}];
+		}
+		case "metadata.updateCustom": {
+			const { type: _type, skipped: _skipped, ...result } = item;
+			return [{
+				type: "metadata.customUpdated",
+				...result
+			}];
+		}
+		case "outline.create": {
+			const { type: _type, ...result } = item;
+			return [{
+				type: "outline.created",
+				...result
+			}];
+		}
+		case "outline.update": {
+			const { type: _type, skipped: _skipped, ...result } = item;
+			return [{
+				type: "outline.updated",
+				...result
+			}];
+		}
+		case "outline.move": {
+			const { type: _type, ...result } = item;
+			return [{
+				type: "outline.moved",
+				...result
+			}];
+		}
+		case "outline.delete": {
+			const { type: _type, ...result } = item;
+			return [{
+				type: "outline.deleted",
+				deleted: require_authority.deletedOutlineItemsOf(result),
+				...result
+			}];
+		}
+		case "outline.restore": {
+			const { type: _type, ...result } = item;
+			return [{
+				type: "outline.restored",
+				...result
+			}];
+		}
+		case "pages.rotate": {
+			const { type: _type, ...result } = item;
+			return [{
+				type: "pages.rotated",
+				...result
+			}];
+		}
+		case "pages.reorder": {
+			const { type: _type, ...result } = item;
+			return [{
+				type: "pages.reordered",
+				...result
+			}];
+		}
+		case "pages.delete": {
+			const { type: _type, ...result } = item;
+			return [{
+				type: "pages.deleted",
+				...result
+			}];
+		}
+		case "pages.insertBlank":
+		case "pages.insert": {
+			const { type: _type, ...result } = item;
+			return [{
+				type: "pages.inserted",
+				...result
+			}];
+		}
+		case "pages.restore": {
+			const { type: _type, ...result } = item;
+			return [{
+				type: "pages.restored",
+				...result
+			}];
+		}
+		case "attachments.create": {
+			const { type: _type, ...result } = item;
+			return [{
+				type: "attachments.created",
+				...result
+			}];
+		}
+		case "attachments.delete": {
+			const { type: _type, ...result } = item;
+			return [{
+				type: "attachments.deleted",
+				deleted: require_Change.deletedAttachmentOf(result),
+				...result
+			}];
+		}
+		case "attachments.restore": {
+			const { type: _type, ...result } = item;
+			return [{
+				type: "attachments.restored",
+				...result
+			}];
+		}
+	}
+}
+//#endregion
 //#region src/engine/document-security-state.ts
 function securityStateFromHead(head) {
 	return {
@@ -169,20 +453,20 @@ function permissionInfoWithAdvisory(info, pdfBits) {
 }
 /**
 * Translate a {@link PdfBits} view into the capability-shaped
-* {@link PdfPermissionAdvisory}. The rules here MUST mirror the bit
-* combinations the scope resolver uses for `pdf.permissions`
-* expansion — `doc.print.high` requires bit 12 AND bit 3, etc.
+* {@link PdfPermissionAdvisory}: what `pdf.permissions` grants on a file
+* with these bits.
 */
 function advisoryFromPdfBits(b) {
+	const granted = new Set(require_builders.materializePdfPermissions(b));
 	return {
-		canPrint: b.bit3,
-		canPrintHigh: b.bit12 && b.bit3,
-		canCopy: b.bit5,
-		canAnnotate: b.bit6,
-		canFillForms: b.bit6 || b.bit9,
-		canModifyForms: b.bit6 && b.bit4,
-		canModifyPages: b.bit4,
-		canAssemble: b.bit11
+		canPrint: granted.has("doc.print"),
+		canPrintHigh: granted.has("doc.print.high"),
+		canCopy: granted.has("doc.text.copy"),
+		canAnnotate: granted.has("doc.annotate.modify"),
+		canFillForms: granted.has("doc.forms.fill"),
+		canModifyForms: granted.has("doc.forms.modify"),
+		canModifyPages: granted.has("doc.pages.modify"),
+		canAssemble: granted.has("doc.pages.assemble")
 	};
 }
 function securityStateFromProbe(info, opts = {}) {
@@ -212,68 +496,95 @@ function securityStateFromProbe(info, opts = {}) {
 	};
 }
 //#endregion
-//#region src/engine/DocumentRenderService.ts
-const CONTINUOUS_RENDER_POLICY = { kind: "continuous" };
+//#region src/scheduling/place.ts
+const PLACE_ORDER = {
+	elsewhere: 0,
+	near: 1,
+	visible: 2
+};
+/** More device pixels than any screen shows, so pixels never outweigh the rest of a rank. */
+const PIXEL_SPAN = 2 ** 40;
+const ELSEWHERE = {
+	place: "elsewhere",
+	pixels: 0
+};
+const ON_SCREEN = {
+	place: "visible",
+	pixels: 0
+};
+/** Whether `a` is the better place: on screen before near before elsewhere, then more pixels. */
+function placedBefore(a, b) {
+	const order = PLACE_ORDER[a.place] - PLACE_ORDER[b.place];
+	return order !== 0 ? order > 0 : a.pixels > b.pixels;
+}
 /**
-* Conform a FULL-PAGE viewport to a render policy — the ONE snap
-* implementation, shared by every engine and plugin. Pure and explicit
-* by design:
-*
-* - `continuous` → identity (local/cloud plugin code stays byte-identical).
-* - `lattice` → returns a `width`-kind viewport at the smallest ladder
-*   width ≥ the requested detail (snap UP: always crisp, CSS downscales
-*   for free), capped at the largest width — detail beyond the cap is the
-*   tile pyramid's job, by design.
-* - `scale`-kind requests convert through the page's width in PDF user
-*   units — pass `opts.pageWidth` (the caller has it from the layout);
-*   omitting it for a scale viewport under a lattice policy is a
-*   programmer error and throws `InvalidArg`.
+* A job's place in one view: its page's role there, except that a part of a
+* visible page that's off screen (a tile of the ring around what shows) is
+* `near`.
 */
-function snapFullPageViewport(policy, viewport, opts) {
-	if (policy.kind === "continuous") return viewport;
-	if (policy.fullPage.widths.length === 0) throw new require_derive.EngineError(require_format.EngineErrorCode.InvalidArg, "render policy has an empty width ladder");
-	const widths = [...policy.fullPage.widths].sort((a, b) => a - b);
-	let requested;
-	if (viewport.kind === "width") requested = viewport.width;
-	else {
-		const pageWidth = opts?.pageWidth;
-		if (pageWidth === void 0 || pageWidth <= 0) throw new require_derive.EngineError(require_format.EngineErrorCode.InvalidArg, "snapping a scale viewport to a width lattice requires opts.pageWidth");
-		requested = (viewport.scale ?? 1) * pageWidth;
-	}
+function placeIn(entry, job) {
+	if (!entry) return ELSEWHERE;
+	if (entry.role === "near") return {
+		place: "near",
+		pixels: 0
+	};
+	if (job.region && entry.visible && !overlaps(job.region, entry.visible)) return {
+		place: "near",
+		pixels: 0
+	};
 	return {
-		kind: "width",
-		width: widths.find((width) => width >= requested) ?? widths[widths.length - 1]
+		place: "visible",
+		pixels: entry.pixels
 	};
 }
 /**
-* Conform an annotation-appearance scale to the policy's appearance
-* lattice. Same discipline as {@link snapFullPageViewport}: identity on
-* continuous (and when the policy carries no appearance block), snap UP,
-* cap at the largest point. Callers derive `scale` from the page's
-* effective render scale (`snappedWidth / pageWidth`, × devicePixelRatio
-* as needed) so composites stay crisp against the page raster.
+* A job's place among a document's views: in the view it serves, or, when it
+* serves none (or one that said nothing), the best place its page has in any
+* view. A job about the whole document serves what's shown, so it counts as
+* on screen. While no view says anything, every job is on screen alike, and
+* jobs run in the order they were asked.
 */
-function snapAppearanceScale(policy, scale) {
-	if (policy.kind === "continuous" || policy.appearances === void 0) return scale;
-	if (policy.appearances.scales.length === 0) throw new require_derive.EngineError(require_format.EngineErrorCode.InvalidArg, "render policy has an empty appearance-scale lattice");
-	const scales = [...policy.appearances.scales].sort((a, b) => a - b);
-	return scales.find((s) => s >= scale) ?? scales[scales.length - 1];
+function placeFor(job, views) {
+	if (views.size === 0 || !job.page) return ON_SCREEN;
+	const objectNumber = job.page.objectNumber;
+	const served = job.view === void 0 ? void 0 : views.get(job.view);
+	if (served) return placeIn(served.get(objectNumber), job);
+	let best = ELSEWHERE;
+	for (const pages of views.values()) {
+		const placed = placeIn(pages.get(objectNumber), job);
+		if (placedBefore(placed, best)) best = placed;
+	}
+	return best;
 }
 /**
-* Conform a tile-pyramid scale to the policy's tile lattice — the third
-* member of the `snap<PolicyBlock><Quantity>` family. Identity on
-* continuous and while the deployment doesn't advertise a `tiles` block
-* (the block is reserved until the deep-zoom vertical ships server-side;
-* the tiling client uses its own default pyramid then — see
-* plugin-render). Snap UP, cap at the largest scale: per-tile cost is
-* constant by construction (`tileSize²` pixels regardless of level), so
-* the cap bounds artifact COUNT, not memory.
+* How soon a job runs among those that may run: higher first. It compares, in
+* turn:
+* 1. background last: a `low` call is about nothing the views show;
+* 2. where its page is: on screen, then just off it, then elsewhere;
+* 3. its priority: `high` (the picture of the page itself) before `auto`;
+* 4. a whole page before a part of one: a tile is only of use once its page
+*    is there;
+* 5. the device pixels its page shows.
+* Equal ranks run in the order they were asked, so a caller sequences its own work.
 */
-function snapTileScale(policy, scale) {
-	if (policy.kind === "continuous" || policy.tiles === void 0) return scale;
-	if (policy.tiles.scales.length === 0) throw new require_derive.EngineError(require_format.EngineErrorCode.InvalidArg, "render policy has an empty tile-scale lattice");
-	const scales = [...policy.tiles.scales].sort((a, b) => a - b);
-	return scales.find((s) => s >= scale) ?? scales[scales.length - 1];
+function rank(job, placed) {
+	let level = job.priority === "low" ? 0 : 1;
+	level = level * 3 + PLACE_ORDER[placed.place];
+	level = level * 2 + (job.priority === "high" ? 1 : 0);
+	level = level * 2 + (job.region ? 0 : 1);
+	return level * PIXEL_SPAN + Math.min(PIXEL_SPAN - 1, Math.round(placed.pixels));
+}
+/**
+* Whether rank `a` beats rank `b` on more than pixels (any of the first four
+* steps of {@link rank}). A running job gives way only to a job that clearly
+* outranks it, so two pages on screen never stop each other's work, and jobs
+* don't flip back and forth while the camera moves.
+*/
+function clearlyOutranks(a, b) {
+	return Math.floor(a / PIXEL_SPAN) > Math.floor(b / PIXEL_SPAN);
+}
+function overlaps(a, b) {
+	return a.x < b.x + b.width && b.x < a.x + a.width && a.y < b.y + b.height && b.y < a.y + a.height;
 }
 //#endregion
 //#region src/engine/passwordPrompt.ts
@@ -281,7 +592,7 @@ function snapTileScale(policy, scale) {
 * Derive the high-level password prompt from the raw security state.
 *
 * The function is pure and total — every `DocumentSecurityState`
-* maps to exactly one `PasswordPrompt`. Use this as the SINGLE source
+* maps to exactly one `PasswordPrompt`. Use this as the single source
 * of truth wherever the SDK exposes a "do you need a password?" flag:
 * both `LocalDocumentSecurityService` and `CloudDocumentSecurityService`
 * call it, so the contract can never drift.
@@ -311,15 +622,17 @@ function snapTileScale(policy, scale) {
 *
 *   6. fallthrough → { state: 'none' }   open and nothing more available
 */
-function passwordPromptFromState(state) {
+function passwordPromptFromState(state, incorrect = false) {
 	if (state.encryption.state === "none") return { state: "none" };
 	if (!state.permissions.known) return {
 		state: "required",
-		hint: null
+		hint: null,
+		incorrect
 	};
 	if (state.encryption.requiresPassword && state.permissions.openedAs === "none") return {
 		state: "required",
-		hint: "user"
+		hint: "user",
+		incorrect
 	};
 	if (state.permissions.openedAs === "owner") return { state: "none" };
 	if (state.permissions.canUpgradeToOwner) return {
@@ -329,6 +642,150 @@ function passwordPromptFromState(state) {
 	return { state: "none" };
 }
 //#endregion
+//#region src/engine/attachmentVerbs.ts
+/**
+* `doc.attachments` on any engine: the reads `rest` holds (`list`,
+* `download`), and each write as a one-op change through `apply`, so a verb
+* has its op's checks, events and undo (its `opId` undoes it) and answers as
+* its single verb did.
+*/
+function attachmentVerbs(rest, apply) {
+	const one = (op, type, options, answer) => require_viewport.AbortablePromise.run(async (signal) => {
+		const item = (await apply({ ops: [await op()] }, options?.opId === void 0 ? {} : { opId: options.opId }).abortWith(signal)).items[0];
+		if (!item || item.type !== type) throw new require_format.EngineError(require_format.EngineErrorCode.Unknown, `${type} wrote nothing`);
+		return answer(item);
+	});
+	return {
+		list: () => rest.list(),
+		download: (ref) => rest.download(ref),
+		create: (file, options) => one(async () => {
+			const { wireFile, resource } = await require_authority.normalizeAttachmentFileSource(file, "file");
+			const { resources: _resources, ...metadata } = wireFile;
+			return {
+				type: "attachments.create",
+				file: metadata,
+				resources: { file: new Uint8Array(resource.bytes) }
+			};
+		}, "attachments.create", options, (item) => ({
+			attachment: item.attachment,
+			meta: item.meta
+		})),
+		delete: (ref, options) => one(async () => ({
+			type: "attachments.delete",
+			ref
+		}), "attachments.delete", options, (item) => ({ meta: item.meta }))
+	};
+}
+//#endregion
+//#region src/engine/outlineVerbs.ts
+/**
+* `doc.outline` on any engine: its read, and each verb as a one-op change
+* through `apply`, so a verb has its op's checks, events and undo (its
+* `opId` undoes it) and answers with the op's item.
+*/
+function outlineVerbs(get, apply) {
+	const one = (op, options) => require_viewport.AbortablePromise.run(async (signal) => {
+		const result = await apply({ ops: [op] }, options?.opId === void 0 ? {} : { opId: options.opId }).abortWith(signal);
+		const type = op.type;
+		const item = result.items[0];
+		if (!item || item.type !== type) throw new require_format.EngineError(require_format.EngineErrorCode.Unknown, `${type} wrote nothing`);
+		const { type: _type, skipped: _skipped, ...answer } = item;
+		return answer;
+	});
+	return {
+		get,
+		create: (data, options) => one({
+			type: "outline.create",
+			parent: options?.parent ?? null,
+			data,
+			...options?.position === void 0 ? {} : { position: options.position },
+			...options?.objectNumber === void 0 ? {} : { objectNumber: options.objectNumber }
+		}, options),
+		update: (ref, patch, options) => one({
+			type: "outline.update",
+			ref,
+			patch
+		}, options),
+		move: (refs, parent, position, options) => one({
+			type: "outline.move",
+			refs,
+			parent,
+			position
+		}, options),
+		delete: (ref, options) => one({
+			type: "outline.delete",
+			ref
+		}, options)
+	};
+}
+//#endregion
+//#region src/engine/pageVerbs.ts
+/**
+* `doc.pages` on any engine: what `rest` holds (the reads, extract, flatten
+* and the page names), and each structure verb as a one-op change through
+* `apply`, so a verb has its op's checks, events and undo (its `opId` undoes
+* it) and answers as its single verb did.
+*/
+function pageVerbs(rest, apply) {
+	const one = (op, options, answer) => require_viewport.AbortablePromise.run(async (signal) => {
+		const result = await apply({ ops: [op] }, options?.opId === void 0 ? {} : { opId: options.opId }).abortWith(signal);
+		const type = op.type;
+		const item = result.items[0];
+		if (!item || item.type !== type) throw new require_format.EngineError(require_format.EngineErrorCode.Unknown, `${type} wrote nothing`);
+		return answer(item);
+	});
+	return {
+		list: () => rest.list(),
+		setName: (input, options) => rest.setName(input, options),
+		removeName: (input, options) => rest.removeName(input, options),
+		flatten: (pages, options) => rest.flatten(pages, options),
+		extract: (pages, options) => rest.extract(pages, options),
+		reorder: (pages, position, options) => one({
+			type: "pages.reorder",
+			pages,
+			position
+		}, options, (item) => ({
+			pages: item.pages,
+			layout: item.layout,
+			meta: item.meta
+		})),
+		rotate: (pages, rotation, options) => one({
+			type: "pages.rotate",
+			pages,
+			rotation
+		}, options, (item) => ({
+			layout: item.layout,
+			meta: item.meta
+		})),
+		delete: (pages, options) => one({
+			type: "pages.delete",
+			pages
+		}, options, (item) => ({
+			layout: item.layout,
+			meta: item.meta
+		})),
+		insert: (bytes, position, options) => one({
+			type: "pages.insert",
+			source: bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes),
+			...position === void 0 ? {} : { position }
+		}, options, (item) => ({
+			insertedPages: item.insertedPages,
+			layout: item.layout,
+			meta: item.meta
+		})),
+		insertBlank: (spec, position, options) => one({
+			type: "pages.insertBlank",
+			spec,
+			...position === void 0 ? {} : { position },
+			...options?.objectNumbers === void 0 ? {} : { objectNumbers: options.objectNumbers }
+		}, options, (item) => ({
+			insertedPages: item.insertedPages,
+			layout: item.layout,
+			meta: item.meta
+		}))
+	};
+}
+//#endregion
 //#region src/wire/WirePack.ts
 /**
 * Singleton empty transfer list. Frozen so accidental in-place
@@ -341,10 +798,8 @@ const EMPTY_TRANSFER = Object.freeze([]);
 *
 * The `transfer` argument is optional; omitting it (or passing `[]`)
 * is the explicit, type-checked way to say "I declare this message
-* carries no transferables." That's structurally identical to the
-* shape the v2 walker generated for non-binary messages, but here
-* the declaration is at construction time, in the producer's own
-* code, where the knowledge actually lives.
+* carries no transferables." The declaration is made at construction
+* time, in the producer's own code, where the knowledge actually lives.
 *
 *   wirePack({ kind: 'metadata.read', jobId, docId })
 *   wirePack({ kind: 'open.fatMem', jobId, docId, bytes }, [bytes])
@@ -357,165 +812,399 @@ function wirePack(payload, transfer = EMPTY_TRANSFER) {
 	};
 }
 //#endregion
-exports.ANNOTATION_SUBTYPES = require_format.ANNOTATION_SUBTYPES;
-exports.AbortError = require_AbortError.AbortError;
-exports.AbortablePromise = AbortablePromise;
-exports.CONTINUOUS_RENDER_POLICY = CONTINUOUS_RENDER_POLICY;
-exports.DEFAULT_EDGE_RESOLVER_BUDGET = require_viewport.DEFAULT_EDGE_RESOLVER_BUDGET;
-exports.DEFAULT_PDF_SAVE_MODE = require_viewport.DEFAULT_PDF_SAVE_MODE;
+exports.ANNOTATION_APPEARANCE_MODES = require_charmap.ANNOTATION_APPEARANCE_MODES;
+exports.ANNOTATION_DEFAULTS = require_calibrate.ANNOTATION_DEFAULTS;
+exports.ANNOTATION_FIELD_NAMES = require_resolveAnnotationDraft.ANNOTATION_FIELD_NAMES;
+exports.ANNOTATION_FIELD_SPACES = require_resolveAnnotationDraft.ANNOTATION_FIELD_SPACES;
+exports.ANNOTATION_RESOURCE_ROLES = require_resolveAnnotationDraft.ANNOTATION_RESOURCE_ROLES;
+exports.ANNOTATION_RESOURCE_ROLE_NAMES = require_calibrate.ANNOTATION_RESOURCE_ROLE_NAMES;
+exports.ANNOTATION_SUBTYPES = require_subtype.ANNOTATION_SUBTYPES;
+exports.ATTACHMENT_LIMITS = require_calibrate.ATTACHMENT_LIMITS;
+exports.AbortError = require_calibrate.AbortError;
+exports.AbortablePromise = require_viewport.AbortablePromise;
+exports.AnnotationTransfer = require_calibrate.AnnotationTransfer;
+exports.CONTINUOUS_RENDER_POLICY = require_DocumentRenderService.CONTINUOUS_RENDER_POLICY;
+exports.DEFAULT_BUNDLE_LIMITS = require_calibrate.DEFAULT_BUNDLE_LIMITS;
+exports.DEFAULT_EDGE_RESOLVER_BUDGET = require_authority.DEFAULT_EDGE_RESOLVER_BUDGET;
+exports.DEFAULT_MEDIA_BOX = require_authority.DEFAULT_MEDIA_BOX;
+exports.DEFAULT_PDF_SAVE_MODE = require_authority.DEFAULT_PDF_SAVE_MODE;
+exports.DEFAULT_RICH_TEXT_BODY = require_resolveAnnotationDraft.DEFAULT_RICH_TEXT_BODY;
+exports.DRAWN_RECT_KINDS = require_resolveAnnotationDraft.DRAWN_RECT_KINDS;
 exports.EMPTY_TRANSFER = EMPTY_TRANSFER;
-exports.EdgeResolver = require_viewport.EdgeResolver;
-exports.EngineError = require_derive.EngineError;
+exports.EdgeResolver = require_authority.EdgeResolver;
+exports.EngineError = require_format.EngineError;
 exports.EngineErrorCode = require_format.EngineErrorCode;
+exports.EventHub = EventHub;
+exports.FormTransfer = require_viewport.FormTransfer;
 exports.InvalidScope = require_resolver.InvalidScope;
-exports.METRES = require_derive.METRES;
+exports.LOCAL_ENGINE_BRAND = require_LocalDocumentHandle.LOCAL_ENGINE_BRAND;
+exports.METRES = require_calibrate.METRES;
 exports.MissingIdentity = require_resolver.MissingIdentity;
-exports.NO_ANNOTATION_FLAGS = require_viewport.NO_ANNOTATION_FLAGS;
-exports.PAGE_INSERT_BLANK_MAX_COUNT = require_format.PAGE_INSERT_BLANK_MAX_COUNT;
-exports.PDF_BITS = require_viewport.PDF_BITS;
-exports.PDF_CODE_TO_SUBTYPE = require_format.PDF_CODE_TO_SUBTYPE;
-exports.PDF_SUBTYPE_TO_CODE = require_format.PDF_SUBTYPE_TO_CODE;
-exports.PdfAnnotationSubtypeCode = require_format.PdfAnnotationSubtypeCode;
+exports.NO_ANNOTATION_FLAGS = require_format.NO_ANNOTATION_FLAGS;
+exports.OBJECT_NUMBER_CEILING = require_viewport.OBJECT_NUMBER_CEILING;
+exports.OBJECT_NUMBER_ISSUE_LIMIT = require_viewport.OBJECT_NUMBER_ISSUE_LIMIT;
+exports.OUTLINE_READ_LIMITS = require_Change.OUTLINE_READ_LIMITS;
+exports.PAGE_INSERT_BLANK_MAX_COUNT = require_PageInsertBlankInput.PAGE_INSERT_BLANK_MAX_COUNT;
+exports.PDF_BITS = require_authority.PDF_BITS;
+exports.PDF_CODE_TO_SUBTYPE = require_subtype.PDF_CODE_TO_SUBTYPE;
+exports.PDF_SUBTYPE_TO_CODE = require_subtype.PDF_SUBTYPE_TO_CODE;
+exports.PRINT_PAPER = require_calibrate.PRINT_PAPER;
+exports.PROTECTABLE_CAPABILITIES = require_resolver.PROTECTABLE_CAPABILITIES;
+exports.PdfAnnotationSubtypeCode = require_subtype.PdfAnnotationSubtypeCode;
 exports.PermissionDenied = require_resolver.PermissionDenied;
-exports.SEARCH_FOLD_VERSION = require_derive.SEARCH_FOLD_VERSION;
+exports.SEARCH_FOLD_VERSION = require_calibrate.SEARCH_FOLD_VERSION;
 exports.SEARCH_REGEX_MAX_LENGTH = require_viewport.SEARCH_REGEX_MAX_LENGTH;
-exports.SEARCH_SNIPPET_CONTEXT = require_viewport.SEARCH_SNIPPET_CONTEXT;
+exports.SEARCH_SNIPPET_CONTEXT = require_authority.SEARCH_SNIPPET_CONTEXT;
 exports.SIGNATURE_POLICY_VERSION = require_resolver.SIGNATURE_POLICY_VERSION;
-exports.UNKNOWN_WEAK_ANNOTATION_STATE = require_viewport.UNKNOWN_WEAK_ANNOTATION_STATE;
-exports.USAGE_INCOMPLETE = require_viewport.USAGE_INCOMPLETE;
+exports.STANDARD_FACES = require_resolveAnnotationDraft.STANDARD_FACES;
+exports.STANDARD_FONTS = require_format.STANDARD_FONTS;
+exports.SessionEventPublisher = SessionEventPublisher;
+exports.UNBAKED_KINDS = require_resolveAnnotationDraft.UNBAKED_KINDS;
+exports.USAGE_INCOMPLETE = require_authority.USAGE_INCOMPLETE;
+exports.WIDGET_ACTION_EVENTS = require_value.WIDGET_ACTION_EVENTS;
+exports.WIDGET_FLAG_NAMES = require_value.WIDGET_FLAG_NAMES;
+exports.actionTreeOf = require_calibrate.actionTreeOf;
+exports.actionWriteOf = require_value.actionWriteOf;
 exports.advisoryFromPdfBits = advisoryFromPdfBits;
-exports.appearanceImpactOf = require_viewport.appearanceImpactOf;
-exports.areaUnitLabel = require_derive.areaUnitLabel;
-exports.assertPdfFloat = require_derive.assertPdfFloat;
-exports.assertWritableMeasure = require_derive.assertWritableMeasure;
-exports.assessmentOf = require_viewport.assessmentOf;
-exports.boundaryTextOffset = require_format.boundaryTextOffset;
-exports.buildCommentThreads = require_viewport.buildCommentThreads;
-exports.buildPageTextLayout = require_viewport.buildPageTextLayout;
-exports.buildSnippet = require_viewport.buildSnippet;
-exports.buildThreads = require_derive.buildThreads;
-exports.canonicalSearchQuery = require_viewport.canonicalSearchQuery;
-exports.caps = require_viewport.caps;
-exports.changedKeys = require_viewport.changedKeys;
-exports.changesAnnotationList = require_viewport.changesAnnotationList;
-exports.charBoundaryAtTextOffset = require_format.charBoundaryAtTextOffset;
-exports.charMapViolation = require_format.charMapViolation;
-exports.charRangeForTextOffsets = require_format.charRangeForTextOffsets;
+exports.allowsCapability = require_authority.allowsCapability;
+exports.allowsFieldWrite = require_authority.allowsFieldWrite;
+exports.allowsSomeFieldWrite = require_authority.allowsSomeFieldWrite;
+exports.anchorOf = require_viewport.anchorOf;
+exports.annotationDefaultsOf = require_calibrate.annotationDefaultsOf;
+exports.annotationImportFacts = require_authority.annotationImportFacts;
+exports.annotationKey = require_format.annotationKey;
+exports.annotationOfDraft = require_calibrate.annotationOfDraft;
+exports.annotationPatchBetween = require_authority.annotationPatchBetween;
+exports.annotationResourceBuffers = require_calibrate.annotationResourceBuffers;
+exports.annotationWriteCapabilities = require_authority.annotationWriteCapabilities;
+exports.annotationWriteCapability = require_authority.annotationWriteCapability;
+exports.appearanceChangeOf = require_resolveAnnotationDraft.appearanceChangeOf;
+exports.appearanceImpactOf = require_resolveAnnotationDraft.appearanceImpactOf;
+exports.appearanceLatticeScale = require_DocumentRenderService.appearanceLatticeScale;
+exports.appearanceModesOf = require_charmap.appearanceModesOf;
+exports.appearanceTurnOf = require_calibrate.appearanceTurnOf;
+exports.applyAnnotationPatch = require_calibrate.applyAnnotationPatch;
+exports.areaUnitLabel = require_calibrate.areaUnitLabel;
+exports.assertAnnotationBundle = require_calibrate.assertAnnotationBundle;
+exports.assertAnnotationBundleManifest = require_calibrate.assertAnnotationBundleManifest;
+exports.assertAnnotationResources = require_calibrate.assertAnnotationResources;
+exports.assertChoiceDefault = require_Change.assertChoiceDefault;
+exports.assertDeclaredFields = require_resolveAnnotationDraft.assertDeclaredFields;
+exports.assertFormBundle = require_viewport.assertFormBundle;
+exports.assertFormBundleManifest = require_viewport.assertFormBundleManifest;
+exports.assertPdfFloat = require_resolveAnnotationDraft.assertPdfFloat;
+exports.assertRichTextAgreement = require_resolveAnnotationDraft.assertRichTextAgreement;
+exports.assertWithinLimit = require_calibrate.assertWithinLimit;
+exports.assertWritableMeasure = require_resolveAnnotationDraft.assertWritableMeasure;
+exports.assessmentOf = require_authority.assessmentOf;
+exports.attachmentVerbs = attachmentVerbs;
+exports.authorizeAnnotationCreate = require_authority.authorizeAnnotationCreate;
+exports.authorizeAnnotationDelete = require_authority.authorizeAnnotationDelete;
+exports.authorizeAnnotationUpdate = require_authority.authorizeAnnotationUpdate;
+exports.authorizeCapability = require_authority.authorizeCapability;
+exports.authorizeFieldGroup = require_authority.authorizeFieldGroup;
+exports.authorizeFieldWrite = require_authority.authorizeFieldWrite;
+exports.authorizeUnprotected = require_authority.authorizeUnprotected;
+exports.boundaryTextOffset = require_charmap.boundaryTextOffset;
+exports.buildCommentThreads = require_resolveAnnotationDraft.buildCommentThreads;
+exports.buildSnippet = require_authority.buildSnippet;
+exports.buildThreads = require_resolveAnnotationDraft.buildThreads;
+exports.bundleCodec = require_calibrate.bundleCodec;
+exports.bundlePageMapping = require_resolveAnnotationDraft.bundlePageMapping;
+exports.canonicalSearchQuery = require_authority.canonicalSearchQuery;
+exports.caps = require_builders.caps;
+exports.changeEvents = changeEvents;
+exports.changeFingerprint = require_authority.changeFingerprint;
+exports.changedKeys = require_authority.changedKeys;
+exports.charBoundaryAtTextOffset = require_charmap.charBoundaryAtTextOffset;
+exports.charMapViolation = require_charmap.charMapViolation;
+exports.charRangeForTextOffsets = require_charmap.charRangeForTextOffsets;
 exports.checkAnyCapability = require_resolver.checkAnyCapability;
+exports.checkAnyFieldAction = require_resolver.checkAnyFieldAction;
 exports.checkCapability = require_resolver.checkCapability;
 exports.checkCollab = require_resolver.checkCollab;
+exports.checkFieldAction = require_resolver.checkFieldAction;
+exports.checkImageQuality = require_authority.checkImageQuality;
+exports.checkRenderUsage = require_authority.checkRenderUsage;
 exports.checkSetGroup = require_resolver.checkSetGroup;
-exports.classifyRelation = require_derive.classifyRelation;
-exports.collab = require_viewport.collab;
-exports.combine = require_viewport.combine;
-exports.conclude = require_viewport.conclude;
-exports.createPageImageHandle = require_viewport.createPageImageHandle;
-exports.decodeFieldRefKey = require_viewport.decodeFieldRefKey;
-exports.decodePdfBits = require_viewport.decodePdfBits;
-exports.decodeStableIdKey = require_viewport.decodeStableIdKey;
-exports.decodeSubmitFormFlags = require_viewport.decodeSubmitFormFlags;
-exports.deriveMeasurementLabel = require_derive.deriveMeasurementLabel;
+exports.classifyRelation = require_resolveAnnotationDraft.classifyRelation;
+exports.clearlyOutranks = clearlyOutranks;
+exports.closeExportSelection = require_authority.closeExportSelection;
+exports.collab = require_builders.collab;
+exports.collabTargetOf = require_resolver.collabTargetOf;
+exports.colorOf = require_resolveAnnotationDraft.colorOf;
+exports.combine = require_authority.combine;
+exports.compareIsoDateTime = require_resolveAnnotationDraft.compareIsoDateTime;
+exports.concatAnnotationLists = require_authority.concatAnnotationLists;
+exports.conclude = require_authority.conclude;
+exports.createPageImageHandle = require_authority.createPageImageHandle;
+exports.createPdfTextLayout = require_calibrate.createPdfTextLayout;
+exports.createTextLayout = require_calibrate.createTextLayout;
+exports.decodeAnnotKey = require_resolver.decodeAnnotKey;
+exports.decodeFieldRefKey = require_format.decodeFieldRefKey;
+exports.decodePageKey = require_format.decodePageKey;
+exports.decodePdfBits = require_authority.decodePdfBits;
+exports.decodeSubmitFormFlags = require_value.decodeSubmitFormFlags;
+exports.defaultEntryOfDraft = require_Change.defaultEntryOfDraft;
+exports.deletedAnnotationsOf = require_authority.deletedAnnotationsOf;
+exports.deletedAttachmentOf = require_Change.deletedAttachmentOf;
+exports.deletedFieldOf = require_value.deletedFieldOf;
+exports.deletedOutlineItemsOf = require_authority.deletedOutlineItemsOf;
+exports.deletedWith = require_resolveAnnotationDraft.deletedWith;
+exports.deriveMeasurementLabel = require_resolveAnnotationDraft.deriveMeasurementLabel;
 exports.deriveProtection = require_resolver.deriveProtection;
-exports.deserializeError = require_derive.deserializeError;
-exports.dictEntries = require_viewport.dictEntries;
-exports.encodeFieldRefKey = require_viewport.encodeFieldRefKey;
-exports.encodeStableIdKey = require_viewport.encodeStableIdKey;
-exports.evaluateStep = require_viewport.evaluateStep;
+exports.describeProtection = require_resolver.describeProtection;
+exports.deserializeError = require_format.deserializeError;
+exports.dictEntries = require_authority.dictEntries;
+exports.draftWritesScripts = require_authority.draftWritesScripts;
+exports.drawnPointsOf = require_calibrate.drawnPointsOf;
+exports.encodeAnnotKey = require_resolver.encodeAnnotKey;
+exports.encodeFieldRefKey = require_format.encodeFieldRefKey;
+exports.encodePageKey = require_format.encodePageKey;
+exports.evaluateStep = require_authority.evaluateStep;
 exports.expandRawScope = require_resolver.expandRawScope;
-exports.expandTextRangeToLine = require_viewport.expandTextRangeToLine;
-exports.expandTextRangeToWord = require_viewport.expandTextRangeToWord;
 exports.expandedCapabilities = require_resolver.expandedCapabilities;
+exports.faceForFreeTextFont = require_resolveAnnotationDraft.faceForFreeTextFont;
+exports.familyKey = require_resolveAnnotationDraft.familyKey;
+exports.familyOfSubtype = require_authority.familyOfSubtype;
+exports.fieldAfterReset = require_Change.fieldAfterReset;
+exports.fieldAfterValue = require_Change.fieldAfterValue;
 exports.fieldLockFor = require_resolver.fieldLockFor;
+exports.fieldMatches = require_value.fieldMatches;
+exports.fieldRightsOf = require_resolver.fieldRightsOf;
+exports.fieldScriptOf = require_value.fieldScriptOf;
+exports.fieldValueOf = require_value.fieldValueOf;
+exports.fieldValueWriteOf = require_Change.fieldValueWriteOf;
 exports.filterMatches = require_resolver.filterMatches;
+exports.fitWidgetToFamily = require_Change.fitWidgetToFamily;
 exports.foldOptionsFor = require_viewport.foldOptionsFor;
-exports.foldText = require_derive.foldText;
+exports.foldText = require_calibrate.foldText;
+exports.formEffectOps = require_Change.formEffectOps;
+exports.formExportRowsOf = require_value.formExportRowsOf;
+exports.formFieldAfter = require_Change.formFieldAfter;
+exports.formFieldOfDraft = require_Change.formFieldOfDraft;
+exports.formImportFacts = require_value.formImportFacts;
+exports.formResetFacts = require_value.formResetFacts;
+exports.formValuesImportFacts = require_value.formValuesImportFacts;
+exports.formWidget = require_format.formWidget;
 exports.formatMeasurement = require_format.formatMeasurement;
-exports.glyphLooseBounds = require_derive.glyphLooseBounds;
-exports.glyphLooseQuad = require_derive.glyphLooseQuad;
-exports.invalidatesWeakIndexRefs = require_viewport.invalidatesWeakIndexRefs;
-exports.isAbortError = require_AbortError.isAbortError;
-exports.isDimension = require_derive.isDimension;
-exports.isReadout = require_derive.isReadout;
-exports.isRotatedGeometryRun = require_derive.isRotatedGeometryRun;
-exports.isStateAnnotation = require_viewport.isStateAnnotation;
-exports.isValidPageObjectNumber = require_viewport.isValidPageObjectNumber;
-exports.knownWeakAnnotationState = require_viewport.knownWeakAnnotationState;
+exports.formatObjectNumberRanges = require_viewport.formatObjectNumberRanges;
+exports.freeTextFontForFace = require_resolveAnnotationDraft.freeTextFontForFace;
+exports.generateUuid = require_authority.generateUuid;
+exports.generateUuidV7 = require_authority.generateUuidV7;
+exports.glyphLooseBounds = require_calibrate.glyphLooseBounds;
+exports.glyphLooseQuad = require_calibrate.glyphLooseQuad;
+exports.hasAnnotationResources = require_calibrate.hasAnnotationResources;
+exports.imageSourceOfBytes = require_authority.imageSourceOfBytes;
+exports.isAbortError = require_calibrate.isAbortError;
+exports.isAtDefault = require_Change.isAtDefault;
+exports.isDimension = require_resolveAnnotationDraft.isDimension;
+exports.isFieldScript = require_value.isFieldScript;
+exports.isKeptRefusal = require_authority.isKeptRefusal;
+exports.isLocalDocument = require_LocalDocumentHandle.isLocalDocument;
+exports.isLocalEngine = require_DocumentRenderService.isLocalEngine;
+exports.isLocalPage = require_LocalDocumentHandle.isLocalPage;
+exports.isNoOpWrite = require_Change.isNoOpWrite;
+exports.isProtectableCapability = require_resolver.isProtectableCapability;
+exports.isReadout = require_resolveAnnotationDraft.isReadout;
+exports.isRotatedGeometryRun = require_calibrate.isRotatedGeometryRun;
+exports.isSamePdfRect = require_resolveAnnotationDraft.isSamePdfRect;
+exports.isSkippedItem = require_Change.isSkippedItem;
+exports.isStandardFontName = require_resolveAnnotationDraft.isStandardFontName;
+exports.isStateAnnotation = require_resolveAnnotationDraft.isStateAnnotation;
+exports.isUndoChange = require_Change.isUndoChange;
+exports.isValidPageObjectNumber = require_format.isValidPageObjectNumber;
+exports.itemWrote = require_Change.itemWrote;
 exports.levelAllows = require_resolver.levelAllows;
 exports.levelFromPermission = require_resolver.levelFromPermission;
 exports.lockCovers = require_resolver.lockCovers;
 exports.lockNameCovers = require_resolver.lockNameCovers;
+exports.manifestBytesOf = require_calibrate.manifestBytesOf;
+exports.mapActionNode = require_calibrate.mapActionNode;
+exports.mapActionTree = require_calibrate.mapActionTree;
+exports.mapAnnotationActions = require_calibrate.mapAnnotationActions;
+exports.mapDocumentActions = require_calibrate.mapDocumentActions;
+exports.mapFieldActions = require_calibrate.mapFieldActions;
+exports.mapLinkTarget = require_calibrate.mapLinkTarget;
+exports.mapOutlineItem = require_authority.mapOutlineItem;
+exports.mapPageActions = require_calibrate.mapPageActions;
+exports.mapPageRefs = require_pageRefs.mapPageRefs;
 exports.matchLiteral = require_viewport.matchLiteral;
-exports.matchPageText = require_viewport.matchPageText;
+exports.matchPageText = require_authority.matchPageText;
 exports.matchRegex = require_viewport.matchRegex;
-exports.materializePdfPermissions = require_viewport.materializePdfPermissions;
-exports.measureFromKnownLength = require_derive.measureFromKnownLength;
-exports.measureFromRatio = require_derive.measureFromRatio;
-exports.measurementPoint = require_derive.measurementPoint;
-exports.measurementReadout = require_derive.measurementReadout;
+exports.materializePdfPermissions = require_builders.materializePdfPermissions;
+exports.measureFromKnownLength = require_calibrate.measureFromKnownLength;
+exports.measureFromRatio = require_calibrate.measureFromRatio;
+exports.measurementPoint = require_resolveAnnotationDraft.measurementPoint;
+exports.measurementReadout = require_resolveAnnotationDraft.measurementReadout;
+exports.mergeAnnotationPatch = require_authority.mergeAnnotationPatch;
 exports.minLevel = require_resolver.minLevel;
-exports.normalizeAnnotationDraft = require_viewport.normalizeAnnotationDraft;
-exports.normalizeAnnotationPatch = require_viewport.normalizeAnnotationPatch;
-exports.normalizeAttachmentFileSource = require_viewport.normalizeAttachmentFileSource;
-exports.normalizePdfRect = require_derive.normalizePdfRect;
-exports.parsePdfValue = require_viewport.parsePdfValue;
+exports.needsScriptRight = require_value.needsScriptRight;
+exports.normalizeAttachmentFileSource = require_authority.normalizeAttachmentFileSource;
+exports.normalizePdfQuad = require_resolveAnnotationDraft.normalizePdfQuad;
+exports.normalizePdfRect = require_resolveAnnotationDraft.normalizePdfRect;
+exports.objectNumbersIn = require_viewport.objectNumbersIn;
+exports.objectNumbersNamedBy = require_Change.objectNumbersNamedBy;
+exports.objectNumbersReferencedBy = require_Change.objectNumbersReferencedBy;
+exports.opIdOf = require_authority.opIdOf;
+exports.outlineItemAfter = require_Change.outlineItemAfter;
+exports.outlineItemOfDraft = require_Change.outlineItemOfDraft;
+exports.outlineItemRefsEqual = require_calibrate.outlineItemRefsEqual;
+exports.outlineItemWithChildren = require_Change.outlineItemWithChildren;
+exports.outlineVerbs = outlineVerbs;
+exports.pageAnnotationDraftOf = require_calibrate.pageAnnotationDraftOf;
+exports.pageAnnotationOf = require_calibrate.pageAnnotationOf;
+exports.pageAnnotationPatchOf = require_calibrate.pageAnnotationPatchOf;
+exports.pageAppearancesOf = require_authority.pageAppearancesOf;
+exports.pageBoxOf = require_calibrate.pageBoxOf;
+exports.pageBoxesOf = require_authority.pageBoxesOf;
+exports.pageDestinationOf = require_calibrate.pageDestinationOf;
+exports.pageFieldActionsOf = require_authority.pageFieldActionsOf;
+exports.pageFormFieldOf = require_authority.pageFormFieldOf;
+exports.pageFormSnapshotOf = require_authority.pageFormSnapshotOf;
+exports.pageGeometryOf = require_calibrate.pageGeometryOf;
+exports.pageGlyphLooseBounds = require_calibrate.pageGlyphLooseBounds;
+exports.pageGlyphLooseQuad = require_calibrate.pageGlyphLooseQuad;
+exports.pageLayoutOf = require_authority.pageLayoutOf;
+exports.pageListOf = require_authority.pageListOf;
+exports.pageMeasureOf = require_calibrate.pageMeasureOf;
+exports.pageOutlineItemOf = require_authority.pageOutlineItemOf;
+exports.pageOutlineOf = require_authority.pageOutlineOf;
+exports.pagePointOf = require_calibrate.pagePointOf;
+exports.pagePointTurned = require_calibrate.pagePointTurned;
+exports.pagePointUnturned = require_calibrate.pagePointUnturned;
+exports.pagePointsBounds = require_calibrate.pagePointsBounds;
+exports.pageQuadBounds = require_calibrate.pageQuadBounds;
+exports.pageQuadOf = require_calibrate.pageQuadOf;
+exports.pageRefsEqual = require_format.pageRefsEqual;
+exports.pageRefsIn = require_pageRefs.pageRefsIn;
+exports.pageRotationOf = require_authority.pageRotationOf;
+exports.pageSearchSliceOf = require_calibrate.pageSearchSliceOf;
+exports.pageSpaceBoxesOf = require_authority.pageSpaceBoxesOf;
+exports.pageTextSegmentOf = require_calibrate.pageTextSegmentOf;
+exports.pageTransform = require_calibrate.pageTransform;
+exports.pageTurnOfDrawn = require_calibrate.pageTurnOfDrawn;
+exports.pageTurnOfUpright = require_calibrate.pageTurnOfUpright;
+exports.pageVerbs = pageVerbs;
+exports.pageViewportsOf = require_calibrate.pageViewportsOf;
+exports.pageWidgetOf = require_authority.pageWidgetOf;
+exports.parseObjectNumberRanges = require_viewport.parseObjectNumberRanges;
+exports.parsePdfValue = require_authority.parsePdfValue;
 exports.parseScope = require_resolver.parseScope;
 exports.passwordPromptFromState = passwordPromptFromState;
-exports.pathLength = require_derive.pathLength;
-exports.pdfPermissions = require_viewport.pdfPermissions;
-exports.pdfQuadBounds = require_derive.pdfQuadBounds;
-exports.pdfQuadCorners = require_derive.pdfQuadCorners;
-exports.pdfQuadFromCorners = require_derive.pdfQuadFromCorners;
-exports.pdfRectFromOriginSize = require_derive.pdfRectFromOriginSize;
-exports.pdfRectHeight = require_derive.pdfRectHeight;
-exports.pdfRectSize = require_derive.pdfRectSize;
-exports.pdfRectToOriginSize = require_derive.pdfRectToOriginSize;
-exports.pdfRectWidth = require_derive.pdfRectWidth;
-exports.pdfValueEquals = require_viewport.pdfValueEquals;
+exports.pathLength = require_resolveAnnotationDraft.pathLength;
+exports.pdfAnnotationDraftOf = require_calibrate.pdfAnnotationDraftOf;
+exports.pdfAnnotationOf = require_calibrate.pdfAnnotationOf;
+exports.pdfAnnotationPatchOf = require_calibrate.pdfAnnotationPatchOf;
+exports.pdfAppearanceTurnOf = require_calibrate.pdfAppearanceTurnOf;
+exports.pdfDestinationOf = require_calibrate.pdfDestinationOf;
+exports.pdfFormFieldDraftOf = require_authority.pdfFormFieldDraftOf;
+exports.pdfMeasureOf = require_calibrate.pdfMeasureOf;
+exports.pdfOutlineDraftOf = require_authority.pdfOutlineDraftOf;
+exports.pdfOutlinePatchOf = require_authority.pdfOutlinePatchOf;
+exports.pdfPermissions = require_builders.pdfPermissions;
+exports.pdfPointOf = require_calibrate.pdfPointOf;
+exports.pdfPointTurned = require_resolveAnnotationDraft.pdfPointTurned;
+exports.pdfPointUnturned = require_resolveAnnotationDraft.pdfPointUnturned;
+exports.pdfPointsBounds = require_resolveAnnotationDraft.pdfPointsBounds;
+exports.pdfQuadBounds = require_resolveAnnotationDraft.pdfQuadBounds;
+exports.pdfQuadOf = require_calibrate.pdfQuadOf;
+exports.pdfQuarterTurnBox = require_resolveAnnotationDraft.pdfQuarterTurnBox;
+exports.pdfRectFromOriginSize = require_resolveAnnotationDraft.pdfRectFromOriginSize;
+exports.pdfRectHeight = require_resolveAnnotationDraft.pdfRectHeight;
+exports.pdfRectIntersection = require_resolveAnnotationDraft.pdfRectIntersection;
+exports.pdfRectOf = require_calibrate.pdfRectOf;
+exports.pdfRectSize = require_resolveAnnotationDraft.pdfRectSize;
+exports.pdfRectToOriginSize = require_resolveAnnotationDraft.pdfRectToOriginSize;
+exports.pdfRectTurnedBounds = require_resolveAnnotationDraft.pdfRectTurnedBounds;
+exports.pdfRectWidth = require_resolveAnnotationDraft.pdfRectWidth;
+exports.pdfRenderTargetOf = require_authority.pdfRenderTargetOf;
+exports.pdfTurnOfDrawn = require_resolveAnnotationDraft.pdfTurnOfDrawn;
+exports.pdfTurnOfUpright = require_resolveAnnotationDraft.pdfTurnOfUpright;
+exports.pdfValueEquals = require_authority.pdfValueEquals;
+exports.pdfWidgetPlacementOf = require_authority.pdfWidgetPlacementOf;
 exports.permissionInfoFromProbe = permissionInfoFromProbe;
 exports.permissionInfoWithAdvisory = permissionInfoWithAdvisory;
-exports.polygonArea = require_derive.polygonArea;
-exports.primaryFinding = require_viewport.primaryFinding;
+exports.placeFor = placeFor;
+exports.placeIn = placeIn;
+exports.placedBefore = placedBefore;
+exports.placedWidgetOf = require_authority.placedWidgetOf;
+exports.polygonArea = require_resolveAnnotationDraft.polygonArea;
+exports.positionIndex = require_viewport.positionIndex;
+exports.primaryFinding = require_authority.primaryFinding;
+exports.printDpiOf = require_authority.printDpiOf;
+exports.printScale = require_calibrate.printScale;
 exports.protectedCapabilities = require_resolver.protectedCapabilities;
-exports.refKey = require_derive.refKey;
-exports.refsOf = require_viewport.refsOf;
-exports.resolveBinarySource = require_viewport.resolveBinarySource;
-exports.restrictionsFor = require_viewport.restrictionsFor;
-exports.restrictionsOf = require_viewport.restrictionsOf;
-exports.revisionTokensEqual = require_viewport.revisionTokensEqual;
-exports.richTextParagraphsFromPlainText = require_viewport.richTextParagraphsFromPlainText;
-exports.richTextPlainText = require_viewport.richTextPlainText;
-exports.sameEffectiveValue = require_viewport.sameEffectiveValue;
-exports.scaleOf = require_derive.scaleOf;
-exports.searchContentEpoch = require_viewport.searchContentEpoch;
-exports.searchRectsForRange = require_viewport.searchRectsForRange;
-exports.searchSegmentsForRange = require_viewport.searchSegmentsForRange;
+exports.quarterTurnOf = require_resolveAnnotationDraft.quarterTurnOf;
+exports.rank = rank;
+exports.refsOf = require_authority.refsOf;
+exports.renderAreaTransform = require_calibrate.renderAreaTransform;
+exports.renderMatrix = require_calibrate.renderMatrix;
+exports.renderSize = require_calibrate.renderSize;
+exports.renderTargetArea = require_calibrate.renderTargetArea;
+exports.renderTransform = require_calibrate.renderTransform;
+exports.reorderPart = require_viewport.reorderPart;
+exports.reorderedList = require_viewport.reorderedList;
+exports.resolveAnnotationDraft = require_calibrate.resolveAnnotationDraft;
+exports.resolveAnnotationPatch = require_calibrate.resolveAnnotationPatch;
+exports.resolveAnnotationResources = require_calibrate.resolveAnnotationResources;
+exports.resolveBinarySource = require_calibrate.resolveBinarySource;
+exports.resolveChangeResources = require_Change.resolveChangeResources;
+exports.resolveMeasurementDraft = require_resolveAnnotationDraft.resolveMeasurementDraft;
+exports.resolvePageExtract = require_authority.resolvePageExtract;
+exports.resolvePageLayers = require_authority.resolvePageLayers;
+exports.resolveRectCommand = require_calibrate.resolveRectCommand;
+exports.resourceIdOf = require_resolveAnnotationDraft.resourceIdOf;
+exports.restrictionsFor = require_authority.restrictionsFor;
+exports.restrictionsOf = require_authority.restrictionsOf;
+exports.rgbOf = require_resolveAnnotationDraft.rgbOf;
+exports.richTextParagraphsFromPlainText = require_resolveAnnotationDraft.richTextParagraphsFromPlainText;
+exports.richTextPlainText = require_resolveAnnotationDraft.richTextPlainText;
+exports.sameColor = require_resolveAnnotationDraft.sameColor;
+exports.sameEffectiveValue = require_authority.sameEffectiveValue;
+exports.scaleOf = require_resolveAnnotationDraft.scaleOf;
+exports.searchContentEpoch = require_authority.searchContentEpoch;
+exports.searchQueryOf = require_authority.searchQueryOf;
 exports.securityStateFromHead = securityStateFromHead;
 exports.securityStateFromProbe = securityStateFromProbe;
-exports.semanticEqual = require_viewport.semanticEqual;
-exports.serializeError = require_derive.serializeError;
-exports.shiftsExistingAnnotationIndices = require_viewport.shiftsExistingAnnotationIndices;
-exports.sliceTextByChars = require_format.sliceTextByChars;
-exports.snapAppearanceScale = snapAppearanceScale;
-exports.snapFullPageViewport = snapFullPageViewport;
-exports.snapTileScale = snapTileScale;
-exports.sniffBinaryMetadata = require_viewport.sniffBinaryMetadata;
-exports.squareMetres = require_derive.squareMetres;
-exports.squareOf = require_derive.squareOf;
-exports.stableStringify = require_viewport.stableStringify;
-exports.subtypeFromCode = require_format.subtypeFromCode;
-exports.textGlyphAt = require_viewport.textGlyphAt;
-exports.textGlyphQuad = require_viewport.textGlyphQuad;
-exports.textSegmentsForRange = require_viewport.textSegmentsForRange;
-exports.toOriginalRange = require_derive.toOriginalRange;
-exports.validAreaBoundary = require_derive.validAreaBoundary;
+exports.semanticEqual = require_resolveAnnotationDraft.semanticEqual;
+exports.serializeError = require_format.serializeError;
+exports.shapeForRect = require_calibrate.shapeForRect;
+exports.shownAppearances = require_charmap.shownAppearances;
+exports.sliceText = require_charmap.sliceText;
+exports.snapAppearanceScale = require_DocumentRenderService.snapAppearanceScale;
+exports.snapFullPageViewport = require_DocumentRenderService.snapFullPageViewport;
+exports.snapTileScale = require_DocumentRenderService.snapTileScale;
+exports.sniffBinaryMetadata = require_calibrate.sniffBinaryMetadata;
+exports.squareMetres = require_calibrate.squareMetres;
+exports.squareOf = require_calibrate.squareOf;
+exports.stableStringify = require_authority.stableStringify;
+exports.standardStateModelOf = require_resolveAnnotationDraft.standardStateModelOf;
+exports.subscribeToType = subscribeToType;
+exports.subtypeFromCode = require_subtype.subtypeFromCode;
+exports.toAttachmentRef = require_calibrate.toAttachmentRef;
+exports.toFieldRef = require_format.toFieldRef;
+exports.toOriginalRange = require_calibrate.toOriginalRange;
+exports.toOutlineItemRef = require_calibrate.toOutlineItemRef;
+exports.toPageRef = require_format.toPageRef;
+exports.topRowOf = require_Change.topRowOf;
+exports.touchesCaption = require_resolveAnnotationDraft.touchesCaption;
+exports.validAreaBoundary = require_resolveAnnotationDraft.validAreaBoundary;
 exports.validNumberFormat = require_format.validNumberFormat;
 exports.validateScopeArray = require_resolver.validateScopeArray;
 exports.validateSearchQuery = require_viewport.validateSearchQuery;
 exports.validateSearchRegex = require_viewport.validateSearchRegex;
+exports.valueEntriesEqual = require_Change.valueEntriesEqual;
 exports.viewportForPoint = require_viewport.viewportForPoint;
+exports.visibleBoxesOf = require_authority.visibleBoxesOf;
+exports.widgetActionsOf = require_value.widgetActionsOf;
+exports.widgetAfterPatch = require_Change.widgetAfterPatch;
+exports.widgetsAfterDisplay = require_Change.widgetsAfterDisplay;
 exports.wirePack = wirePack;
+exports.withFileFromResource = require_calibrate.withFileFromResource;
 exports.wordAt = require_viewport.wordAt;
 exports.wordBefore = require_viewport.wordBefore;
-exports.worstVerdict = require_viewport.worstVerdict;
+exports.worstVerdict = require_authority.worstVerdict;
+exports.writesScripts = require_value.writesScripts;
 
 //# sourceMappingURL=runtime.cjs.map