@embedpdf/engine-core 3.0.0-next.13 → 3.0.0-next.15

package/dist/runtime.js

@@ -1,128 +1,318 @@
-import { $ as buildCommentThreads, A as USAGE_INCOMPLETE, B as changedKeys, C as validateSearchRegex, D as wordBefore, E as wordAt, F as assessmentOf, G as stableStringify, H as parsePdfValue, I as combine, J as appearanceImpactOf, K as decodeFieldRefKey, L as conclude, M as evaluateStep, N as restrictionsOf, O as DEFAULT_EDGE_RESOLVER_BUDGET, P as sameEffectiveValue, Q as shiftsExistingAnnotationIndices, R as primaryFinding, S as validateSearchQuery, T as matchLiteral, U as pdfValueEquals, V as dictEntries, W as refsOf, X as changesAnnotationList, Y as semanticEqual, Z as invalidatesWeakIndexRefs, _ as SEARCH_SNIPPET_CONTEXT, _t as richTextPlainText, a as PDF_BITS, at as normalizeAnnotationPatch, b as SEARCH_REGEX_MAX_LENGTH, bt as decodeSubmitFormFlags, c as searchContentEpoch, ct as resolveBinarySource, d as buildPageTextLayout, dt as knownWeakAnnotationState, et as isStateAnnotation, f as expandTextRangeToLine, ft as revisionTokensEqual, g as textSegmentsForRange, gt as richTextParagraphsFromPlainText, h as textGlyphQuad, ht as isValidPageObjectNumber, i as pdfPermissions, it as normalizeAnnotationDraft, j as restrictionsFor, k as EdgeResolver, l as searchRectsForRange, lt as NO_ANNOTATION_FLAGS, m as textGlyphAt, mt as encodeStableIdKey, n as collab, nt as classifyRelation, o as decodePdfBits, ot as normalizeAttachmentFileSource, p as expandTextRangeToWord, pt as decodeStableIdKey, q as encodeFieldRefKey, r as materializePdfPermissions, rt as refKey, s as canonicalSearchQuery, st as sniffBinaryMetadata, t as caps, tt as buildThreads, u as searchSegmentsForRange, ut as UNKNOWN_WEAK_ANNOTATION_STATE, v as buildSnippet, vt as DEFAULT_PDF_SAVE_MODE, w as foldOptionsFor, x as matchRegex, y as matchPageText, yt as createPageImageHandle, z as worstVerdict } from "./builders-Dqo2X-dt.js";
-import { _ as pdfRectSize, a as deserializeError, c as glyphLooseBounds, d as normalizePdfRect, f as pdfQuadBounds, g as pdfRectHeight, h as pdfRectFromOriginSize, i as EngineError, l as glyphLooseQuad, m as pdfQuadFromCorners, n as foldText, o as serializeError, p as pdfQuadCorners, r as toOriginalRange, s as _defineProperty, t as SEARCH_FOLD_VERSION, u as isRotatedGeometryRun, v as pdfRectToOriginSize, y as pdfRectWidth } from "./fold-CdEJTBTn.js";
-import { a as charRangeForTextOffsets, c as PDF_CODE_TO_SUBTYPE, d as subtypeFromCode, f as EngineErrorCode, i as charMapViolation, l as PDF_SUBTYPE_TO_CODE, n as boundaryTextOffset, o as sliceTextByChars, r as charBoundaryAtTextOffset, s as ANNOTATION_SUBTYPES, t as PAGE_INSERT_BLANK_MAX_COUNT, u as PdfAnnotationSubtypeCode } from "./PageInsertBlankInput-cHq9-i-z.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-DHqPBnYc.js";
-//#region src/promise/AbortablePromise.ts
-let _Symbol$species;
-_Symbol$species = Symbol.species;
+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 pdfAppearanceTurnOf, A as createPdfTextLayout, At as renderTargetArea, B as mapActionNode, C as resolveAnnotationPatch, Ct as pageQuadOf, D as pageGeometryOf, Dt as pageTransform, E as createTextLayout, Et as pdfRectOf, F as pdfAnnotationOf, G as mapLinkTarget, H as mapAnnotationActions, I as pdfAnnotationPatchOf, J as pageDestinationOf, K as mapPageActions, L as pageMeasureOf, M as pageAnnotationOf, Mt as renderSize, N as pageAnnotationPatchOf, O as pageSearchSliceOf, Ot as renderAreaTransform, P as pdfAnnotationDraftOf, R as pageViewportsOf, S as resolveAnnotationDraft, St as pagePointOf, T as shapeForRect, Tt as pdfQuadOf, U as mapDocumentActions, V as mapActionTree, W as mapFieldActions, X as ANNOTATION_DEFAULTS, Y as pdfDestinationOf, Z as annotationDefaultsOf, _ as pagePointUnturned, _t as isAbortError, a as squareMetres, at as DEFAULT_BUNDLE_LIMITS, b as pageTurnOfDrawn, bt as isRotatedGeometryRun, c as foldText, ct as ANNOTATION_RESOURCE_ROLE_NAMES, d as appearanceTurnOf, dt as hasAnnotationResources, et as toAttachmentRef, f as applyAnnotationPatch, ft as resolveAnnotationResources, g as pagePointTurned, gt as AbortError, h as pageGlyphLooseQuad, ht as resolveBinarySource, i as areaUnitLabel, it as bundleCodec, j as pageAnnotationDraftOf, jt as renderTransform, k as pageTextSegmentOf, kt as renderMatrix, l as toOriginalRange, lt as annotationResourceBuffers, m as pageGlyphLooseBounds, mt as sniffBinaryMetadata, n as measureFromRatio, nt as assertAnnotationBundle, o as squareOf, ot as assertWithinLimit, p as drawnPointsOf, pt as withFileFromResource, r as METRES, rt as assertAnnotationBundleManifest, s as SEARCH_FOLD_VERSION, st as manifestBytesOf, t as measureFromKnownLength, tt as AnnotationTransfer, u as annotationOfDraft, ut as assertAnnotationResources, v as pagePointsBounds, vt as glyphLooseBounds, w as resolveRectCommand, wt as pdfPointOf, x as pageTurnOfUpright, xt as pageBoxOf, y as pageQuadBounds, yt as glyphLooseQuad, z as pdfMeasureOf } from "./calibrate-7T3fnP8-.js";
+import { $ as pageListOf, A as sameEffectiveValue, B as refsOf, C as searchQueryOf, D as restrictionsFor, E as USAGE_INCOMPLETE, F as worstVerdict, G as pageFormFieldOf, H as placedWidgetOf, I as changedKeys, J as pdfFormFieldDraftOf, K as pageFormSnapshotOf, L as dictEntries, M as combine, N as conclude, O as evaluateStep, P as primaryFinding, Q as pageLayoutOf, R as parsePdfValue, S as matchPageText, T as EdgeResolver, U as draftWritesScripts, V as stableStringify, W as pageFieldActionsOf, X as pageAppearancesOf, Y as pdfWidgetPlacementOf, Z as pdfRenderTargetOf, _ as opIdOf, _t as DEFAULT_MEDIA_BOX, a as annotationWriteCapability, at as concatAnnotationLists, b as SEARCH_SNIPPET_CONTEXT, c as authorizeAnnotationUpdate, ct as normalizeAttachmentFileSource, d as authorizeFieldWrite, dt as generateUuidV7, et as pageSpaceBoxesOf, f as authorizeUnprotected, ft as DEFAULT_PDF_SAVE_MODE, g as isKeptRefusal, gt as resolvePageLayers, h as changeFingerprint, ht as imageSourceOfBytes, i as annotationWriteCapabilities, it as deletedAnnotationsOf, j as assessmentOf, k as restrictionsOf, l as authorizeCapability, lt as familyOfSubtype, m as decodePdfBits, mt as createPageImageHandle, n as allowsFieldWrite, nt as annotationPatchBetween, o as authorizeAnnotationCreate, ot as closeExportSelection, p as PDF_BITS, pt as checkImageQuality, q as pageWidgetOf, r as allowsSomeFieldWrite, rt as mergeAnnotationPatch, s as authorizeAnnotationDelete, st as annotationImportFacts, t as allowsCapability, tt as visibleBoxesOf, u as authorizeFieldGroup, ut as generateUuid, v as canonicalSearchQuery, vt as pageBoxesOf, w as DEFAULT_EDGE_RESOLVER_BUDGET, x as buildSnippet, y as searchContentEpoch, yt as pageRotationOf, z as pdfValueEquals } from "./authority-B3BklsB4.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-CzxmD9Ck.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-BJW13EGZ.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 { S as deletedAttachmentOf, _ 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, x as valueEntriesEqual, y as isAtDefault } from "./Change-CKoxfTNY.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-CNj0POeY.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-DV3J9lMz.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
+			}];
+		}
+	}
+}
+//#endregion
 //#region src/engine/document-security-state.ts
 function securityStateFromHead(head) {
 	return {
@@ -168,20 +358,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 +401,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 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;
+}
+/**
+* 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 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 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));
 }
 /**
-* 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.
+* 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 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 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 +497,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 +527,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 {
@@ -340,10 +559,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 +573,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, 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, 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, deriveProtection, deserializeError, dictEntries, encodeFieldRefKey, encodeStableIdKey, evaluateStep, expandRawScope, expandTextRangeToLine, expandTextRangeToWord, expandedCapabilities, fieldLockFor, filterMatches, foldOptionsFor, foldText, glyphLooseBounds, glyphLooseQuad, invalidatesWeakIndexRefs, isAbortError, isRotatedGeometryRun, isStateAnnotation, isValidPageObjectNumber, knownWeakAnnotationState, levelAllows, levelFromPermission, lockCovers, lockNameCovers, matchLiteral, matchPageText, matchRegex, materializePdfPermissions, minLevel, normalizeAnnotationDraft, normalizeAnnotationPatch, normalizeAttachmentFileSource, normalizePdfRect, parsePdfValue, parseScope, passwordPromptFromState, pdfPermissions, pdfQuadBounds, pdfQuadCorners, pdfQuadFromCorners, pdfRectFromOriginSize, pdfRectHeight, pdfRectSize, pdfRectToOriginSize, pdfRectWidth, pdfValueEquals, permissionInfoFromProbe, permissionInfoWithAdvisory, primaryFinding, protectedCapabilities, refKey, refsOf, resolveBinarySource, restrictionsFor, restrictionsOf, revisionTokensEqual, richTextParagraphsFromPlainText, richTextPlainText, sameEffectiveValue, searchContentEpoch, searchRectsForRange, searchSegmentsForRange, securityStateFromHead, securityStateFromProbe, semanticEqual, serializeError, shiftsExistingAnnotationIndices, sliceTextByChars, snapAppearanceScale, snapFullPageViewport, snapTileScale, sniffBinaryMetadata, stableStringify, subtypeFromCode, textGlyphAt, textGlyphQuad, textSegmentsForRange, toOriginalRange, validateScopeArray, validateSearchQuery, validateSearchRegex, 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, 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, PAGE_INSERT_BLANK_MAX_COUNT, PDF_BITS, PDF_CODE_TO_SUBTYPE, PDF_SUBTYPE_TO_CODE, 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, 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, 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, checkSetGroup, classifyRelation, clearlyOutranks, closeExportSelection, collab, collabTargetOf, colorOf, combine, compareIsoDateTime, concatAnnotationLists, conclude, createPageImageHandle, createPdfTextLayout, createTextLayout, decodeAnnotKey, decodeFieldRefKey, decodePageKey, decodePdfBits, decodeSubmitFormFlags, defaultEntryOfDraft, deletedAnnotationsOf, deletedAttachmentOf, deletedFieldOf, 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, mapPageActions, mapPageRefs, matchLiteral, matchPageText, matchRegex, materializePdfPermissions, measureFromKnownLength, measureFromRatio, measurementPoint, measurementReadout, mergeAnnotationPatch, minLevel, needsScriptRight, normalizeAttachmentFileSource, normalizePdfQuad, normalizePdfRect, objectNumbersIn, objectNumbersNamedBy, objectNumbersReferencedBy, opIdOf, pageAnnotationDraftOf, pageAnnotationOf, pageAnnotationPatchOf, pageAppearancesOf, pageBoxOf, pageBoxesOf, pageDestinationOf, pageFieldActionsOf, pageFormFieldOf, pageFormSnapshotOf, pageGeometryOf, pageGlyphLooseBounds, pageGlyphLooseQuad, pageLayoutOf, pageListOf, pageMeasureOf, pagePointOf, pagePointTurned, pagePointUnturned, pagePointsBounds, pageQuadBounds, pageQuadOf, pageRefsEqual, pageRefsIn, pageRotationOf, pageSearchSliceOf, pageSpaceBoxesOf, pageTextSegmentOf, pageTransform, pageTurnOfDrawn, pageTurnOfUpright, pageViewportsOf, pageWidgetOf, parseObjectNumberRanges, parsePdfValue, parseScope, passwordPromptFromState, pathLength, pdfAnnotationDraftOf, pdfAnnotationOf, pdfAnnotationPatchOf, pdfAppearanceTurnOf, pdfDestinationOf, pdfFormFieldDraftOf, pdfMeasureOf, 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, protectedCapabilities, quarterTurnOf, rank, refsOf, renderAreaTransform, renderMatrix, renderSize, renderTargetArea, renderTransform, reorderPart, reorderedList, resolveAnnotationDraft, resolveAnnotationPatch, resolveAnnotationResources, resolveBinarySource, resolveChangeResources, resolveMeasurementDraft, 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, toPageRef, topRowOf, touchesCaption, validAreaBoundary, validNumberFormat, validateScopeArray, validateSearchQuery, validateSearchRegex, valueEntriesEqual, viewportForPoint, visibleBoxesOf, widgetActionsOf, widgetAfterPatch, widgetsAfterDisplay, wirePack, withFileFromResource, wordAt, wordBefore, worstVerdict, writesScripts };
 
 //# sourceMappingURL=runtime.js.map