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

package/dist/runtime.js

@@ -1,128 +1,412 @@
-import { $ as shiftsExistingAnnotationIndices, A as EdgeResolver, B as worstVerdict, C as validateSearchQuery, D as wordAt, E as matchLiteral, F as sameEffectiveValue, G as refsOf, H as dictEntries, I as assessmentOf, J as encodeFieldRefKey, K as stableStringify, L as combine, M as restrictionsFor, N as evaluateStep, O as wordBefore, P as restrictionsOf, Q as invalidatesWeakIndexRefs, R as conclude, S as matchRegex, T as foldOptionsFor, U as parsePdfValue, V as changedKeys, W as pdfValueEquals, X as semanticEqual, Y as appearanceImpactOf, Z as changesAnnotationList, _ as textSegmentsForRange, _t as createPageImageHandle, a as pdfPermissions, at as sniffBinaryMetadata, b as matchPageText, c as canonicalSearchQuery, ct as UNKNOWN_WEAK_ANNOTATION_STATE, d as searchSegmentsForRange, dt as decodeStableIdKey, et as buildCommentThreads, f as buildPageTextLayout, ft as encodeStableIdKey, g as textGlyphQuad, gt as DEFAULT_PDF_SAVE_MODE, h as textGlyphAt, ht as richTextPlainText, i as materializePdfPermissions, it as normalizeAttachmentFileSource, j as USAGE_INCOMPLETE, k as DEFAULT_EDGE_RESOLVER_BUDGET, l as searchContentEpoch, lt as knownWeakAnnotationState, m as expandTextRangeToWord, mt as richTextParagraphsFromPlainText, n as caps, nt as normalizeAnnotationDraft, o as PDF_BITS, ot as resolveBinarySource, p as expandTextRangeToLine, pt as isValidPageObjectNumber, q as decodeFieldRefKey, r as collab, rt as normalizeAnnotationPatch, s as decodePdfBits, st as NO_ANNOTATION_FLAGS, t as viewportForPoint, tt as isStateAnnotation, u as searchRectsForRange, ut as revisionTokensEqual, v as SEARCH_SNIPPET_CONTEXT, vt as decodeSubmitFormFlags, w as validateSearchRegex, x as SEARCH_REGEX_MAX_LENGTH, y as buildSnippet, z as primaryFinding } from "./viewport-CvMcadfQ.js";
-import { A as isRotatedGeometryRun, C as refKey, D as _defineProperty, E as serializeError, F as pdfRectFromOriginSize, I as pdfRectHeight, L as pdfRectSize, M as pdfQuadBounds, N as pdfQuadCorners, O as glyphLooseBounds, P as pdfQuadFromCorners, R as pdfRectToOriginSize, S as classifyRelation, T as deserializeError, _ as assertWritableMeasure, a as measurementPoint, b as toOriginalRange, c as scaleOf, d as measureFromRatio, f as METRES, g as assertPdfFloat, h as squareOf, i as measurementReadout, j as normalizePdfRect, k as glyphLooseQuad, l as validAreaBoundary, m as squareMetres, n as isDimension, o as pathLength, p as areaUnitLabel, r as isReadout, s as polygonArea, t as deriveMeasurementLabel, u as measureFromKnownLength, v as SEARCH_FOLD_VERSION, w as EngineError, x as buildThreads, y as foldText, z as pdfRectWidth } from "./derive-DAFJolWu.js";
-import { a as charBoundaryAtTextOffset, c as sliceTextByChars, d as PDF_SUBTYPE_TO_CODE, f as PdfAnnotationSubtypeCode, i as boundaryTextOffset, l as ANNOTATION_SUBTYPES, m as EngineErrorCode, n as validNumberFormat, o as charMapViolation, p as subtypeFromCode, r as PAGE_INSERT_BLANK_MAX_COUNT, s as charRangeForTextOffsets, t as formatMeasurement, u as PDF_CODE_TO_SUBTYPE } from "./format-Bbphf4zR.js";
-import { S as protectedCapabilities, _ as levelAllows, a as expandRawScope, b as lockNameCovers, c as parseScope, d as MissingIdentity, f as PermissionDenied, g as fieldLockFor, h as deriveProtection, i as checkSetGroup, l as validateScopeArray, m as SIGNATURE_POLICY_VERSION, n as checkCapability, o as expandedCapabilities, r as checkCollab, s as filterMatches, t as checkAnyCapability, u as InvalidScope, v as levelFromPermission, x as minLevel, y as lockCovers } from "./resolver-inAVzsWt.js";
-import { n as isAbortError, t as AbortError } from "./AbortError-DwuHPK_I.js";
-//#region src/promise/AbortablePromise.ts
-let _Symbol$species;
-_Symbol$species = Symbol.species;
+import { C as outlineItemAfter, E as OUTLINE_READ_LIMITS, S as deletedAttachmentOf, T as outlineItemWithChildren, _ as assertChoiceDefault, a as objectNumbersReferencedBy, b as isNoOpWrite, c as defaultEntryOfDraft, d as formFieldAfter, f as formFieldOfDraft, g as widgetAfterPatch, h as fitWidgetToFamily, i as objectNumbersNamedBy, l as fieldAfterReset, m as widgetsAfterDisplay, n as isUndoChange, o as resolveChangeResources, p as topRowOf, r as itemWrote, s as formEffectOps, t as isSkippedItem, u as fieldAfterValue, v as fieldValueWriteOf, w as outlineItemOfDraft, x as valueEntriesEqual, y as isAtDefault } from "./Change-tMR34hTU.js";
+import { $ as pdfAppearanceTurnOf, A as createPdfTextLayout, At as pageTransform, B as mapActionNode, C as resolveAnnotationPatch, Ct as isRotatedGeometryRun, D as pageGeometryOf, Dt as pdfPointOf, E as createTextLayout, Et as pageQuadOf, F as pdfAnnotationOf, Ft as renderSize, G as mapLinkTarget, H as mapAnnotationActions, I as pdfAnnotationPatchOf, It as PRINT_PAPER, J as pageDestinationOf, K as mapPageActions, L as pageMeasureOf, Lt as printScale, M as pageAnnotationOf, Mt as renderMatrix, N as pageAnnotationPatchOf, Nt as renderTargetArea, O as pageSearchSliceOf, Ot as pdfQuadOf, P as pdfAnnotationDraftOf, Pt as renderTransform, R as pageViewportsOf, Rt as actionTreeOf, S as resolveAnnotationDraft, St as glyphLooseQuad, T as shapeForRect, Tt as pagePointOf, U as mapDocumentActions, V as mapActionTree, W as mapFieldActions, X as ANNOTATION_DEFAULTS, Y as pdfDestinationOf, Z as annotationDefaultsOf, _ as pagePointUnturned, _t as outlineItemRefsEqual, a as squareMetres, at as bundleCodec, b as pageTurnOfDrawn, bt as isAbortError, c as foldText, ct as manifestBytesOf, d as appearanceTurnOf, dt as assertAnnotationResources, et as ATTACHMENT_LIMITS, f as applyAnnotationPatch, ft as hasAnnotationResources, g as pagePointTurned, gt as resolveBinarySource, h as pageGlyphLooseQuad, ht as sniffBinaryMetadata, i as areaUnitLabel, it as assertAnnotationBundleManifest, j as pageAnnotationDraftOf, jt as renderAreaTransform, k as pageTextSegmentOf, kt as pdfRectOf, l as toOriginalRange, lt as ANNOTATION_RESOURCE_ROLE_NAMES, m as pageGlyphLooseBounds, mt as withFileFromResource, n as measureFromRatio, nt as AnnotationTransfer, o as squareOf, ot as DEFAULT_BUNDLE_LIMITS, p as drawnPointsOf, pt as resolveAnnotationResources, r as METRES, rt as assertAnnotationBundle, s as SEARCH_FOLD_VERSION, st as assertWithinLimit, t as measureFromKnownLength, tt as toAttachmentRef, u as annotationOfDraft, ut as annotationResourceBuffers, v as pagePointsBounds, vt as toOutlineItemRef, w as resolveRectCommand, wt as pageBoxOf, x as pageTurnOfUpright, xt as glyphLooseBounds, y as pageQuadBounds, yt as AbortError, z as pdfMeasureOf } from "./calibrate-nQFgCuki.js";
+import { a as deletedFieldOf, c as formExportRowsOf, d as decodeSubmitFormFlags, f as fieldScriptOf, g as writesScripts, h as widgetActionsOf, i as formValuesImportFacts, l as WIDGET_ACTION_EVENTS, m as needsScriptRight, n as WIDGET_FLAG_NAMES, o as formResetFacts, p as isFieldScript, r as formImportFacts, s as fieldMatches, t as fieldValueOf, u as actionWriteOf } from "./value-Dhc8eYcx.js";
+import { B as deletedWith, C as measurementPoint, Ct as pdfRectToOriginSize, D as validAreaBoundary, E as scaleOf, Et as quarterTurnOf, F as buildCommentThreads, I as isStateAnnotation, K as bundlePageMapping, L as standardStateModelOf, M as appearanceChangeOf, N as appearanceImpactOf, O as DRAWN_RECT_KINDS, P as semanticEqual, Q as ANNOTATION_FIELD_SPACES, R as buildThreads, S as measurementReadout, St as pdfRectSize, T as polygonArea, Tt as pdfRectWidth, X as resourceIdOf, Z as compareIsoDateTime, _ as assertPdfFloat, _t as pdfQuadBounds, at as sameColor, b as isDimension, bt as pdfRectHeight, c as assertRichTextAgreement, ct as richTextPlainText, d as faceForFreeTextFont, dt as pdfPointsBounds, et as ANNOTATION_FIELD_NAMES, f as familyKey, ft as pdfTurnOfDrawn, g as touchesCaption, gt as normalizePdfRect, h as resolveMeasurementDraft, ht as normalizePdfQuad, i as assertDeclaredFields, it as rgbOf, j as UNBAKED_KINDS, lt as pdfPointTurned, m as isStandardFontName, mt as isSamePdfRect, ot as DEFAULT_RICH_TEXT_BODY, p as freeTextFontForFace, pt as pdfTurnOfUpright, rt as colorOf, st as richTextParagraphsFromPlainText, tt as ANNOTATION_RESOURCE_ROLES, u as STANDARD_FACES, ut as pdfPointUnturned, v as assertWritableMeasure, vt as pdfQuarterTurnBox, w as pathLength, wt as pdfRectTurnedBounds, x as isReadout, xt as pdfRectIntersection, y as deriveMeasurementLabel, yt as pdfRectFromOriginSize, z as classifyRelation } from "./resolveAnnotationDraft-CUpf0SMh.js";
+import { _ as serializeError, a as formWidget, c as STANDARD_FONTS, d as pageRefsEqual, f as toPageRef, g as deserializeError, h as EngineError, i as encodeFieldRefKey, l as decodePageKey, m as annotationKey, n as validNumberFormat, o as toFieldRef, p as isValidPageObjectNumber, r as decodeFieldRefKey, s as NO_ANNOTATION_FLAGS, t as formatMeasurement, u as encodePageKey, v as _defineProperty, y as EngineErrorCode } from "./format-Dgg428Kb.js";
+import { $ as pageWidgetOf, A as restrictionsOf, B as pdfValueEquals, C as matchPageText, Ct as imageSourceOfBytes, D as USAGE_INCOMPLETE, Dt as pageBoxesOf, E as EdgeResolver, Et as DEFAULT_MEDIA_BOX, F as primaryFinding, G as mapOutlineItem, H as stableStringify, I as worstVerdict, J as pdfOutlineDraftOf, K as pageOutlineItemOf, L as changedKeys, M as assessmentOf, N as combine, O as restrictionsFor, Ot as pageRotationOf, P as conclude, Q as pageFormSnapshotOf, R as dictEntries, S as buildSnippet, St as createPageImageHandle, T as DEFAULT_EDGE_RESOLVER_BUDGET, Tt as resolvePageLayers, U as placedWidgetOf, V as refsOf, W as draftWritesScripts, X as pageFieldActionsOf, Y as pdfOutlinePatchOf, Z as pageFormFieldOf, _ as isKeptRefusal, _t as generateUuidV7, a as annotationWriteCapability, at as pageListOf, b as searchContentEpoch, bt as checkImageQuality, c as authorizeAnnotationUpdate, ct as annotationPatchBetween, d as authorizeFieldWrite, dt as concatAnnotationLists, et as pdfFormFieldDraftOf, f as authorizeUnprotected, ft as closeExportSelection, g as changeFingerprint, gt as generateUuid, h as deletedOutlineItemsOf, ht as familyOfSubtype, i as annotationWriteCapabilities, it as pageLayoutOf, j as sameEffectiveValue, k as evaluateStep, l as authorizeCapability, lt as mergeAnnotationPatch, m as decodePdfBits, mt as normalizeAttachmentFileSource, n as allowsFieldWrite, nt as pageAppearancesOf, o as authorizeAnnotationCreate, ot as pageSpaceBoxesOf, p as PDF_BITS, pt as annotationImportFacts, q as pageOutlineOf, r as allowsSomeFieldWrite, rt as pdfRenderTargetOf, s as authorizeAnnotationDelete, st as visibleBoxesOf, t as allowsCapability, tt as pdfWidgetPlacementOf, u as authorizeFieldGroup, ut as deletedAnnotationsOf, v as opIdOf, vt as DEFAULT_PDF_SAVE_MODE, w as searchQueryOf, wt as printDpiOf, x as SEARCH_SNIPPET_CONTEXT, xt as checkRenderUsage, y as canonicalSearchQuery, yt as resolvePageExtract, z as parsePdfValue } from "./authority-PuxpGFhJ.js";
+import { A as MissingIdentity, C as lockCovers, D as decodeAnnotKey, E as protectedCapabilities, O as encodeAnnotKey, S as levelFromPermission, T as minLevel, _ as deriveProtection, a as checkFieldAction, b as isProtectableCapability, c as expandRawScope, d as filterMatches, f as parseScope, g as SIGNATURE_POLICY_VERSION, h as PROTECTABLE_CAPABILITIES, i as checkCollab, j as PermissionDenied, k as InvalidScope, l as expandedCapabilities, n as checkAnyFieldAction, o as checkSetGroup, p as validateScopeArray, r as checkCapability, s as collabTargetOf, t as checkAnyCapability, u as fieldRightsOf, v as describeProtection, w as lockNameCovers, x as levelAllows, y as fieldLockFor } from "./resolver-BBggAxQc.js";
+import { S as AbortablePromise, _ as OBJECT_NUMBER_CEILING, a as reorderedList, b as objectNumbersIn, c as validateSearchQuery, d as matchLiteral, f as wordAt, g as assertFormBundleManifest, h as assertFormBundle, i as reorderPart, l as validateSearchRegex, m as FormTransfer, n as anchorOf, o as SEARCH_REGEX_MAX_LENGTH, p as wordBefore, r as positionIndex, s as matchRegex, t as viewportForPoint, u as foldOptionsFor, v as OBJECT_NUMBER_ISSUE_LIMIT, x as parseObjectNumberRanges, y as formatObjectNumberRanges } from "./viewport-DQR5LyX3.js";
+import { a as sliceText, d as shownAppearances, i as charRangeForTextOffsets, l as ANNOTATION_APPEARANCE_MODES, n as charBoundaryAtTextOffset, r as charMapViolation, t as boundaryTextOffset, u as appearanceModesOf } from "./charmap-Cprti1ta.js";
+import { a as subtypeFromCode, i as PdfAnnotationSubtypeCode, n as PDF_CODE_TO_SUBTYPE, r as PDF_SUBTYPE_TO_CODE, t as ANNOTATION_SUBTYPES } from "./subtype-CG4WpIRj.js";
+import { n as pageRefsIn, t as mapPageRefs } from "./pageRefs-DkbuxSCV.js";
+import { t as PAGE_INSERT_BLANK_MAX_COUNT } from "./PageInsertBlankInput-DhVYVJ_S.js";
+import { i as pdfPermissions, n as collab, r as materializePdfPermissions, t as caps } from "./builders-DV62HA3I.js";
+import { n as isLocalPage, r as LOCAL_ENGINE_BRAND, t as isLocalDocument } from "./LocalDocumentHandle-DAPdaOt_.js";
+import { a as snapTileScale, i as snapFullPageViewport, n as appearanceLatticeScale, o as isLocalEngine, r as snapAppearanceScale, t as CONTINUOUS_RENDER_POLICY } from "./DocumentRenderService-DFrZ9wfW.js";
+//#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;
 		});
