@embedpdf/engine-core 3.0.0-next.0

package/dist/runtime.d.cts

@@ -0,0 +1,1002 @@
+import { $a as AnnotationIdentityQuality, $i as LayerScopes, $n as searchRectsForRange, $o as pdfQuadCorners, $r as ListBoxFieldDraft, $s as revisionTokensEqual, Aa as EmbeddedFileItem, Ac as PdfSize, Ai as AnnotationCreateResult, An as HighlightDraft, Ao as PageImageHandle, Ar as FormFieldDeleteResult, As as filterMatches, At as LineDraft, B as StampAnnotationDTO, Ba as BinarySource, Bc as PdfPageActions, Bi as changesAnnotationList, Bn as PageFlattenStatus, Bo as PageRenderOptions, Br as FormFieldDisplay, Bs as CollabEntity, Bt as PolygonPatch, C as RedactDraft, Ca as GeometryStyleDraftFields, Cc as InkList, Ci as ToggleFieldWidget, Cn as UnderlineAnnotationDTO, Co as AnnotationAppearancesQuery, Cr as SearchQuery, Cs as CollabTarget, Ct as LinkAnnotationDTO, Da as AttachmentFileBase, Dc as PdfQuad, Di as FormWidgetRef, Do as WeakAnnotationState, Dr as SearchSnippet, Ds as checkSetGroup, E as WidgetDraft, Ea as AttachmentContent, Ec as PdfPoint, Ei as FormFieldRef, Eo as UNKNOWN_WEAK_ANNOTATION_STATE, Er as SearchSliceBudget, Es as checkCollab, Fa as normalizeAnnotationPatch, Fc as PdfActionTree, Fi as AppearanceImpact, Fn as RedactionApplyScope, Fo as PageNetworkRenderFormat, Fr as FormWidgetLinkResult, Fs as validateScopeArray, Ft as PolylineAnnotationDTO, Ga as ANNOTATION_SUBTYPES, Gi as CacheDelta, Gn as PageRotateResult, Go as PageGeometryGlyph, Gr as FormFieldPatch, Gs as ParsedCollab, Gt as VertexPatchFields, H as StampFit, Ha as WireResource, Hc as DocumentMetadataTrapped, Hi as shiftsExistingAnnotationIndices, Hn as PageInsertResult, Ho as PageRenderTarget, Hr as FormFieldValue, Hs as DocCapability, Ht as PolygonDraft, Ia as BinaryMetadata, Ic as PdfActionType, Ii as AppearanceOutcome, In as RedactionApplyStatus, Io as PageRaster, Ir as FormEffect, Is as PDF_BITS, It as PolylineDraft, J as TextPatch, Ja as PDF_SUBTYPE_TO_CODE, Ji as PdfLinkTargetWritable, Jn as PageMoveResult, Jo as PageTextSnapshot, Jr as TextFieldPatch, Js as ParsedWildcard, Ka as AnnotationSubtype, Ki as MutationMeta, Kn as PageRotateInput, Ko as PageGeometryRun, Kr as ListBoxFieldPatch, Ks as ParsedScope, La as BinaryMimeType, Lc as PdfActionWarning, Li as appearanceImpactOf, Ln as PageFlattenInput, Lo as PageRenderBackground, Lr as FormEffectResult, Ls as decodePdfBits, M as FileAttachmentPatch, Ma as NormalizedDraft, Mc as DocumentActionsSnapshot, Mi as AnnotationMoveResult, Mn as MetadataUpdateResult, Mo as PageImageOptions, Mr as FormImportResult, Ms as MissingIdentity, N as FileAttachmentAnnotationDTO, Na as NormalizedPatch, Nc as NamedJavaScriptAction, Ni as AnnotationUpdateResult, Nn as RedactionApplyItemResult, No as PageImageResult, Nr as FormRepairResult, Ns as PermissionDenied, Oa as AttachmentFileInfo, Oc as PdfRect, Oi as decodeFieldRefKey, On as HighlightPatch, Oo as knownWeakAnnotationState, Or as FormDataExport, Os as expandRawScope, Ot as LinePatch, Pa as normalizeAnnotationDraft, Pc as PdfActionNode, Pi as AppearanceAction, Pn as RedactionApplyResult, Po as PageImageSource, Pr as FormSetValueResult, Ps as parseScope, Pt as PolylinePatch, Qa as AnnotationBase, Qi as LayerScopePlane, Qn as searchContentEpoch, Qo as pdfQuadBounds, Qr as FormFieldOptionInput, Qs as RevisionToken, R as StampPatch, Ra as sniffBinaryMetadata, Rc as PdfAnnotationActions, Ri as semanticEqual, Rn as PageFlattenItemResult, Ro as PageRenderEncodedFormat, Rr as FormEffectStatus, Rs as AnnotationActor, S as RedactAnnotationDTO, Sa as FilledStylePatchFields, Sc as CalloutLine, Si as TextFieldDTO, Sn as UnderlinePatch, So as AnnotationAppearanceRenderOptions, Sr as SearchMode, Ss as pdfPermissions, St as LinkPatch, T as WidgetAnnotationDTO, Ta as GeometryStylePatchFields, Tc as LinePoints, Ti as FormValueEntry, To as PageState, Tr as SearchSlice, Ts as checkCapability, U as StampWireDraft, Ua as WireResourceMap, Ui as AnnotationListMutationMeta, Un as PageDeleteResult, Uo as PageRenderViewport, Ur as CheckboxFieldPatch, Us as IdentityClaims, Ut as VertexAnnotationFields, V as StampDraft, Va as ResourceRef, Vc as DocumentMetadata, Vi as invalidatesWeakIndexRefs, Vn as PageFlattenUsage, Vo as PageRenderQuery, Vr as FormDataFormat, Vs as CollabFilter, Vt as PolygonAnnotationDTO, Wa as resolveBinarySource, Wi as RefetchReason, Wn as PageDeleteInput, Wo as createPageImageHandle, Wr as ComboBoxFieldPatch, Ws as ParsedCapability, Wt as VertexDraftFields, X as NoteIcon, Xa as subtypeFromCode, Xi as DocumentManifest, Xn as PageMoveInput, Xo as PdfQuadCorners, Xr as ComboBoxFieldDraft, Xs as AnnotationDraftBase, Xt as SquareAnnotationDTO, Y as TextAnnotationDTO, Ya as PdfAnnotationSubtypeCode, Yi as PdfDestination, Yn as PageStructureCache, Yo as PdfOriginSize, Yr as CheckboxFieldDraft, Ys as PdfBits, Yt as SquarePatch, Z as TextDraft, Za as AnnotationPatchBase, Zi as ManifestPage, Zn as canonicalSearchQuery, Zo as normalizePdfRect, Zr as FormFieldDraft, Zs as AnnotationRef, Zt as SquareDraft, _a as ColorStyleDraftFields, _c as Rotation, _i as FormFieldOrigin, _n as SquigglyAnnotationDTO, _o as AnnotationAppearanceImagesResult, _r as SEARCH_FOLD_VERSION, _s as OpenOptions, aa as AnnotationKindModule, ac as BlendMode, ai as WidgetAppearance, an as ShapeDraftFields, ao as SerializedEngineError, ar as SearchQueryValidation, as as pdfRectWidth, b as UnsupportedAnnotationDTO, ba as FilledStyleDraftFields, bc as StrikeoutIntent, bi as RadioFieldDTO, bo as AnnotationAppearanceMode, br as toOriginalRange, bs as collab, c as AnnotationKind, ca as PatchOfKind, cc as FreeTextFont, ci as WidgetStyleFields, co as EngineErrorCode, cr as matchRegex, cs as PageLayout, ct as FreeTextAnnotationDTO, d as AnnotationSubtypeOfKind, da as AttachmentsCache, dc as LineEnding, di as ComboBoxFieldDTO, dn as StrikeoutAnnotationDTO, do as FontSpec, dr as foldOptionsFor, ds as OpenInput, ea as AnnotationRelationKind, ec as PageObjectNumber, ei as RadioFieldDraft, eo as AnnotationStableId, er as SEARCH_SNIPPET_CONTEXT, es as pdfQuadFromCorners, fa as normalizeAttachmentFileSource, fc as LineEndings, fi as FormFieldBase, fn as StrikeoutDraft, fo as DEFAULT_PDF_SAVE_MODE, fr as matchLiteral, fs as OpenInputById, ga as WireAttachmentFile, gc as Rect, gi as FormFieldOption, gn as SquigglyPatch, go as AnnotationAppearanceImageOptions, gr as FoldedText, gs as OpenInputToken, ha as FileAttachmentWireDraft, hc as Point, hi as FormFieldFlags, ho as AnnotationAppearanceImage, hr as FoldOptions, hs as OpenInputLayerSource, ht as InkDraft, i as AnnotationDTO, ia as refKey, ic as AnnotationReplyType, ii as FormSnapshot, in as ShapeAnnotationFields, io as EngineErrorOptions, ir as SearchQueryIssue, is as pdfRectToOriginSize, ja as EmbeddedFileRef, jc as ActionReadBudget, ji as AnnotationDeleteResult, jn as MetadataCache, jo as PageImageObjectUrl, jr as FormFieldUpdateResult, js as InvalidScope, ka as AttachmentFileSource, kc as PdfRotation, ki as encodeFieldRefKey, kn as HighlightAnnotationDTO, ko as PageImageBlobSource, kr as FormFieldCreateResult, ks as expandedCapabilities, kt as LineAnnotationDTO, l as AnnotationPatch, la as AttachmentCreateResult, lc as FreeTextIntent, li as WidgetStylePatchFields, lo as FontHandle, lr as validateSearchQuery, ls as PageRotation, lt as FreeTextDraft, m as WireAnnotationPatch, ma as FileAttachmentIcon, mc as PdfRectDifferences, mi as FormFieldFamily, mo as CachePins, mr as wordBefore, ms as OpenInputLayerBytes, mt as InkAnnotationDTO, n as AnnotationListSnapshotAllPages, na as buildThreads, nc as AnnotationBorderStyle, ni as WidgetPlacement, nn as CircleAnnotationDTO, no as encodeStableIdKey, nr as matchPageText, ns as pdfRectHeight, nt as CaretAnnotationDTO, o as AnnotationDraft, oa as DTOOfKind, oc as CaretIntent, on as ShapePatchFields, oo as deserializeError, or as SearchRegexIssue, os as PageListSnapshot, p as WireAnnotationDraft, pa as FileAttachmentDraft, pc as NO_ANNOTATION_FLAGS, pi as FormFieldDTO, po as PdfSaveMode, pr as wordAt, ps as OpenInputBytes, pt as InkPatch, qa as PDF_CODE_TO_SUBTYPE, qi as PdfLinkTarget, qn as PageMoveCache, qo as PageGeometrySnapshot, qr as RadioFieldPatch, qs as ParsedVirtual, ra as classifyRelation, rc as AnnotationFlags, ri as FormKind, rn as CircleDraft, ro as EngineError, rr as SEARCH_REGEX_MAX_LENGTH, rs as pdfRectSize, rt as CaretDraft, sa as DraftOfKind, sc as Color, si as WidgetStyleDraftFields, so as serializeError, sr as SearchRegexValidation, ss as PageBoxes, st as FreeTextPatch, t as AnnotationListPageSnapshot, ta as AnnotationThread, tc as isValidPageObjectNumber, ti as TextFieldDraft, tn as CirclePatch, to as decodeStableIdKey, tr as buildSnippet, ts as pdfRectFromOriginSize, tt as CaretPatch, ua as AttachmentDeleteResult, uc as InkIntent, ui as CheckboxFieldDTO, un as StrikeoutPatch, uo as FontKey, ur as validateSearchRegex, us as MetadataPatch, v as UnsupportedPatch, va as ColorStyleFields, vc as Size, vi as ListBoxFieldDTO, vn as SquigglyDraft, vo as AnnotationAppearanceManifest, vr as SearchMatchRange, vs as TokenSource, w as WidgetPatch, wa as GeometryStyleFields, wc as InkStroke, wi as UnknownFieldDTO, wn as UnderlineDraft, wo as AnnotationAppearancesResult, wr as SearchRequest, ws as checkAnyCapability, wt as LinkDraft, x as RedactPatch, xa as FilledStyleFields, xc as TextAlignment, xi as SignatureFieldDTO, xo as AnnotationAppearanceRaster, xr as SearchMatch, xs as materializePdfPermissions, y as UnsupportedDraft, ya as ColorStylePatchFields, yc as StandardFont, yi as PushButtonFieldDTO, yo as AnnotationAppearanceManifestEntry, yr as foldText, ys as caps, z as StampWirePatch, za as BinaryPayload, zc as PdfFieldActions, zi as AnnotationMutationKind, zn as PageFlattenResult, zo as PageRenderFormat, zr as FormEffectsResult, zs as CollabAction } from "./AnnotationListSnapshot-W0RCsyDE.cjs";
+import { a as DocumentEncryptionState, c as DocumentSecurityState, d as PdfPermissionAdvisory, f as PdfPermissionInfo, g as AbortablePromise, h as AbortableExecutor, i as DocumentAccessReason, l as DocumentUnlockInput, m as passwordPromptFromState, n as CdnAdapter, o as DocumentOpenMode, p as PasswordPrompt, r as DocumentAccessInfo, s as DocumentSecurityService, t as CdnAccessInfo, u as DocumentUnlockResult } from "./DocumentSecurityService-Df79fgpe.cjs";
+import { A as DocumentPagesService, C as CONTINUOUS_RENDER_POLICY, D as snapFullPageViewport, E as snapAppearanceScale, F as WeakAnnotationEditSession, I as DocumentActionsService, M as FormRepairOptions, N as DocumentAttachmentsService, O as snapTileScale, P as DocumentAnnotationsService, S as DocumentSearchService, T as EngineRenderPolicy, _ as PageTextService, a as DocumentHandle, b as PageAnnotationsService, c as DocumentEventInit, d as PageHandle, f as PieceInfoService, g as PieceInfoSnapshot, h as PieceInfoPatchValue, i as DocumentCapabilities, j as DocumentFormsService, k as DocumentRedactionService, l as DocumentEventType, m as PieceInfoPatch, n as EngineFactory, o as DocumentEventStream, p as PieceInfoEntry, r as FontService, s as DocumentEvent, t as Engine, u as EventOrigin, v as PageRenderService, w as DocumentRenderService, x as MetadataService, y as PageGeometryService } from "./Engine-D9loFZc1.cjs";
+//#region src/promise/AbortError.d.ts
+declare class AbortError extends Error {
+  readonly name = "AbortError";
+  readonly reason: unknown;
+  constructor(reason?: unknown);
+}
+declare function isAbortError(value: unknown): value is AbortError;
+//#endregion
+//#region src/wire/worker-protocol.d.ts
+/**
+ * Wire protocol used between an Engine-side queue and any Worker host
+ * (browser Web Worker, Node worker_thread, inline). Cloud HTTP traffic
+ * uses a different envelope; this is purely the worker boundary.
+ *
+ * Identical between @embedpdf/engine and @cloudpdf/server because
+ * the WorkerHost dispatch logic is the same on both sides — only the
+ * underlying PdfRuntimeModule (WASM vs native) differs.
+ */
+type WorkerJobId = number;
+interface OpenFatMemoryWorkerRequest {
+  kind: 'open.fatMem';
+  jobId: WorkerJobId;
+  docId: string;
+  bytes: ArrayBuffer;
+  password: string | null;
+}
+type LayerOpenSource = {
+  kind: 'fresh';
+} | {
+  kind: 'raw-delta';
+  bytes: ArrayBuffer;
+} | {
+  kind: 'artifact';
+  bytes: ArrayBuffer;
+} | {
+  kind: 'artifact-file';
+  path: string;
+};
+interface OpenLayerMemoryBaseWorkerRequest {
+  kind: 'open.layerMemBase';
+  jobId: WorkerJobId;
+  docId: string;
+  /**
+   * Omit for a handle whose docId already uniquely identifies the layer
+   * session. Cloud layer sessions supply a real layer name when multiple
+   * layer views must live under one docId.
+   */
+  layerName?: string;
+  baseKey: string;
+  baseBytes: ArrayBuffer;
+  layer: LayerOpenSource;
+  password: string | null;
+}
+interface OpenLayerFileBaseWorkerRequest {
+  kind: 'open.layerFileBase';
+  jobId: WorkerJobId;
+  docId: string;
+  /**
+   * Omit for the base-view session. Supplying a name opens a separate
+   * layer session under the same docId.
+   */
+  layerName?: string;
+  baseKey: string;
+  basePath: string;
+  layer: LayerOpenSource;
+  password: string | null;
+}
+type OpenWorkerRequest = OpenFatMemoryWorkerRequest | OpenLayerMemoryBaseWorkerRequest | OpenLayerFileBaseWorkerRequest;
+interface MetadataReadWorkerRequest {
+  kind: 'metadata.read';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+}
+interface MetadataUpdateWorkerRequest {
+  kind: 'metadata.update';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  patch: MetadataPatch;
+  artifactPath?: string;
+}
+interface ActionsReadWorkerRequest {
+  kind: 'actions.read';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+}
+interface AnnotationsListRawAllWorkerRequest {
+  kind: 'annotations.listRawAll';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+}
+interface AnnotationsListRawPageWorkerRequest {
+  kind: 'annotations.listRawPage';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  pageObjectNumber: PageObjectNumber;
+}
+interface AnnotationsListFullPageWorkerRequest {
+  kind: 'annotations.listFullPage';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  pageObjectNumber: PageObjectNumber;
+}
+/**
+ * Batch-render every annotation appearance stream on a page. Acquires a
+ * `pagePtr`, iterates `/Annots`, and renders each annotation's `/AP` via
+ * `EPDF_RenderAnnotBitmap` into its own raster. Read-only; gated on the
+ * render capability like `pages.render`.
+ */
+interface AnnotationsRenderAppearancesWorkerRequest {
+  kind: 'annotations.renderAppearances';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  pageObjectNumber: PageObjectNumber;
+  options?: AnnotationAppearanceRenderOptions;
+}
+interface AnnotationsCreateWorkerRequest {
+  kind: 'annotations.create';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  pageObjectNumber: PageObjectNumber;
+  /** WIRE form — binary fields hold `{ resource }` refs into {@link resources}. */
+  draft: WireAnnotationDraft;
+  /**
+   * Binary payloads referenced by the draft, keyed by resource key. The
+   * producer puts each `bytes` buffer on the wirePack transfer list
+   * (zero-copy, same convention as `PageRaster`).
+   */
+  resources?: WireResourceMap;
+  artifactPath?: string;
+  /**
+   * Identity to stamp on the newly created annotation:
+   *   - `displayName` → /T (PDF author field)
+   *   - `userId` / `groupId` → /EMBD_Metadata/{UserID,GroupID,CreatedBy,UpdatedBy}
+   * Optional — when absent (engine-local with no identity, anonymous tests),
+   * the worker still stamps the standard /M (modification date) but skips
+   * EMBD_Metadata.
+   */
+  actor?: AnnotationActor;
+}
+interface AnnotationsUpdateWorkerRequest {
+  kind: 'annotations.update';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  ref: AnnotationRef;
+  /** WIRE form — see {@link AnnotationsCreateWorkerRequest.draft}. */
+  patch: WireAnnotationPatch;
+  /** Binary payloads referenced by the patch — see the create request. */
+  resources?: WireResourceMap;
+  artifactPath?: string;
+  /**
+   * Identity of the editor. Drives /EMBD_Metadata/UpdatedBy refresh on
+   * update; preserves UserID/GroupID/CreatedBy. When absent, only /M
+   * is refreshed.
+   */
+  actor?: AnnotationActor;
+}
+interface AnnotationsDeleteWorkerRequest {
+  kind: 'annotations.delete';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  ref: AnnotationRef;
+  artifactPath?: string;
+}
+/**
+ * Batch annotation reorder. Refs are resolved on the worker BEFORE the
+ * move so the impact computation has a single before-state and one
+ * revision bump per batch.
+ */
+interface AnnotationsMoveWorkerRequest {
+  kind: 'annotations.move';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  pageObjectNumber: PageObjectNumber;
+  refs: AnnotationRef[];
+  toIndex: number;
+  artifactPath?: string;
+}
+/**
+ * Complete reconciled form snapshot. Cheap between mutations: the worker
+ * caches the underlying EPDFForm model keyed on the session's mutation
+ * counter and rebuilds only after a write.
+ */
+interface FormsListWorkerRequest {
+  kind: 'forms.list';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+}
+interface FormsSetValueWorkerRequest {
+  kind: 'forms.setValue';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  ref: FormFieldRef;
+  value: FormFieldValue;
+  artifactPath?: string;
+}
+interface FormsResetWorkerRequest {
+  kind: 'forms.reset';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  ref: FormFieldRef;
+  artifactPath?: string;
+}
+interface FormsApplyEffectsWorkerRequest {
+  kind: 'forms.applyEffects';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  effects: FormEffect[];
+  artifactPath?: string;
+}
+interface FormsExportWorkerRequest {
+  kind: 'forms.export';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  format: FormDataFormat;
+}
+interface FormsImportWorkerRequest {
+  kind: 'forms.import';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  /** FDF or XFDF payload; goes on the wirePack transfer list (zero-copy). */
+  data: ArrayBuffer;
+  /** Sniffed from the bytes when omitted. */
+  format?: FormDataFormat;
+  artifactPath?: string;
+}
+interface FormsRepairWorkerRequest {
+  kind: 'forms.repair';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  bakeAppearances?: boolean;
+  artifactPath?: string;
+}
+interface FormsCreateFieldWorkerRequest {
+  kind: 'forms.createField';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  draft: FormFieldDraft;
+  artifactPath?: string;
+}
+interface FormsUpdateFieldWorkerRequest {
+  kind: 'forms.updateField';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  ref: FormFieldRef;
+  patch: FormFieldPatch;
+  artifactPath?: string;
+}
+interface FormsDeleteFieldWorkerRequest {
+  kind: 'forms.deleteField';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  ref: FormFieldRef;
+  artifactPath?: string;
+}
+interface FormsAttachWidgetWorkerRequest {
+  kind: 'forms.attachWidget';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  ref: FormFieldRef;
+  widget: FormWidgetRef;
+  onState?: string;
+  artifactPath?: string;
+}
+interface FormsDetachWidgetWorkerRequest {
+  kind: 'forms.detachWidget';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  ref: FormFieldRef;
+  widget: FormWidgetRef;
+  artifactPath?: string;
+}
+interface PagesListWorkerRequest {
+  kind: 'pages.list';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+}
+/**
+ * Per-page plain-text extraction. Acquires a pagePtr and runs PDFium's
+ * `FPDFText_LoadPage` → `FPDFText_GetText` chain. Identical to
+ * `annotations.listFullPage` in shape; both are slow-path per-page
+ * reads keyed by indirect object number.
+ */
+interface PagesTextWorkerRequest {
+  kind: 'pages.text';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  pageObjectNumber: PageObjectNumber;
+}
+interface PagesGeometryWorkerRequest {
+  kind: 'pages.geometry';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  pageObjectNumber: PageObjectNumber;
+}
+/**
+ * One budgeted search slice (see `DocumentSearchService`). Read-only: the
+ * worker's per-page corpus cache is version-keyed on the session mutation
+ * counter, so repeated slices between mutations reuse extracted text.
+ */
+interface SearchQueryWorkerRequest {
+  kind: 'search.query';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  request: SearchRequest;
+}
+interface PagesRenderWorkerRequest {
+  kind: 'pages.render';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  pageObjectNumber: PageObjectNumber;
+  options?: PageRenderOptions;
+}
+/**
+ * One-shot file render — open the base document from a file path, render
+ * ONE page by display index, close. No session is bound (the ingestion
+ * `runAdHoc` pattern, like `document.probeSecurityFile`): this is the
+ * derived-artifact warmer's producer, used when no live document session
+ * exists yet. The payload reports the page's durable object number so the
+ * caller can key the artifact it persists.
+ */
+interface DocumentRenderPageFileWorkerRequest {
+  kind: 'document.renderPageFile';
+  jobId: WorkerJobId;
+  path: string;
+  password: string | null;
+  /** Display index (0-based) — ingest knows "first page", not object numbers. */
+  pageIndex: number;
+  options?: PageRenderOptions;
+}
+interface PagesMoveWorkerRequest {
+  kind: 'pages.move';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  pageObjectNumbers: PageObjectNumber[];
+  destIndex: number;
+  artifactPath?: string;
+}
+interface PagesRotateWorkerRequest {
+  kind: 'pages.rotate';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  pageObjectNumbers: PageObjectNumber[];
+  /** Absolute rotation in degrees clockwise — see `PageRotateInput`. */
+  rotation: PageRotation;
+  artifactPath?: string;
+}
+interface PagesDeleteWorkerRequest {
+  kind: 'pages.delete';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  pageObjectNumbers: PageObjectNumber[];
+  artifactPath?: string;
+}
+interface PagesFlattenWorkerRequest {
+  kind: 'pages.flatten';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  pageObjectNumbers: PageObjectNumber[];
+  usage: PageFlattenUsage;
+  artifactPath?: string;
+}
+interface RedactionApplyWorkerRequest {
+  kind: 'redaction.apply';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  scope: RedactionApplyScope;
+  artifactPath?: string;
+}
+/** Export the given pages as a standalone PDF (a read — the source
+ *  session is untouched, so no layer artifact rides the result). */
+interface PagesExtractWorkerRequest {
+  kind: 'pages.extract';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  pageObjectNumbers: PageObjectNumber[];
+}
+/** List the document catalog's `/EmbeddedFiles` name tree (a read). */
+interface AttachmentsListWorkerRequest {
+  kind: 'attachments.list';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+}
+/**
+ * Decode one document-level embedded file (a read — no revision bump, no
+ * layer artifact). Two delivery modes, the `artifactPath?` pattern:
+ * `path` absent → browser mode, decoded bytes ride the transfer list;
+ * `path` present → server mode, the worker streams the decoded file to
+ * that path (`EPDFAttachment_ExtractFile` + `FPDF_FILEWRITE`) so the
+ * payload never crosses the thread boundary and HTTP can stream it from
+ * disk with backpressure.
+ */
+interface AttachmentsReadFileWorkerRequest {
+  kind: 'attachments.readFile';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  ref: EmbeddedFileRef;
+  path?: string;
+  /** Decompression-bomb cap forwarded to the runtime. Absent/0 = unlimited. */
+  maxDecodedBytes?: number;
+}
+/**
+ * Create a document-level embedded file (a MUTATION — layer sessions
+ * persist an artifact). `file` is the same post-normalization wire shape
+ * the file-attachment annotation draft uses: metadata in JSON, bytes
+ * out-of-band under the referenced resource key. `file.name` becomes the
+ * name-tree key.
+ */
+interface AttachmentsCreateWorkerRequest {
+  kind: 'attachments.create';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  file: WireAttachmentFile;
+  /** Binary payload referenced by `file.resource` — transfer-list bytes. */
+  resources?: WireResourceMap;
+  artifactPath?: string;
+}
+/** Delete a document-level embedded file by key (a MUTATION). */
+interface AttachmentsDeleteWorkerRequest {
+  kind: 'attachments.delete';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  ref: EmbeddedFileRef;
+  artifactPath?: string;
+}
+/** Decode the file embedded in a FileAttachment annotation's `/FS`.
+ *  Same read semantics and delivery modes as `attachments.readFile`. */
+interface AnnotationsReadFileWorkerRequest {
+  kind: 'annotations.readFile';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  pageObjectNumber: PageObjectNumber;
+  ref: AnnotationRef;
+  path?: string;
+  /** Decompression-bomb cap forwarded to the runtime. Absent/0 = unlimited. */
+  maxDecodedBytes?: number;
+}
+/** Insert every page of a standalone PDF (transferable `bytes`) at
+ *  `destIndex` (omitted → append). A structural MUTATION: layer sessions
+ *  persist an artifact like move/rotate/delete. */
+interface PagesInsertWorkerRequest {
+  kind: 'pages.insert';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  bytes: ArrayBuffer;
+  destIndex?: number;
+  artifactPath?: string;
+}
+/**
+ * `/PieceInfo` private application data (ISO 32000 §14.5). One job family
+ * serves both levels: `pageObjectNumber` present → the page's `/PieceInfo`,
+ * absent → the document catalog's — mirroring the native API symmetry.
+ * `update`/`clear` are mutations (a layer session persists an artifact);
+ * `read`/`applications` are plain reads.
+ */
+interface PieceInfoReadWorkerRequest {
+  kind: 'pieceInfo.read';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  pageObjectNumber?: PageObjectNumber;
+  application: string;
+}
+interface PieceInfoUpdateWorkerRequest {
+  kind: 'pieceInfo.update';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  pageObjectNumber?: PageObjectNumber;
+  application: string;
+  patch: PieceInfoPatch;
+  artifactPath?: string;
+}
+interface PieceInfoApplicationsWorkerRequest {
+  kind: 'pieceInfo.applications';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  pageObjectNumber?: PageObjectNumber;
+}
+interface PieceInfoClearWorkerRequest {
+  kind: 'pieceInfo.clear';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  pageObjectNumber?: PageObjectNumber;
+  application: string;
+  artifactPath?: string;
+}
+interface DocumentSaveBufferWorkerRequest {
+  kind: 'document.saveBuffer';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  mode: PdfSaveMode;
+}
+interface DocumentSaveFileWorkerRequest {
+  kind: 'document.saveFile';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  mode: PdfSaveMode;
+  path: string;
+}
+/** Export JUST the layer artifact (the overlay diff) to a transferable buffer.
+ *  Layer sessions only; the host rejects a base-only session. */
+interface DocumentSaveLayerBufferWorkerRequest {
+  kind: 'document.saveLayerBuffer';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+}
+interface DocumentSecurityProbeInfo {
+  encryptionState: 'unknown' | 'none' | 'encrypted' | 'unsupported';
+  encryptionRequiresPassword: boolean | null;
+  securityHandlerRevision: number | null;
+  pdfPermissionsBits: number | null;
+  pdfPermissionsAllAllowed: boolean | null;
+  pdfOpenedAs: 'none' | 'user' | 'owner' | null;
+  securityProbedAt: number | null;
+}
+interface DocumentProbeSecurityFileWorkerRequest {
+  kind: 'document.probeSecurityFile';
+  jobId: WorkerJobId;
+  path: string;
+  password: string | null;
+}
+interface DocumentCheckPasswordPermissionsWorkerRequest {
+  kind: 'document.checkPasswordPermissions';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName?: string;
+  password: string;
+  mode?: 'any' | 'owner';
+}
+/**
+ * Register a runtime font on the host's PDFium thread. Carries the font bytes
+ * as a transferable `ArrayBuffer` (declared in the producer's transfer
+ * manifest, like `open.fatMem`). Runtime-global: not tied to any docId. The
+ * host keeps the volatile native `FontId` keyed by `fontKey`; the wire only
+ * ever references the stable `fontKey`.
+ */
+interface FontsRegisterWorkerRequest {
+  kind: 'fonts.register';
+  jobId: WorkerJobId;
+  fontKey: string;
+  /** `""` → infer the base font name from the file. */
+  familyName: string;
+  /** `0` → infer the weight from the file. */
+  weight: number;
+  /** `-1` → infer / `0` non-italic / `1` italic. */
+  italic: number;
+  data: ArrayBuffer;
+}
+interface FontsAddFallbackWorkerRequest {
+  kind: 'fonts.addFallback';
+  jobId: WorkerJobId;
+  fontKey: string;
+}
+interface FontsClearFallbacksWorkerRequest {
+  kind: 'fonts.clearFallbacks';
+  jobId: WorkerJobId;
+}
+interface FontsClearWorkerRequest {
+  kind: 'fonts.clear';
+  jobId: WorkerJobId;
+}
+interface CloseWorkerRequest {
+  kind: 'close';
+  jobId: WorkerJobId;
+  docId: string;
+}
+/**
+ * Close exactly ONE layer session, leaving the base document, sibling
+ * layer sessions, and the caller's doc↔worker binding intact. Idempotent:
+ * closing an absent session is a no-op ack.
+ *
+ * This is the reload seam for layer-session freshness (the server closes
+ * a stale layer session and re-opens it from the current durable
+ * artifact) — `close` is the whole-document teardown, this is the
+ * layer-scoped sibling.
+ */
+interface LayerCloseWorkerRequest {
+  kind: 'layer.close';
+  jobId: WorkerJobId;
+  docId: string;
+  layerName: string;
+}
+interface AbortWorkerRequest {
+  kind: 'abort';
+  jobId: WorkerJobId;
+}
+interface ShutdownWorkerRequest {
+  kind: 'shutdown';
+  jobId: WorkerJobId;
+}
+interface LayerArtifactWorkerPayload {
+  bytes: ArrayBuffer;
+  size: number;
+}
+/**
+ * Result of an attachment file read (`attachments.readFile` /
+ * `annotations.readFile`): the decoded file's metadata plus exactly one
+ * delivery mode, mirroring the request's `path?` — `bytes` on the
+ * transfer list (browser), or the `path` the worker wrote (server).
+ */
+interface AttachmentFileWorkerPayload {
+  name: string;
+  mimeType?: string;
+  size: number;
+  bytes?: ArrayBuffer;
+  path?: string;
+}
+interface LayerArtifactFileWorkerPayload {
+  path: string;
+}
+type WorkerRequest = OpenWorkerRequest | MetadataReadWorkerRequest | MetadataUpdateWorkerRequest | ActionsReadWorkerRequest | AnnotationsListRawAllWorkerRequest | AnnotationsListRawPageWorkerRequest | AnnotationsListFullPageWorkerRequest | AnnotationsRenderAppearancesWorkerRequest | AnnotationsCreateWorkerRequest | AnnotationsUpdateWorkerRequest | AnnotationsDeleteWorkerRequest | AnnotationsMoveWorkerRequest | FormsListWorkerRequest | FormsSetValueWorkerRequest | FormsResetWorkerRequest | FormsApplyEffectsWorkerRequest | FormsExportWorkerRequest | FormsImportWorkerRequest | FormsRepairWorkerRequest | FormsCreateFieldWorkerRequest | FormsUpdateFieldWorkerRequest | FormsDeleteFieldWorkerRequest | FormsAttachWidgetWorkerRequest | FormsDetachWidgetWorkerRequest | PagesListWorkerRequest | PagesMoveWorkerRequest | PagesRotateWorkerRequest | PagesDeleteWorkerRequest | PagesFlattenWorkerRequest | RedactionApplyWorkerRequest | PagesExtractWorkerRequest | PagesInsertWorkerRequest | AttachmentsListWorkerRequest | AttachmentsReadFileWorkerRequest | AttachmentsCreateWorkerRequest | AttachmentsDeleteWorkerRequest | AnnotationsReadFileWorkerRequest | PieceInfoReadWorkerRequest | PieceInfoUpdateWorkerRequest | PieceInfoApplicationsWorkerRequest | PieceInfoClearWorkerRequest | PagesTextWorkerRequest | PagesGeometryWorkerRequest | PagesRenderWorkerRequest | SearchQueryWorkerRequest | DocumentSaveBufferWorkerRequest | DocumentSaveFileWorkerRequest | DocumentSaveLayerBufferWorkerRequest | DocumentProbeSecurityFileWorkerRequest | DocumentRenderPageFileWorkerRequest | DocumentCheckPasswordPermissionsWorkerRequest | FontsRegisterWorkerRequest | FontsAddFallbackWorkerRequest | FontsClearFallbacksWorkerRequest | FontsClearWorkerRequest | CloseWorkerRequest | LayerCloseWorkerRequest | AbortWorkerRequest | ShutdownWorkerRequest;
+type WorkerResultPayload = {
+  tag: 'open';
+  docId: string;
+  security: DocumentSecurityProbeInfo;
+} | {
+  tag: 'metadata.read';
+  metadata: DocumentMetadata;
+} | {
+  tag: 'actions.read';
+  snapshot: DocumentActionsSnapshot;
+} | {
+  tag: 'metadata.update';
+  result: MetadataUpdateResult;
+  artifact?: LayerArtifactWorkerPayload;
+  artifactFile?: LayerArtifactFileWorkerPayload;
+} | {
+  tag: 'annotations.listRawAll';
+  snapshot: AnnotationListSnapshotAllPages;
+} | {
+  tag: 'annotations.listRawPage';
+  snapshot: AnnotationListPageSnapshot;
+} | {
+  tag: 'annotations.listFullPage';
+  snapshot: AnnotationListPageSnapshot;
+} | {
+  tag: 'annotations.renderAppearances';
+  result: AnnotationAppearancesResult;
+} | {
+  tag: 'annotations.create';
+  result: AnnotationCreateResult;
+  artifact?: LayerArtifactWorkerPayload;
+  artifactFile?: LayerArtifactFileWorkerPayload;
+} | {
+  tag: 'annotations.update';
+  result: AnnotationUpdateResult;
+  artifact?: LayerArtifactWorkerPayload;
+  artifactFile?: LayerArtifactFileWorkerPayload;
+} | {
+  tag: 'annotations.delete';
+  result: AnnotationDeleteResult;
+  artifact?: LayerArtifactWorkerPayload;
+  artifactFile?: LayerArtifactFileWorkerPayload;
+} | {
+  tag: 'annotations.move';
+  result: AnnotationMoveResult;
+  artifact?: LayerArtifactWorkerPayload;
+  artifactFile?: LayerArtifactFileWorkerPayload;
+} | {
+  tag: 'forms.list';
+  snapshot: FormSnapshot;
+} | {
+  tag: 'forms.setValue';
+  result: FormSetValueResult;
+  artifact?: LayerArtifactWorkerPayload;
+  artifactFile?: LayerArtifactFileWorkerPayload;
+} | {
+  tag: 'forms.reset';
+  result: FormSetValueResult;
+  artifact?: LayerArtifactWorkerPayload;
+  artifactFile?: LayerArtifactFileWorkerPayload;
+} | {
+  tag: 'forms.applyEffects';
+  result: FormEffectsResult;
+  artifact?: LayerArtifactWorkerPayload;
+  artifactFile?: LayerArtifactFileWorkerPayload;
+} | {
+  tag: 'forms.export';
+  format: FormDataFormat;
+  bytes: ArrayBuffer;
+} | {
+  tag: 'forms.import';
+  result: FormImportResult;
+  artifact?: LayerArtifactWorkerPayload;
+  artifactFile?: LayerArtifactFileWorkerPayload;
+} | {
+  tag: 'forms.repair';
+  result: FormRepairResult;
+  artifact?: LayerArtifactWorkerPayload;
+  artifactFile?: LayerArtifactFileWorkerPayload;
+} | {
+  tag: 'forms.createField';
+  result: FormFieldCreateResult;
+  artifact?: LayerArtifactWorkerPayload;
+  artifactFile?: LayerArtifactFileWorkerPayload;
+} | {
+  tag: 'forms.updateField';
+  result: FormFieldUpdateResult;
+  artifact?: LayerArtifactWorkerPayload;
+  artifactFile?: LayerArtifactFileWorkerPayload;
+} | {
+  tag: 'forms.deleteField';
+  result: FormFieldDeleteResult;
+  artifact?: LayerArtifactWorkerPayload;
+  artifactFile?: LayerArtifactFileWorkerPayload;
+} | {
+  tag: 'forms.attachWidget';
+  result: FormWidgetLinkResult;
+  artifact?: LayerArtifactWorkerPayload;
+  artifactFile?: LayerArtifactFileWorkerPayload;
+} | {
+  tag: 'forms.detachWidget';
+  result: FormWidgetLinkResult;
+  artifact?: LayerArtifactWorkerPayload;
+  artifactFile?: LayerArtifactFileWorkerPayload;
+} | {
+  tag: 'pages.list';
+  snapshot: PageListSnapshot;
+} | {
+  tag: 'pages.move';
+  result: PageMoveResult;
+  artifact?: LayerArtifactWorkerPayload;
+  artifactFile?: LayerArtifactFileWorkerPayload;
+} | {
+  tag: 'pages.rotate';
+  result: PageRotateResult;
+  artifact?: LayerArtifactWorkerPayload;
+  artifactFile?: LayerArtifactFileWorkerPayload;
+} | {
+  tag: 'pages.delete';
+  result: PageDeleteResult;
+  artifact?: LayerArtifactWorkerPayload;
+  artifactFile?: LayerArtifactFileWorkerPayload;
+} | {
+  tag: 'pages.flatten';
+  result: PageFlattenResult;
+  artifact?: LayerArtifactWorkerPayload;
+  artifactFile?: LayerArtifactFileWorkerPayload;
+} | {
+  tag: 'redaction.apply';
+  result: RedactionApplyResult;
+  artifact?: LayerArtifactWorkerPayload;
+  artifactFile?: LayerArtifactFileWorkerPayload;
+} | {
+  tag: 'pages.extract';
+  bytes: ArrayBuffer;
+  size: number;
+} | {
+  tag: 'attachments.list';
+  items: EmbeddedFileItem[];
+} | {
+  tag: 'attachments.readFile';
+  content: AttachmentFileWorkerPayload;
+} | {
+  tag: 'attachments.create';
+  result: AttachmentCreateResult;
+  artifact?: LayerArtifactWorkerPayload;
+  artifactFile?: LayerArtifactFileWorkerPayload;
+} | {
+  tag: 'attachments.delete';
+  result: AttachmentDeleteResult;
+  artifact?: LayerArtifactWorkerPayload;
+  artifactFile?: LayerArtifactFileWorkerPayload;
+} | {
+  tag: 'annotations.readFile';
+  content: AttachmentFileWorkerPayload;
+} | {
+  tag: 'pages.insert';
+  result: PageInsertResult;
+  artifact?: LayerArtifactWorkerPayload;
+  artifactFile?: LayerArtifactFileWorkerPayload;
+} | {
+  tag: 'pieceInfo.read';
+  snapshot: PieceInfoSnapshot | null;
+} | {
+  tag: 'pieceInfo.update';
+  artifact?: LayerArtifactWorkerPayload;
+  artifactFile?: LayerArtifactFileWorkerPayload;
+} | {
+  tag: 'pieceInfo.applications';
+  applications: string[];
+} | {
+  tag: 'pieceInfo.clear';
+  artifact?: LayerArtifactWorkerPayload;
+  artifactFile?: LayerArtifactFileWorkerPayload;
+} | {
+  tag: 'pages.text';
+  snapshot: PageTextSnapshot;
+} | {
+  tag: 'pages.geometry';
+  snapshot: PageGeometrySnapshot;
+} | {
+  tag: 'pages.render';
+  raster: PageRaster;
+} | {
+  tag: 'search.query';
+  slice: SearchSlice;
+} | {
+  tag: 'document.saveBuffer';
+  bytes: ArrayBuffer;
+  size: number;
+} | {
+  tag: 'document.saveLayerBuffer';
+  bytes: ArrayBuffer;
+  size: number;
+} | {
+  tag: 'document.saveFile';
+  path: string;
+} | {
+  tag: 'document.probeSecurityFile';
+  security: DocumentSecurityProbeInfo;
+} | {
+  tag: 'document.renderPageFile';
+  /** Durable page identity of the rendered index — the artifact key's pon. */
+  pageObjectNumber: PageObjectNumber;
+  pageCount: number;
+  raster: PageRaster;
+} | {
+  tag: 'document.checkPasswordPermissions';
+  security: DocumentSecurityProbeInfo;
+} | {
+  tag: 'fonts.register';
+  fontKey: string;
+} | {
+  tag: 'fonts.addFallback';
+} | {
+  tag: 'fonts.clearFallbacks';
+} | {
+  tag: 'fonts.clear';
+} | {
+  tag: 'close';
+} | {
+  tag: 'shutdown';
+};
+type WorkerResponse = {
+  kind: 'resolve';
+  jobId: WorkerJobId;
+  result: WorkerResultPayload;
+} | {
+  kind: 'reject';
+  jobId: WorkerJobId;
+  error: SerializedEngineError;
+};
+type WorkerLifecycleMessage = {
+  kind: 'ready';
+} | {
+  kind: 'init-error';
+  error: string;
+};
+//#endregion
+//#region src/engine/document-security-state.d.ts
+interface DocumentHeadLike {
+  encryption: {
+    state: DocumentSecurityState['encryption']['state'];
+    requiresPassword: boolean | null;
+  };
+  permissions: DocumentSecurityState['permissions'];
+  access: DocumentSecurityState['access'];
+}
+declare function securityStateFromHead(head: DocumentHeadLike): DocumentSecurityState;
+declare function permissionInfoFromProbe(info: DocumentSecurityProbeInfo): PdfPermissionInfo | null;
+/**
+ * Same as {@link permissionInfoFromProbe} but additionally populates
+ * `flags` (typed PdfBits view) and `advisory` (capability-shaped
+ * booleans for UI badges). Used by routes that have a decoded `PdfBits`
+ * in hand — notably `/access`, which always does.
+ *
+ * Returns `null` for the same reason as the base function — when the
+ * PDF hasn't been probed yet so bits are unknown.
+ */
+declare function permissionInfoWithAdvisory(info: DocumentSecurityProbeInfo, pdfBits: PdfBits): PdfPermissionInfo | null;
+/**
+ * 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.
+ */
+declare function advisoryFromPdfBits(b: PdfBits): PdfPermissionAdvisory;
+declare function securityStateFromProbe(info: DocumentSecurityProbeInfo, opts?: {
+  accessEndpoint?: string;
+  cdnRequired?: boolean;
+}): DocumentSecurityState;
+//#endregion
+//#region src/wire/WirePack.d.ts
+/**
+ * Wire-level packaging for messages crossing a Web Worker / Node
+ * `worker_thread` boundary.
+ *
+ * `WirePack<P>` is the typed pair every producer hands to a transport:
+ * the structured payload (validated against the wire schema) and an
+ * explicit, ordered list of `Transferable` objects that the producer
+ * intends to move (zero-copy) to the receiver.
+ *
+ * Why this is a first-class type and not a transport-side argument:
+ *
+ *   - **Producer is the only one who knows.** Whether a particular
+ *     `ArrayBuffer` should be moved (zero-copy, sender's reference
+ *     detached) or copied (structured-cloned, both sides retain
+ *     access) is a semantic decision belonging to the code that
+ *     produced the buffer. Inferring it later — by walking the
+ *     payload looking for `ArrayBuffer` instances and assuming they
+ *     should all be transferred — is the v2 footgun this design
+ *     replaces.
+ *
+ *   - **Type-checked at the boundary.** A handler returning
+ *     `WirePack<RenderResult>` cannot forget to declare its
+ *     transfer list; the producer literally writes
+ *     `wirePack({ ..., pixels }, [pixels.buffer])` in a single
+ *     return statement. Forgetting yields a structurally identical
+ *     copy (slow but correct), never a silent leak.
+ *
+ *   - **Symmetric across the boundary.** Same `WirePack<P>` on the
+ *     request path (main → worker) and the response path (worker →
+ *     main). Inline transports treat `transfer` as a no-op since
+ *     there's no thread boundary to cross.
+ *
+ *   - **Schema-orthogonal.** Zod schemas validate `payload` and
+ *     nothing else. `transfer` is not data; it's a memory-ownership
+ *     manifest, and the design keeps those concerns separate.
+ *
+ * The receiver of a `postMessage(payload, { transfer })` call gets
+ * the payload back **with the listed buffers already moved into it**
+ * — there's no second argument on the receiving end. So `WirePack`
+ * only ever travels the producer-to-transport leg of the trip; the
+ * consumer side just sees the unwrapped `payload`.
+ */
+interface WirePack<P> {
+  readonly payload: P;
+  readonly transfer: readonly Transferable[];
+}
+/**
+ * Singleton empty transfer list. Frozen so accidental in-place
+ * mutation throws in strict mode rather than silently mutating the
+ * default for future calls.
+ */
+declare const EMPTY_TRANSFER: readonly Transferable[];
+/**
+ * Producer-side helper: pair a typed payload with its transfer list.
+ *
+ * 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.
+ *
+ *   wirePack({ kind: 'metadata.read', jobId, docId })
+ *   wirePack({ kind: 'open.fatMem', jobId, docId, bytes }, [bytes])
+ *   wirePack({ tag: 'page.render', pixels }, [pixels.buffer])
+ */
+declare function wirePack<P>(payload: P, transfer?: readonly Transferable[]): WirePack<P>;
+//#endregion
+export { ANNOTATION_SUBTYPES, AbortError, type AbortWorkerRequest, type AbortableExecutor, AbortablePromise, type ActionReadBudget, type ActionsReadWorkerRequest, type AnnotationActor, type AnnotationAppearanceImage, type AnnotationAppearanceImageOptions, type AnnotationAppearanceImagesResult, type AnnotationAppearanceManifest, type AnnotationAppearanceManifestEntry, type AnnotationAppearanceMode, type AnnotationAppearanceRaster, type AnnotationAppearanceRenderOptions, type AnnotationAppearancesQuery, type AnnotationAppearancesResult, type AnnotationBase, type AnnotationBorderStyle, type AnnotationCreateResult, type AnnotationDTO, type AnnotationDeleteResult, type AnnotationDraft, type AnnotationDraftBase, type AnnotationFlags, type AnnotationIdentityQuality, type AnnotationKind, type AnnotationKindModule, type AnnotationListMutationMeta, type AnnotationListPageSnapshot, type AnnotationListSnapshotAllPages, type AnnotationMoveResult, type AnnotationMutationKind, type AnnotationPatch, type AnnotationPatchBase, type AnnotationRef, type AnnotationRelationKind, type AnnotationReplyType, type AnnotationStableId, type AnnotationSubtype, type AnnotationSubtypeOfKind, type AnnotationThread, type AnnotationUpdateResult, type AnnotationsCreateWorkerRequest, type AnnotationsDeleteWorkerRequest, type AnnotationsListFullPageWorkerRequest, type AnnotationsListRawAllWorkerRequest, type AnnotationsListRawPageWorkerRequest, type AnnotationsMoveWorkerRequest, type AnnotationsReadFileWorkerRequest, type AnnotationsRenderAppearancesWorkerRequest, type AnnotationsUpdateWorkerRequest, type AppearanceAction, type AppearanceImpact, type AppearanceOutcome, type AttachmentContent, type AttachmentCreateResult, type AttachmentDeleteResult, type AttachmentFileBase, type AttachmentFileInfo, type AttachmentFileSource, type AttachmentFileWorkerPayload, type AttachmentsCache, type AttachmentsCreateWorkerRequest, type AttachmentsDeleteWorkerRequest, type AttachmentsListWorkerRequest, type AttachmentsReadFileWorkerRequest, type BinaryMetadata, type BinaryMimeType, type BinaryPayload, type BinarySource, type BlendMode, CONTINUOUS_RENDER_POLICY, type CacheDelta, type CachePins, type CalloutLine, type CaretAnnotationDTO, type CaretDraft, type CaretIntent, type CaretPatch, type CdnAccessInfo, type CdnAdapter, type CheckboxFieldDTO, type CheckboxFieldDraft, type CheckboxFieldPatch, type CircleAnnotationDTO, type CircleDraft, type CirclePatch, type CloseWorkerRequest, type CollabAction, type CollabEntity, type CollabFilter, type CollabTarget, type Color, type ColorStyleDraftFields, type ColorStyleFields, type ColorStylePatchFields, type ComboBoxFieldDTO, type ComboBoxFieldDraft, type ComboBoxFieldPatch, DEFAULT_PDF_SAVE_MODE, type DTOOfKind, type DocCapability, type DocumentAccessInfo, type DocumentAccessReason, type DocumentActionsService, type DocumentActionsSnapshot, type DocumentAnnotationsService, type DocumentAttachmentsService, type DocumentCapabilities, type DocumentCheckPasswordPermissionsWorkerRequest, type DocumentEncryptionState, type DocumentEvent, type DocumentEventInit, type DocumentEventStream, type DocumentEventType, type DocumentFormsService, type DocumentHandle, type IdentityClaims as DocumentIdentity, type IdentityClaims, type DocumentManifest, type DocumentMetadata, type DocumentMetadataTrapped, type DocumentOpenMode, type DocumentPagesService, type DocumentProbeSecurityFileWorkerRequest, type DocumentRedactionService, type DocumentRenderPageFileWorkerRequest, type DocumentRenderService, type DocumentSaveBufferWorkerRequest, type DocumentSaveFileWorkerRequest, type DocumentSaveLayerBufferWorkerRequest, type DocumentSearchService, type DocumentSecurityProbeInfo, type DocumentSecurityService, type DocumentSecurityState, type DocumentUnlockInput, type DocumentUnlockResult, type DraftOfKind, EMPTY_TRANSFER, type EmbeddedFileItem, type EmbeddedFileRef, type Engine, EngineError, EngineErrorCode, type EngineErrorOptions, type EngineFactory, type EngineRenderPolicy, type EventOrigin, type FileAttachmentAnnotationDTO, type FileAttachmentDraft, type FileAttachmentIcon, type FileAttachmentPatch, type FileAttachmentWireDraft, type FilledStyleDraftFields, type FilledStyleFields, type FilledStylePatchFields, type FoldOptions, type FoldedText, type FontHandle, type FontKey, type FontService, type FontSpec, type FontsAddFallbackWorkerRequest, type FontsClearFallbacksWorkerRequest, type FontsClearWorkerRequest, type FontsRegisterWorkerRequest, type FormDataExport, type FormDataFormat, type FormEffect, type FormEffectResult, type FormEffectStatus, type FormEffectsResult, type FormFieldBase, type FormFieldCreateResult, type FormFieldDTO, type FormFieldDeleteResult, type FormFieldDisplay, type FormFieldDraft, type FormFieldFamily, type FormFieldFlags, type FormFieldOption, type FormFieldOptionInput, type FormFieldOrigin, type FormFieldPatch, type FormFieldRef, type FormFieldUpdateResult, type FormFieldValue, type FormImportResult, type FormKind, type FormRepairOptions, type FormRepairResult, type FormSetValueResult, type FormSnapshot, type FormValueEntry, type FormWidgetLinkResult, type FormWidgetRef, type FormsApplyEffectsWorkerRequest, type FormsAttachWidgetWorkerRequest, type FormsCreateFieldWorkerRequest, type FormsDeleteFieldWorkerRequest, type FormsDetachWidgetWorkerRequest, type FormsExportWorkerRequest, type FormsImportWorkerRequest, type FormsListWorkerRequest, type FormsRepairWorkerRequest, type FormsResetWorkerRequest, type FormsSetValueWorkerRequest, type FormsUpdateFieldWorkerRequest, type FreeTextAnnotationDTO, type FreeTextDraft, type FreeTextFont, type FreeTextIntent, type FreeTextPatch, type GeometryStyleDraftFields, type GeometryStyleFields, type GeometryStylePatchFields, type HighlightAnnotationDTO, type HighlightDraft, type HighlightPatch, type InkAnnotationDTO, type InkDraft, type InkIntent, type InkList, type InkPatch, type InkStroke, InvalidScope, type LayerArtifactFileWorkerPayload, type LayerArtifactWorkerPayload, type LayerCloseWorkerRequest, type LayerOpenSource, type LayerScopePlane, type LayerScopes, type LineAnnotationDTO, type LineDraft, type LineEnding, type LineEndings, type LinePatch, type LinePoints, type LinkAnnotationDTO, type LinkDraft, type LinkPatch, type ListBoxFieldDTO, type ListBoxFieldDraft, type ListBoxFieldPatch, type ManifestPage, type MetadataCache, type MetadataPatch, type MetadataReadWorkerRequest, type MetadataService, type MetadataUpdateResult, type MetadataUpdateWorkerRequest, MissingIdentity, type MutationMeta, NO_ANNOTATION_FLAGS, type NamedJavaScriptAction, type NormalizedDraft, type NormalizedPatch, type NoteIcon, type OpenFatMemoryWorkerRequest, type OpenInput, type OpenInputById, type OpenInputBytes, type OpenInputLayerBytes, type OpenInputLayerSource, type OpenInputToken, type OpenLayerFileBaseWorkerRequest, type OpenLayerMemoryBaseWorkerRequest, type OpenOptions, type OpenWorkerRequest, PDF_BITS, PDF_CODE_TO_SUBTYPE, PDF_SUBTYPE_TO_CODE, type PageAnnotationsService, type PageBoxes, type PageDeleteInput, type PageDeleteResult, type PageFlattenInput, type PageFlattenItemResult, type PageFlattenResult, type PageFlattenStatus, type PageFlattenUsage, type PageGeometryGlyph, type PageGeometryRun, type PageGeometryService, type PageGeometrySnapshot, type PageHandle, type PageImageBlobSource, type PageImageHandle, type PageImageObjectUrl, type PageImageOptions, type PageImageResult, type PageImageSource, type PageInsertResult, type PageLayout, type PageListSnapshot, type PageMoveCache, type PageMoveInput, type PageMoveResult, type PageNetworkRenderFormat, type PageObjectNumber, type PageRaster, type PageRenderBackground, type PageRenderEncodedFormat, type PageRenderFormat, type PageRenderOptions, type PageRenderQuery, type PageRenderService, type PageRenderTarget, type PageRenderViewport, type PageRotateInput, type PageRotateResult, type PageRotation, type PageState, type PageStructureCache, type PageTextService, type PageTextSnapshot, type PagesDeleteWorkerRequest, type PagesExtractWorkerRequest, type PagesFlattenWorkerRequest, type PagesGeometryWorkerRequest, type PagesInsertWorkerRequest, type PagesListWorkerRequest, type PagesMoveWorkerRequest, type PagesRenderWorkerRequest, type PagesRotateWorkerRequest, type PagesTextWorkerRequest, type ParsedCapability, type ParsedCollab, type ParsedScope, type ParsedVirtual, type ParsedWildcard, type PasswordPrompt, type PatchOfKind, type PdfActionNode, type PdfActionTree, type PdfActionType, type PdfActionWarning, type PdfAnnotationActions, PdfAnnotationSubtypeCode, type PdfBits, type PdfDestination, type PdfFieldActions, type PdfLinkTarget, type PdfLinkTargetWritable, type PdfOriginSize, type PdfPageActions, type PdfPermissionAdvisory, type PdfPermissionInfo, type PdfPoint, type PdfQuad, type PdfQuadCorners, type PdfRect, type PdfRectDifferences, type PdfRotation, type PdfSaveMode, type PdfSize, PermissionDenied, type PieceInfoApplicationsWorkerRequest, type PieceInfoClearWorkerRequest, type PieceInfoEntry, type PieceInfoPatch, type PieceInfoPatchValue, type PieceInfoReadWorkerRequest, type PieceInfoService, type PieceInfoSnapshot, type PieceInfoUpdateWorkerRequest, type Point, type PolygonAnnotationDTO, type PolygonDraft, type PolygonPatch, type PolylineAnnotationDTO, type PolylineDraft, type PolylinePatch, type PushButtonFieldDTO, type RadioFieldDTO, type RadioFieldDraft, type RadioFieldPatch, type Rect, type RedactAnnotationDTO, type RedactDraft, type RedactPatch, type RedactionApplyItemResult, type RedactionApplyResult, type RedactionApplyScope, type RedactionApplyStatus, type RedactionApplyWorkerRequest, type RefetchReason, type ResourceRef, type RevisionToken, type Rotation, SEARCH_FOLD_VERSION, SEARCH_REGEX_MAX_LENGTH, SEARCH_SNIPPET_CONTEXT, type SearchMatch, type SearchMatchRange, type SearchMode, type SearchQuery, type SearchQueryIssue, type SearchQueryValidation, type SearchQueryWorkerRequest, type SearchRegexIssue, type SearchRegexValidation, type SearchRequest, type SearchSlice, type SearchSliceBudget, type SearchSnippet, type SerializedEngineError, type ShapeAnnotationFields, type ShapeDraftFields, type ShapePatchFields, type ShutdownWorkerRequest, type SignatureFieldDTO, type Size, type SquareAnnotationDTO, type SquareDraft, type SquarePatch, type SquigglyAnnotationDTO, type SquigglyDraft, type SquigglyPatch, type StampAnnotationDTO, type StampDraft, type StampFit, type StampPatch, type StampWireDraft, type StampWirePatch, type StandardFont, type StrikeoutAnnotationDTO, type StrikeoutDraft, type StrikeoutIntent, type StrikeoutPatch, type TextAlignment, type TextAnnotationDTO, type TextDraft, type TextFieldDTO, type TextFieldDraft, type TextFieldPatch, type TextPatch, type ToggleFieldWidget, type TokenSource, UNKNOWN_WEAK_ANNOTATION_STATE, type UnderlineAnnotationDTO, type UnderlineDraft, type UnderlinePatch, type UnknownFieldDTO, type UnsupportedAnnotationDTO, type UnsupportedDraft, type UnsupportedPatch, type VertexAnnotationFields, type VertexDraftFields, type VertexPatchFields, type WeakAnnotationEditSession, type WeakAnnotationState, type WidgetAnnotationDTO, type WidgetAppearance, type WidgetDraft, type WidgetPatch, type WidgetPlacement, type WidgetStyleDraftFields, type WidgetStyleFields, type WidgetStylePatchFields, type WireAnnotationDraft, type WireAnnotationPatch, type WireAttachmentFile, type WirePack, type WireResource, type WireResourceMap, type WorkerJobId, type WorkerLifecycleMessage, type WorkerRequest, type WorkerResponse, type WorkerResultPayload, advisoryFromPdfBits, appearanceImpactOf, buildSnippet, buildThreads, canonicalSearchQuery, caps, changesAnnotationList, checkAnyCapability, checkCapability, checkCollab, checkSetGroup, classifyRelation, collab, createPageImageHandle, decodeFieldRefKey, decodePdfBits, decodeStableIdKey, deserializeError, encodeFieldRefKey, encodeStableIdKey, expandRawScope, expandedCapabilities, filterMatches, foldOptionsFor, foldText, invalidatesWeakIndexRefs, isAbortError, isValidPageObjectNumber, knownWeakAnnotationState, matchLiteral, matchPageText, matchRegex, materializePdfPermissions, normalizeAnnotationDraft, normalizeAnnotationPatch, normalizeAttachmentFileSource, normalizePdfRect, parseScope, passwordPromptFromState, pdfPermissions, pdfQuadBounds, pdfQuadCorners, pdfQuadFromCorners, pdfRectFromOriginSize, pdfRectHeight, pdfRectSize, pdfRectToOriginSize, pdfRectWidth, permissionInfoFromProbe, permissionInfoWithAdvisory, refKey, resolveBinarySource, revisionTokensEqual, searchContentEpoch, searchRectsForRange, securityStateFromHead, securityStateFromProbe, semanticEqual, serializeError, shiftsExistingAnnotationIndices, snapAppearanceScale, snapFullPageViewport, snapTileScale, sniffBinaryMetadata, subtypeFromCode, toOriginalRange, validateScopeArray, validateSearchQuery, validateSearchRegex, wirePack, wordAt, wordBefore };
+//# sourceMappingURL=runtime.d.cts.map