-		_defineProperty(this, "signal", void 0);
-		_defineProperty(this, "_ctrl", void 0);
-		_defineProperty(this, "_progressCbs", void 0);
-		_defineProperty(this, "_state", void 0);
-		_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 AbortError ? reason : new AbortError(reason);
-		this._state.settled = true;
-		this._ctrl.abort(err);
-		this._internalReject(err);
+	}) {
+		this.onListenerError = onListenerError;
+		_defineProperty(this, "listeners", /* @__PURE__ */ new Set());
+		_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 (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: 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 annotationImportFacts(result).map((fact) => ({
+				type: "annotations.created",
+				...fact
+			}));
+		}
+		case "forms.import": {
+			const { type: _type, ...result } = item;
+			return formImportFacts(result).map((fact) => ({
+				type: "forms.created",
+				...fact
+			}));
+		}
+		case "forms.importValues": {
+			const { type: _type, ...result } = item;
+			return 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 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: 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: 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: 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 {
@@ -168,20 +452,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(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 = {}) {
@@ -211,68 +495,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 EngineError(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 EngineError(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 EngineError(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 EngineError(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
@@ -280,7 +591,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.
@@ -310,15 +621,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 {
@@ -328,6 +641,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) => 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 EngineError(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 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) => 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 EngineError(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) => 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 EngineError(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
@@ -340,10 +797,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])
@@ -356,6 +811,6 @@ function wirePack(payload, transfer = EMPTY_TRANSFER) {
 	};
 }
 //#endregion
-export { ANNOTATION_SUBTYPES, AbortError, AbortablePromise, CONTINUOUS_RENDER_POLICY, DEFAULT_EDGE_RESOLVER_BUDGET, DEFAULT_PDF_SAVE_MODE, EMPTY_TRANSFER, EdgeResolver, EngineError, EngineErrorCode, InvalidScope, METRES, MissingIdentity, NO_ANNOTATION_FLAGS, PAGE_INSERT_BLANK_MAX_COUNT, PDF_BITS, PDF_CODE_TO_SUBTYPE, PDF_SUBTYPE_TO_CODE, PdfAnnotationSubtypeCode, PermissionDenied, SEARCH_FOLD_VERSION, SEARCH_REGEX_MAX_LENGTH, SEARCH_SNIPPET_CONTEXT, SIGNATURE_POLICY_VERSION, UNKNOWN_WEAK_ANNOTATION_STATE, USAGE_INCOMPLETE, advisoryFromPdfBits, appearanceImpactOf, areaUnitLabel, assertPdfFloat, assertWritableMeasure, assessmentOf, boundaryTextOffset, buildCommentThreads, buildPageTextLayout, buildSnippet, buildThreads, canonicalSearchQuery, caps, changedKeys, changesAnnotationList, charBoundaryAtTextOffset, charMapViolation, charRangeForTextOffsets, checkAnyCapability, checkCapability, checkCollab, checkSetGroup, classifyRelation, collab, combine, conclude, createPageImageHandle, decodeFieldRefKey, decodePdfBits, decodeStableIdKey, decodeSubmitFormFlags, deriveMeasurementLabel, deriveProtection, deserializeError, dictEntries, encodeFieldRefKey, encodeStableIdKey, evaluateStep, expandRawScope, expandTextRangeToLine, expandTextRangeToWord, expandedCapabilities, fieldLockFor, filterMatches, foldOptionsFor, foldText, formatMeasurement, glyphLooseBounds, glyphLooseQuad, invalidatesWeakIndexRefs, isAbortError, isDimension, isReadout, isRotatedGeometryRun, isStateAnnotation, isValidPageObjectNumber, knownWeakAnnotationState, levelAllows, levelFromPermission, lockCovers, lockNameCovers, matchLiteral, matchPageText, matchRegex, materializePdfPermissions, measureFromKnownLength, measureFromRatio, measurementPoint, measurementReadout, minLevel, normalizeAnnotationDraft, normalizeAnnotationPatch, normalizeAttachmentFileSource, normalizePdfRect, parsePdfValue, parseScope, passwordPromptFromState, pathLength, pdfPermissions, pdfQuadBounds, pdfQuadCorners, pdfQuadFromCorners, pdfRectFromOriginSize, pdfRectHeight, pdfRectSize, pdfRectToOriginSize, pdfRectWidth, pdfValueEquals, permissionInfoFromProbe, permissionInfoWithAdvisory, polygonArea, primaryFinding, protectedCapabilities, refKey, refsOf, resolveBinarySource, restrictionsFor, restrictionsOf, revisionTokensEqual, richTextParagraphsFromPlainText, richTextPlainText, sameEffectiveValue, scaleOf, searchContentEpoch, searchRectsForRange, searchSegmentsForRange, securityStateFromHead, securityStateFromProbe, semanticEqual, serializeError, shiftsExistingAnnotationIndices, sliceTextByChars, snapAppearanceScale, snapFullPageViewport, snapTileScale, sniffBinaryMetadata, squareMetres, squareOf, stableStringify, subtypeFromCode, textGlyphAt, textGlyphQuad, textSegmentsForRange, toOriginalRange, validAreaBoundary, validNumberFormat, validateScopeArray, validateSearchQuery, validateSearchRegex, viewportForPoint, wirePack, wordAt, wordBefore, worstVerdict };
+export { ANNOTATION_APPEARANCE_MODES, ANNOTATION_DEFAULTS, ANNOTATION_FIELD_NAMES, ANNOTATION_FIELD_SPACES, ANNOTATION_RESOURCE_ROLES, ANNOTATION_RESOURCE_ROLE_NAMES, ANNOTATION_SUBTYPES, ATTACHMENT_LIMITS, AbortError, AbortablePromise, AnnotationTransfer, CONTINUOUS_RENDER_POLICY, DEFAULT_BUNDLE_LIMITS, DEFAULT_EDGE_RESOLVER_BUDGET, DEFAULT_MEDIA_BOX, DEFAULT_PDF_SAVE_MODE, DEFAULT_RICH_TEXT_BODY, DRAWN_RECT_KINDS, EMPTY_TRANSFER, EdgeResolver, EngineError, EngineErrorCode, EventHub, FormTransfer, InvalidScope, LOCAL_ENGINE_BRAND, METRES, MissingIdentity, NO_ANNOTATION_FLAGS, OBJECT_NUMBER_CEILING, OBJECT_NUMBER_ISSUE_LIMIT, OUTLINE_READ_LIMITS, PAGE_INSERT_BLANK_MAX_COUNT, PDF_BITS, PDF_CODE_TO_SUBTYPE, PDF_SUBTYPE_TO_CODE, PRINT_PAPER, PROTECTABLE_CAPABILITIES, PdfAnnotationSubtypeCode, PermissionDenied, SEARCH_FOLD_VERSION, SEARCH_REGEX_MAX_LENGTH, SEARCH_SNIPPET_CONTEXT, SIGNATURE_POLICY_VERSION, STANDARD_FACES, STANDARD_FONTS, SessionEventPublisher, UNBAKED_KINDS, USAGE_INCOMPLETE, WIDGET_ACTION_EVENTS, WIDGET_FLAG_NAMES, actionTreeOf, actionWriteOf, advisoryFromPdfBits, allowsCapability, allowsFieldWrite, allowsSomeFieldWrite, anchorOf, annotationDefaultsOf, annotationImportFacts, annotationKey, annotationOfDraft, annotationPatchBetween, annotationResourceBuffers, annotationWriteCapabilities, annotationWriteCapability, appearanceChangeOf, appearanceImpactOf, appearanceLatticeScale, appearanceModesOf, appearanceTurnOf, applyAnnotationPatch, areaUnitLabel, assertAnnotationBundle, assertAnnotationBundleManifest, assertAnnotationResources, assertChoiceDefault, assertDeclaredFields, assertFormBundle, assertFormBundleManifest, assertPdfFloat, assertRichTextAgreement, assertWithinLimit, assertWritableMeasure, assessmentOf, attachmentVerbs, authorizeAnnotationCreate, authorizeAnnotationDelete, authorizeAnnotationUpdate, authorizeCapability, authorizeFieldGroup, authorizeFieldWrite, authorizeUnprotected, boundaryTextOffset, buildCommentThreads, buildSnippet, buildThreads, bundleCodec, bundlePageMapping, canonicalSearchQuery, caps, changeEvents, changeFingerprint, changedKeys, charBoundaryAtTextOffset, charMapViolation, charRangeForTextOffsets, checkAnyCapability, checkAnyFieldAction, checkCapability, checkCollab, checkFieldAction, checkImageQuality, checkRenderUsage, checkSetGroup, classifyRelation, clearlyOutranks, closeExportSelection, collab, collabTargetOf, colorOf, combine, compareIsoDateTime, concatAnnotationLists, conclude, createPageImageHandle, createPdfTextLayout, createTextLayout, decodeAnnotKey, decodeFieldRefKey, decodePageKey, decodePdfBits, decodeSubmitFormFlags, defaultEntryOfDraft, deletedAnnotationsOf, deletedAttachmentOf, deletedFieldOf, deletedOutlineItemsOf, deletedWith, deriveMeasurementLabel, deriveProtection, describeProtection, deserializeError, dictEntries, draftWritesScripts, drawnPointsOf, encodeAnnotKey, encodeFieldRefKey, encodePageKey, evaluateStep, expandRawScope, expandedCapabilities, faceForFreeTextFont, familyKey, familyOfSubtype, fieldAfterReset, fieldAfterValue, fieldLockFor, fieldMatches, fieldRightsOf, fieldScriptOf, fieldValueOf, fieldValueWriteOf, filterMatches, fitWidgetToFamily, foldOptionsFor, foldText, formEffectOps, formExportRowsOf, formFieldAfter, formFieldOfDraft, formImportFacts, formResetFacts, formValuesImportFacts, formWidget, formatMeasurement, formatObjectNumberRanges, freeTextFontForFace, generateUuid, generateUuidV7, glyphLooseBounds, glyphLooseQuad, hasAnnotationResources, imageSourceOfBytes, isAbortError, isAtDefault, isDimension, isFieldScript, isKeptRefusal, isLocalDocument, isLocalEngine, isLocalPage, isNoOpWrite, isProtectableCapability, isReadout, isRotatedGeometryRun, isSamePdfRect, isSkippedItem, isStandardFontName, isStateAnnotation, isUndoChange, isValidPageObjectNumber, itemWrote, levelAllows, levelFromPermission, lockCovers, lockNameCovers, manifestBytesOf, mapActionNode, mapActionTree, mapAnnotationActions, mapDocumentActions, mapFieldActions, mapLinkTarget, mapOutlineItem, mapPageActions, mapPageRefs, matchLiteral, matchPageText, matchRegex, materializePdfPermissions, measureFromKnownLength, measureFromRatio, measurementPoint, measurementReadout, mergeAnnotationPatch, minLevel, needsScriptRight, normalizeAttachmentFileSource, normalizePdfQuad, normalizePdfRect, objectNumbersIn, objectNumbersNamedBy, objectNumbersReferencedBy, opIdOf, outlineItemAfter, outlineItemOfDraft, outlineItemRefsEqual, outlineItemWithChildren, outlineVerbs, pageAnnotationDraftOf, pageAnnotationOf, pageAnnotationPatchOf, pageAppearancesOf, pageBoxOf, pageBoxesOf, pageDestinationOf, pageFieldActionsOf, pageFormFieldOf, pageFormSnapshotOf, pageGeometryOf, pageGlyphLooseBounds, pageGlyphLooseQuad, pageLayoutOf, pageListOf, pageMeasureOf, pageOutlineItemOf, pageOutlineOf, pagePointOf, pagePointTurned, pagePointUnturned, pagePointsBounds, pageQuadBounds, pageQuadOf, pageRefsEqual, pageRefsIn, pageRotationOf, pageSearchSliceOf, pageSpaceBoxesOf, pageTextSegmentOf, pageTransform, pageTurnOfDrawn, pageTurnOfUpright, pageVerbs, pageViewportsOf, pageWidgetOf, parseObjectNumberRanges, parsePdfValue, parseScope, passwordPromptFromState, pathLength, pdfAnnotationDraftOf, pdfAnnotationOf, pdfAnnotationPatchOf, pdfAppearanceTurnOf, pdfDestinationOf, pdfFormFieldDraftOf, pdfMeasureOf, pdfOutlineDraftOf, pdfOutlinePatchOf, pdfPermissions, pdfPointOf, pdfPointTurned, pdfPointUnturned, pdfPointsBounds, pdfQuadBounds, pdfQuadOf, pdfQuarterTurnBox, pdfRectFromOriginSize, pdfRectHeight, pdfRectIntersection, pdfRectOf, pdfRectSize, pdfRectToOriginSize, pdfRectTurnedBounds, pdfRectWidth, pdfRenderTargetOf, pdfTurnOfDrawn, pdfTurnOfUpright, pdfValueEquals, pdfWidgetPlacementOf, permissionInfoFromProbe, permissionInfoWithAdvisory, placeFor, placeIn, placedBefore, placedWidgetOf, polygonArea, positionIndex, primaryFinding, printDpiOf, printScale, protectedCapabilities, quarterTurnOf, rank, refsOf, renderAreaTransform, renderMatrix, renderSize, renderTargetArea, renderTransform, reorderPart, reorderedList, resolveAnnotationDraft, resolveAnnotationPatch, resolveAnnotationResources, resolveBinarySource, resolveChangeResources, resolveMeasurementDraft, resolvePageExtract, resolvePageLayers, resolveRectCommand, resourceIdOf, restrictionsFor, restrictionsOf, rgbOf, richTextParagraphsFromPlainText, richTextPlainText, sameColor, sameEffectiveValue, scaleOf, searchContentEpoch, searchQueryOf, securityStateFromHead, securityStateFromProbe, semanticEqual, serializeError, shapeForRect, shownAppearances, sliceText, snapAppearanceScale, snapFullPageViewport, snapTileScale, sniffBinaryMetadata, squareMetres, squareOf, stableStringify, standardStateModelOf, subscribeToType, subtypeFromCode, toAttachmentRef, toFieldRef, toOriginalRange, toOutlineItemRef, toPageRef, topRowOf, touchesCaption, validAreaBoundary, validNumberFormat, validateScopeArray, validateSearchQuery, validateSearchRegex, valueEntriesEqual, viewportForPoint, visibleBoxesOf, widgetActionsOf, widgetAfterPatch, widgetsAfterDisplay, wirePack, withFileFromResource, wordAt, wordBefore, worstVerdict, writesScripts };
 
 //# sourceMappingURL=runtime.js.map