@embedpdf/engine-core 3.0.0-next.1 → 3.0.0-next.11

package/dist/{AnnotationListSnapshot-W0RCsyDE.d.cts → AnnotationListSnapshot-C1U3XUxP.d.cts}

@@ -16,20 +16,245 @@ interface DocumentMetadata {
   custom: Record<string, string>;
 }
 //#endregion
+//#region src/identity/PageObjectNumber.d.ts
+/**
+ * PDF indirect object number for a page.
+ *
+ * Resolved via the PDFium runtime helper `EPDFPage_GetObjectNumber(pagePtr)`.
+ * Always > 0 for well-formed PDFs. This replaces the v2 page index as the
+ * primary addressing key. The page index is kept on `PageHandle` as display
+ * metadata only, because it can shift when pages are inserted, deleted, or
+ * reordered while a session is open.
+ */
+type PageObjectNumber = number;
+/**
+ * Type guard for the rare malformed-PDF case where a page is a direct
+ * object. The engine treats `0` as malformed and throws `EngineError(NotFound)`
+ * before any page-level operation.
+ */
+declare function isValidPageObjectNumber(value: unknown): value is PageObjectNumber;
+//#endregion
+//#region src/dto/PdfDestination.d.ts
+/**
+ * An explicit PDF destination (ISO 32000-1 §12.3.2.2): a page, a location,
+ * and a magnification. Produced by outlines/bookmarks, link annotations,
+ * `/OpenAction`, and GoTo actions; named destinations resolve to one of
+ * these through the catalog's `/Dests` dictionary or name tree — the
+ * ENGINE does that resolution, so the viewer only ever sees this explicit
+ * form.
+ *
+ * Coordinates are PDF user space (y-up, points, absolute — NOT
+ * crop-relative). `null` means "retain the current value" (the spec's
+ * meaning for null array entries); a `/XYZ` zoom of `0` is equivalent to
+ * null. The `fitB*` kinds refer to the page's content BOUNDING box rather
+ * than the crop box.
+ *
+ * Viewers translate these onto the stage's reveal primitive — see
+ * `destinationToReveal` in `@embedpdf/plugin-stage`.
+ */
+type PdfDestination = {
+  kind: 'xyz';
+  pageObjectNumber: PageObjectNumber;
+  left?: number | null;
+  top?: number | null;
+  zoom?: number | null;
+} | {
+  kind: 'fit';
+  pageObjectNumber: PageObjectNumber;
+} | {
+  kind: 'fitH';
+  pageObjectNumber: PageObjectNumber;
+  top?: number | null;
+} | {
+  kind: 'fitV';
+  pageObjectNumber: PageObjectNumber;
+  left?: number | null;
+} | {
+  kind: 'fitR';
+  pageObjectNumber: PageObjectNumber;
+  left: number;
+  bottom: number;
+  right: number;
+  top: number;
+} | {
+  kind: 'fitB';
+  pageObjectNumber: PageObjectNumber;
+} | {
+  kind: 'fitBH';
+  pageObjectNumber: PageObjectNumber;
+  top?: number | null;
+} | {
+  kind: 'fitBV';
+  pageObjectNumber: PageObjectNumber;
+  left?: number | null;
+};
+//#endregion
 //#region src/dto/PdfAction.d.ts
 /** Normalized values of an action dictionary's `/S` name. */
-type PdfActionType = 'unknown' | 'goto' | 'goto-remote' | 'goto-embedded' | 'launch' | 'thread' | 'uri' | 'sound' | 'movie' | 'hide' | 'named' | 'submit-form' | 'reset-form' | 'import-data' | 'javascript' | 'set-ocg-state' | 'rendition' | 'transition' | 'goto-3d-view';
-/** One detached node in a normalized PDF action tree. */
-interface PdfActionNode {
-  type: PdfActionType;
+type PdfActionType = PdfActionNode['type'];
+/**
+ * One Hide `/T` or ResetForm `/Fields` entry. Deliberately UNSCOPED: a
+ * dictionary reference carries no page, so resolution (a name to widgets, an
+ * object number to an annotation or field) is the interpreter's job — never
+ * the extractor's.
+ */
+type PdfActionTargetRef = {
+  kind: 'name';
+  name: string;
+} | {
+  kind: 'objectNumber';
+  objectNumber: number;
+};
+/**
+ * Decoded SubmitForm `/Flags` word (ISO 32000-2:2020 Table 240) plus the raw
+ * value. `exclude` is DERIVED from bit 1 — never stored separately, so the
+ * two cannot disagree. Note the two easily-missed positions verified against
+ * the spec: bit 12 is `ExclFKey` (not "ExclFDFTemplate") and bit 13 is
+ * reserved/undefined, so `EmbedForm` is bit 14.
+ */
+interface SubmitFormFlags {
+  raw: number;
+  /** Bit 1: set → `fields` lists EXCLUDED fields. */
+  exclude: boolean;
+  /** Bit 2: submit designated valueless fields too, as name-only entries. */
+  includeNoValueFields: boolean;
+  /** Bits 3/6/9 folded into one verdict: bit 9 SubmitPDF dominates ("all
+   *  other flags shall be ignored except GetMethod"), else bit 6 XFDF, else
+   *  bit 3 HTML Form format, else FDF (the Table 240 default). */
+  format: 'fdf' | 'html' | 'xfdf' | 'pdf';
+  /** Bit 4. ISO makes GetMethod meaningful only with ExportFormat set, and
+   *  the bit-9 rule keeps it alive for SubmitPDF — so `'get'` only for
+   *  `'html'` and `'pdf'`; everything else posts. */
+  method: 'post' | 'get';
+  /** Bit 5 (meaningful only with ExportFormat; passed through — this stack
+   *  does not capture click coordinates). */
+  submitCoordinates: boolean;
+  /** Bit 7 (FDF only): include incremental updates via FDF `Differences`. */
+  includeAppendSaves: boolean;
+  /** Bit 8 (FDF only): include markup annotations. */
+  includeAnnotations: boolean;
+  /** Bit 10: convert date-like values to the standard date format. */
+  canonicalFormat: boolean;
+  /** Bit 11 (FDF, with IncludeAnnotations): only the current user's
+   *  annotations. */
+  exclNonUserAnnots: boolean;
+  /** Bit 12: the submitted FDF excludes its `F` entry. */
+  exclFKey: boolean;
+  /** Bit 14 (bit 13 is reserved): the FDF `F` entry embeds the source PDF. */
+  embedForm: boolean;
+}
+/**
+ * The one Table-240 decode, shared by the reader, the schema's producers,
+ * and tests — so bit semantics cannot fork.
+ */
+declare const decodeSubmitFormFlags: (raw: number) => SubmitFormFlags;
+/**
+ * SubmitForm's extracted intent. ATOMIC on purpose: either every required
+ * component resolved (a complete, executable payload) or the node carries no
+ * payload at all — partial states are unrepresentable. An unreadable
+ * REQUIRED component (`/F`) degrades the whole node to `unknown` +
+ * `payload-dropped` at read time instead.
+ */
+interface SubmitFormPayload {
+  /** Resolved `/F` URL — a `<< /FS /URL >>` file specification (7.11.5,
+   *  `/UF` preferred over `/F` per 7.11.2); a bare string `/F` is accepted
+   *  as a producer-compat extension. */
+  url: string;
+  /**
+   * `null` = `/Fields` ABSENT → Include/Exclude is ignored and every field
+   * except NoExport-flagged ones is submitted (Table 239). `[]` =
+   * present-but-empty: include mode submits NOTHING, exclude mode submits
+   * everything eligible — presence and emptiness are different states.
+   */
+  fields: PdfActionTargetRef[] | null;
+  flags: SubmitFormFlags;
+  /** `/CharSet` (PDF 2.0), extracted but not encoded by this stack. */
+  charSet?: string;
+}
+interface PdfActionNodeCommon {
   /** Raw `/S` name, retained for unknown and future action types. */
   subtype: string;
-  /** Decoded `/JS` source for JavaScript and Rendition actions. */
-  script?: string;
   /** Normalized `/Next` children in PDF order. */
   next: PdfActionNode[];
 }
-type PdfActionWarning = 'cycle-dropped' | 'malformed-next' | 'incomplete';
+/**
+ * One detached node in a normalized PDF action tree, discriminated on the
+ * interpreter that would execute it. Every executable arm carries its full
+ * payload — a `goto` without a destination or a `uri` without a URI is
+ * unrepresentable. A payload the reader cannot materialize degrades the node
+ * to `unknown` (original `/S` kept on `subtype`) and appends the tree-level
+ * `'payload-dropped'` warning.
+ */
+type PdfActionNode = PdfActionNodeCommon & ({
+  type: 'javascript';
+  script: string;
+} | {
+  type: 'goto';
+  destination: PdfDestination;
+} | {
+  type: 'uri';
+  uri: string;
+  isMap: boolean;
+} | {
+  type: 'named';
+  name: string;
+} | {
+  type: 'hide';
+  targets: PdfActionTargetRef[];
+  hide: boolean;
+} | {
+  type: 'reset-form';
+  /**
+   * `null` = `/Fields` ABSENT → reset every field (`exclude` is
+   * meaningless). `[]` = present-but-empty: with `exclude` false reset
+   * NOTHING, with `exclude` true reset EVERYTHING — PDFium's executor
+   * branches on presence first.
+   */
+  fields: PdfActionTargetRef[] | null;
+  exclude: boolean;
+} |
+/** Reported, never executed. */
+{
+  type: 'goto-remote';
+  filePath: string;
+} | {
+  type: 'goto-embedded';
+  filePath: string;
+} | {
+  type: 'launch';
+  filePath: string;
+} |
+/** ISO allows `/Rendition` to carry `/JS`; preserved, not collected. */
+{
+  type: 'rendition';
+  script?: string;
+} |
+/** Recognized; executable only when `payload` is present. Absent payload
+ *  = extracted by an older runtime (skew) — the node stays
+ *  recognized-inert exactly as before this payload existed. */
+{
+  type: 'submit-form';
+  payload?: SubmitFormPayload;
+} | {
+  type: 'thread';
+} | {
+  type: 'sound';
+} | {
+  type: 'movie';
+} | {
+  type: 'import-data';
+} | {
+  type: 'set-ocg-state';
+} | {
+  type: 'transition';
+} | {
+  type: 'goto-3d-view';
+} | {
+  type: 'unknown';
+});
+type PdfActionWarning = 'cycle-dropped' | 'malformed-next' | 'incomplete' |
+/** A node's payload could not be read; that node degraded to `unknown`. */
+'payload-dropped';
 /**
  * One extracted action root plus the native reader's safety verdict.
  * Consumers must never execute a tree whose `incomplete` flag is true.
@@ -38,7 +263,8 @@ interface PdfActionTree {
   /** Null when the model was valid but its root exceeded a safety bound. */
   root: PdfActionNode | null;
   incomplete: boolean;
-  /** Raw native bits, retained so newer warnings survive older SDKs. */
+  /** Raw native bits, retained so newer warnings survive older SDKs.
+   *  TS-detected warnings (`payload-dropped`) appear only in `warnings`. */
   warningFlags: number;
   warnings: PdfActionWarning[];
 }
@@ -73,8 +299,13 @@ interface NamedJavaScriptAction {
 /** Catalog-owned actions. Page actions stay on their owning PageLayout. */
 interface DocumentActionsSnapshot {
   nameTreeScripts: NamedJavaScriptAction[];
-  /** Action-form `/OpenAction`; a destination-form value reads as null. */
+  /** Action-form `/OpenAction`. Mutually exclusive with `openDestination` —
+   *  `/OpenAction` is one entry, a dictionary or an array. */
   openAction: PdfActionTree | null;
+  /** Destination-form `/OpenAction` — the initial view, not an action.
+   *  Optional on the wire for skew tolerance (absent ≡ null); the schema
+   *  defaults it, so parsed snapshots always carry the key. */
+  openDestination?: PdfDestination | null;
   willClose?: PdfActionTree;
   willSave?: PdfActionTree;
   didSave?: PdfActionTree;
@@ -90,6 +321,13 @@ interface ActionReadBudget {
   maxModels: number;
   maxNodes: number;
   maxScriptCodeUnits: number;
+  /** Hide `/T` + ResetForm/SubmitForm `/Fields` entries, aggregate across
+   *  the job. */
+  maxTargetEntries: number;
+  /** Payload string code units (URIs, submit URLs/CharSets, names, file
+   *  paths, name-tree script names), aggregate across the job. Reserved
+   *  BEFORE allocation. */
+  maxPayloadCodeUnits: number;
 }
 //#endregion
 //#region src/geometry/primitives.d.ts
@@ -116,9 +354,13 @@ interface PdfPoint {
   y: number;
 }
 /**
- * A rectangle in PDF user space, expressed as edges (y-up, so `top > bottom`
- * and `right > left` once normalized). Page-box origin is preserved, so
- * `left`/`bottom` may be non-zero or negative.
+ * A rectangle in the FILE's coordinates — PDF user space, expressed as edges
+ * (y-up, so `top > bottom` and `right > left` once normalized). Page-box
+ * origin is preserved, so `left`/`bottom` may be non-zero or negative.
+ *
+ * The rule: stored in the file → `PdfRect`; shown on screen → the viewer's
+ * y-down `Rect` (`{x, y, width, height}`). The shapes are incompatible on
+ * purpose — passing one where the other goes doesn't compile.
  */
 interface PdfRect {
   left: number;
@@ -290,6 +532,36 @@ interface PdfRectDifferences {
  *                       group (e.g. the Caret of a text-edit pair).
  */
 type AnnotationReplyType = 'reply' | 'group';
+/** The two ISO 32000 §12.5.6.3 standard state models (Table 174). */
+type KnownAnnotationStateModel = 'review' | 'marked';
+/**
+ * The `/StateModel` of an annotation-state text annotation — ISO 32000
+ * §12.5.6.3. The standard models are `'review'` and `'marked'`, but the
+ * PDF stores the entry as a free text string and Acrobat supports
+ * registering custom state models, so the type stays open. The
+ * `(string & {})` arm keeps the standard literals auto-completing while
+ * accepting any custom model (the {@link FreeTextFont} pattern).
+ *
+ * Known values are wire-stable lowercase; the engine maps them onto the
+ * capitalized PDF spellings (`Review`, `Marked`) at read/write time.
+ * Unknown values round-trip verbatim in both directions.
+ */
+type AnnotationStateModel = KnownAnnotationStateModel | (string & {});
+/** The ISO 32000 §12.5.6.3 standard states (Table 174). */
+type KnownAnnotationState = 'accepted' | 'rejected' | 'cancelled' | 'completed' | 'none' | 'marked' | 'unmarked';
+/**
+ * The `/State` an annotation-state text annotation sets — ISO 32000
+ * §12.5.6.3. `'accepted' | 'rejected' | 'cancelled' | 'completed' |
+ * 'none'` belong to the `'review'` model; `'marked' | 'unmarked'` to the
+ * `'marked'` model. Open for the same reason as
+ * {@link AnnotationStateModel}: custom models bring custom states.
+ *
+ * States are PER USER and live on separate text annotations replying
+ * (`/IRT`) to their target — never on the target itself. The `/T` of the
+ * state annotation names who set it; later changes by the same user
+ * chain as replies to their previous state annotation, latest wins.
+ */
+type AnnotationState = KnownAnnotationState | (string & {});
 /**
  * Bitset wrapper for the `/F` (Annotation Flags) PDF entry. We expose each
  * bit as its own boolean so callers don't have to know the bit positions.
@@ -308,24 +580,6 @@ interface AnnotationFlags {
 }
 declare const NO_ANNOTATION_FLAGS: AnnotationFlags;
 //#endregion
-//#region src/identity/PageObjectNumber.d.ts
-/**
- * PDF indirect object number for a page.
- *
- * Resolved via the PDFium runtime helper `EPDFPage_GetObjectNumber(pagePtr)`.
- * Always > 0 for well-formed PDFs. This replaces the v2 page index as the
- * primary addressing key. The page index is kept on `PageHandle` as display
- * metadata only, because it can shift when pages are inserted, deleted, or
- * reordered while a session is open.
- */
-type PageObjectNumber = number;
-/**
- * Type guard for the rare malformed-PDF case where a page is a direct
- * object. The engine treats `0` as malformed and throws `EngineError(NotFound)`
- * before any page-level operation.
- */
-declare function isValidPageObjectNumber(value: unknown): value is PageObjectNumber;
-//#endregion
 //#region src/revision/RevisionToken.d.ts
 /**
  * Opaque token a client must hand back when addressing an annotation by
@@ -392,6 +646,8 @@ type AnnotationRef = {
  */
 interface AnnotationDraftBase {
   contents?: string | null;
+  /** `/Subj` — short subject line (ISO 32000 §12.5.6.2, markup annotations). */
+  subject?: string | null;
   /** Blend mode to bake into the normal appearance. Omit for the subtype default. */
   blendMode?: BlendMode;
   /** Optional /NM the caller wants to assign on creation. */
@@ -428,7 +684,7 @@ interface AnnotationDraftBase {
  * expands these capabilities. PDF bits are NEVER consulted unless
  * `pdf.permissions` is in scope.
  */
-type DocCapability = 'doc.open' | 'doc.render' | 'doc.text.select' | 'doc.text.copy' | 'doc.text.search' | 'doc.content.copy' | 'doc.download' | 'doc.download.flattened' | 'doc.print' | 'doc.print.high' | 'doc.pages.modify' | 'doc.pages.assemble' | 'doc.forms.read' | 'doc.forms.fill' | 'doc.forms.modify' | 'doc.annotate.read' | 'doc.annotate.modify' | 'doc.metadata.modify' | 'doc.attachments.modify' | 'doc.redact';
+type DocCapability = 'doc.open' | 'doc.render' | 'doc.text.select' | 'doc.text.copy' | 'doc.text.search' | 'doc.content.copy' | 'doc.download' | 'doc.download.flattened' | 'doc.print' | 'doc.print.high' | 'doc.pages.modify' | 'doc.pages.assemble' | 'doc.forms.read' | 'doc.forms.fill' | 'doc.forms.modify' | 'doc.forms.submit' | 'doc.annotate.read' | 'doc.annotate.modify' | 'doc.metadata.modify' | 'doc.attachments.modify' | 'doc.redact';
 /**
  * Single-entity collaboration vocabulary. Only annotations are
  * collab-scoped today; future entities slot into the same grammar.
@@ -932,9 +1188,9 @@ interface OpenInputById {
  * `GET /v1/docs/:docId/head`. The returned handle is bound to this
  * token; subsequent operations on it carry that bearer.
  *
- * Use this for share-link / embed-link UX where the bearer of the
- * token is authorised for exactly one document (e.g. a third-party
- * reviewer the customer has shared a single doc with).
+ * Use this when your backend mints doc-scoped JWTs itself (e.g. a
+ * logged-in reviewer authorised for exactly one document). For the
+ * no-backend public-share flow, use `kind: 'share'` instead.
  *
  * Rejected by `@embedpdf/engine`.
  */
@@ -949,7 +1205,31 @@ interface OpenInputToken {
   token: TokenSource;
   password?: string | null;
 }
-type OpenInput = OpenInputBytes | OpenInputLayerBytes | OpenInputById | OpenInputToken;
+/**
+ * Cloud-engine: open via a public share token (`shr_…`) from the
+ * dashboard's embed snippet. A share token is a REFERENCE to a
+ * stored grant on the server, not a credential — the engine
+ * exchanges it for a short-lived doc-scoped session JWT and
+ * silently re-exchanges near expiry, so revoking or editing the
+ * share retargets every embedded copy at the next renewal. No
+ * backend required; the engine itself may be constructed with no
+ * engine-level token at all.
+ *
+ * Rejected by `@embedpdf/engine`.
+ */
+interface OpenInputShare {
+  kind: 'share';
+  /** Public share token (`shr_…`) identifying the grant. */
+  shareToken: string;
+  /**
+   * Passphrase for a protected grant. This is the SHARE passphrase,
+   * checked by the exchange endpoint — not the PDF's encryption
+   * password, which stays in `password` like every other kind.
+   */
+  sharePassword?: string;
+  password?: string | null;
+}
+type OpenInput = OpenInputBytes | OpenInputLayerBytes | OpenInputById | OpenInputToken | OpenInputShare;
 interface OpenOptions {
   password?: string | null;
   /**
@@ -1151,16 +1431,127 @@ declare function pdfQuadCorners(q: PdfQuad): PdfQuadCorners;
  */
 declare function pdfQuadFromCorners(c: PdfQuadCorners): PdfQuad;
 //#endregion
+//#region src/text/charmap.d.ts
+/**
+ * Character↔text index translation — the ONE place the two text index
+ * spaces of a page meet.
+ *
+ * A page has two index spaces:
+ *
+ *   - CHARACTER space: PDFium's internal character list, the space geometry
+ *     runs tile (`PageGeometryRun.charStart`), hit-testing addresses, and
+ *     selection ranges live in. Size: `PageTextSnapshot.charCount`.
+ *   - TEXT space: UTF-16 code-unit offsets into the extracted string
+ *     `PageTextSnapshot.text` — what search matching and slicing operate on.
+ *
+ * They diverge in exactly two ways, both encoded by `charMap` anchors:
+ *   - a non-printing character occupies a character slot but contributes
+ *     ZERO text units (PDFium's `char_indices_` skip list);
+ *   - a supplementary-plane character contributes TWO text units (a
+ *     surrogate pair) once extraction is UTF-16-faithful.
+ *
+ * `charMap` semantics (see {@link CharMapAnchor}): an implicit head anchor
+ * `[0, 0]`; between anchors every character advances the text by exactly one
+ * unit; an anchor sits at `i + 1` whenever character `i` contributed
+ * something other than one unit. Absent/empty map = identity
+ * (`charCount === text.length`). `charMapViolation` is the validator both
+ * the wire schema and engine builders share — malformed maps are rejected,
+ * never silently repaired.
+ *
+ * Boundary model: a "character boundary" `c` ∈ [0, charCount] sits BEFORE
+ * character `c`; `boundaryTextOffset(s, charCount) === text.length` always.
+ * All ranges are half-open in both spaces.
+ */
+/**
+ * One anchor of the character→text mapping: from character index `char`
+ * onward (until the next anchor), boundary `c` maps to text offset
+ * `text + (c - char)`.
+ */
+type CharMapAnchor = readonly [char: number, text: number];
+/** Direction to resolve a text offset that falls on a zero-width plateau —
+ *  see {@link charBoundaryAtTextOffset}. */
+type CharBoundaryBias = 'start' | 'end';
+/**
+ * Text offset of character boundary `boundary` (clamped into
+ * [0, charCount]). For a dropped character this is the offset of the next
+ * real text unit — exactly what half-open slicing needs at either end.
+ */
+declare function boundaryTextOffset(snapshot: PageTextSnapshot, boundary: number): number;
+/**
+ * The character boundary for a text offset, with explicit plateau bias:
+ *
+ *   - `'start'`: the GREATEST boundary whose text offset is <= `offset` —
+ *     scans forward past zero-width characters, so a range start never
+ *     includes a dropped character that precedes its first real unit.
+ *   - `'end'`: the SMALLEST boundary whose text offset is >= `offset` —
+ *     stops before zero-width characters, so a range end never swallows a
+ *     dropped character that follows its last real unit.
+ *
+ * An offset inside a surrogate pair resolves outward under both biases
+ * (start → the pair's character, end → past it), so a clipped astral
+ * character is always covered whole. Prefer {@link charRangeForTextOffsets}
+ * — the two biases exist to be used as a PAIR.
+ */
+declare function charBoundaryAtTextOffset(snapshot: PageTextSnapshot, offset: number, bias: CharBoundaryBias): number;
+/**
+ * The character range whose text projection is exactly
+ * `text.slice(startOffset, endOffset)` — THE inverse used by search-hit
+ * conversion and select-by-text. Start is right-biased and end left-biased
+ * (see {@link charBoundaryAtTextOffset}), so zero-width characters adjacent
+ * to the range fall OUTSIDE it on both sides.
+ *
+ * A non-empty text range can never invert: `end > start` implies
+ * `B(end) >= endOffset > startOffset >= B(start)`, which forces
+ * `end > start` by monotonicity. Empty input (`endOffset <= startOffset`)
+ * normalizes to the end-rule boundary of `startOffset` on both sides.
+ */
+declare function charRangeForTextOffsets(snapshot: PageTextSnapshot, startOffset: number, endOffset: number): {
+  start: number;
+  end: number;
+};
+/**
+ * THE copy primitive: the text projection of the half-open character range
+ * `[charStart, charEnd)`. Dropped characters inside the range contribute
+ * nothing; a supplementary character contributes its full surrogate pair.
+ * `sliceTextByChars(s, 0, s.charCount) === s.text` always.
+ */
+declare function sliceTextByChars(snapshot: PageTextSnapshot, charStart: number, charEnd: number): string;
+/**
+ * First invariant violation of a snapshot's char map, or null when valid.
+ * Shared by the wire schema (rejects malformed bodies) and engine builders
+ * (dev-mode assertion). The invariants:
+ *
+ *   1. absent/empty map ⇒ identity, so `charCount === text.length`;
+ *   2. anchor chars strictly increasing, each in [1, charCount];
+ *   3. step rule: against the previous anchor (implicit head [0, 0]), the
+ *      character just before each anchor contributed exactly 0 units
+ *      (dropped) or 2 (surrogate pair):
+ *      `t₂ - (t₁ + (c₂ - c₁ - 1)) ∈ {0, 2}`;
+ *   4. tail: `lastText + (charCount - lastChar) === text.length`
+ *      (equivalently `boundaryTextOffset(s, charCount) === text.length`).
+ */
+declare function charMapViolation(charCount: number, textLength: number, charMap: ReadonlyArray<CharMapAnchor> | undefined): string | null;
+//#endregion
 //#region src/dto/PageTextSnapshot.d.ts
 /**
  * Per-page text snapshot returned by `PageHandle.text.read()` and over
- * the wire as the `GET /v1/docs/:docId/pages/:pon/text@contentVersion=N` body.
- *
- * `text` is the full plain-text extraction of the page in display order
- * (UTF-16 → JS string). `charCount` is the PDFium-reported character
- * count and may differ from `text.length` when the page contains
- * astral-plane characters (PDFium counts UTF-16 code units, and JS
- * strings preserve them as surrogate pairs).
+ * the wire as the `GET …/text/pages/:pon/data@<contentVersion>` body.
+ *
+ * `text` is the full extracted page text in display order, UTF-16 faithful
+ * (supplementary-plane characters are surrogate pairs, never dropped).
+ *
+ * `charCount` is the size of the page's CHARACTER space — PDFium's internal
+ * character list, the same space geometry runs tile
+ * (`PageGeometryRun.charStart`) and selection ranges live in. It is NOT the
+ * length of `text`: a non-printing character occupies a character slot but
+ * contributes zero text units, and a supplementary character contributes
+ * two. `charMap` encodes exactly those deviations; absent/empty means the
+ * two spaces are identical (`charCount === text.length`), which is the
+ * common case and costs nothing on the wire. All translation goes through
+ * the helpers in `text/charmap.ts` (`boundaryTextOffset`,
+ * `charRangeForTextOffsets`, `sliceTextByChars`) — consumers never
+ * interpret anchors directly, and the wire schema rejects maps that violate
+ * the invariants documented there.
  *
  * This snapshot is pure content, addressed and cached by `contentVersion`.
  * It deliberately carries NO annotation liveness envelope (`PageState`):
@@ -1168,22 +1559,19 @@ declare function pdfQuadFromCorners(c: PdfQuadCorners): PdfQuad;
  * annotation `revision` / weak-state changes on a different cadence than
  * `contentVersion`, so baking liveness into this content-cached body would
  * be a stale-data hazard. Liveness lives on annotation reads instead.
- *
- * Future extensions (per-character bounding boxes, font runs, search
- * results, etc.) land on `PageTextService` as additional methods; the
- * snapshot shape stays stable so the wire URL and CDN cache remain
- * intact across SDK versions.
  */
 interface PageTextSnapshot {
   text: string;
   charCount: number;
+  /** Character→text anchors; absent/empty = identity. See `text/charmap.ts`. */
+  charMap?: ReadonlyArray<CharMapAnchor>;
 }
 //#endregion
 //#region src/dto/PageGeometrySnapshot.d.ts
 /**
- * One glyph's geometry in PDF user space (y-up edges).
+ * One upright glyph's geometry in PDF user space (y-up edges).
  *
- * `looseBox` is the loose char box (pdfium `FPDFText_GetLooseCharBox`): the
+ * `looseBox` is the loose char cell (pdfium `FPDFText_GetLooseCharBox`): the
  * font-metric box covering the full glyph cell without regard to the actual
  * glyph shape. Always present (zeroed + flagged empty for degenerate glyphs);
  * it's the box selection envelopes are built from.
@@ -1200,15 +1588,61 @@ interface PageGeometryGlyph {
   tightBox?: PdfRect;
 }
 /**
- * One text run (contiguous glyphs sharing a text object). `rect` is the run's
- * enclosing box in PDF user space (y-up edges).
+ * One non-upright glyph's geometry: the exact oriented cells, in PDF user
+ * space (page coordinates — NOT a local frame). The corner SLOTS are
+ * frame-geometric in the glyph's own upright frame:
+ * `p1` = upper-start, `p2` = upper-end, `p3` = lower-start, `p4` = lower-end,
+ * where "upper" is the ascent side and "start" is the frame's minimum-x side.
+ * Deliberately NOT a bidi/reading-order statement — advance direction is a
+ * glyph-sequence concern, carried separately where consumers need it.
+ *
+ * Degenerate glyphs carry a zeroed `looseQuad` plus the empty flag (bit 2),
+ * mirroring the upright variant's zeroed-box convention. `flags` bits match
+ * {@link PageGeometryGlyph.flags}.
+ */
+interface RotatedGeometryGlyph {
+  looseQuad: PdfQuad;
+  flags: number;
+  tightQuad?: PdfQuad;
+}
+/**
+ * A run whose char matrix is upright — byte-identical to the wire shape that
+ * predates orientation support, so upright documents never pay for it.
  */
-interface PageGeometryRun {
+interface UprightGeometryRun {
   rect: PdfRect;
   charStart: number;
   glyphs: PageGeometryGlyph[];
   fontSize?: number;
 }
+/**
+ * A run whose char matrix is NOT upright (rotated, sheared, or mirrored).
+ *
+ * `rect` stays a page-space AABB (culling), like every other wire rect.
+ * `rotation` is the baseline angle in radians, CCW in PDF y-up space
+ * (`atan2(m.b, m.a)` of the run's char matrix). Note a shear-only run has
+ * `rotation === 0` and still uses this variant — its cells are
+ * parallelograms an AABB would misrepresent. `ascentFlip` is true when the
+ * ascent vector maps opposite the rotated frame's +y (mirrored /
+ * negative-determinant content).
+ */
+interface RotatedGeometryRun {
+  rect: PdfRect;
+  charStart: number;
+  glyphs: RotatedGeometryGlyph[];
+  rotation: number;
+  ascentFlip: boolean;
+  fontSize?: number;
+}
+/**
+ * One text run (contiguous glyphs sharing a text object and orientation).
+ * A discriminated union so consumers CANNOT read axis-aligned boxes off
+ * rotated text by accident — handling orientation is a compile-time
+ * obligation, not a runtime discovery. Narrow with
+ * {@link isRotatedGeometryRun}, or use the uniform {@link glyphLooseQuad} /
+ * {@link glyphLooseBounds} views.
+ */
+type PageGeometryRun = UprightGeometryRun | RotatedGeometryRun;
 /**
  * Geometry-only text layout for one page, in PDF user space (y-up). The v3
  * viewer converts to content/view space via the page geometry matrix.
@@ -1220,6 +1654,22 @@ interface PageGeometryRun {
 interface PageGeometrySnapshot {
   runs: PageGeometryRun[];
 }
+/** Narrowing guard: is this run the rotated (non-upright) variant? */
+declare function isRotatedGeometryRun(run: PageGeometryRun): run is RotatedGeometryRun;
+/**
+ * Uniform oriented-cell view over either run variant: the glyph's loose cell
+ * as a quad (synthesized from the box corners when the run is upright, in
+ * the same frame-geometric slot order).
+ */
+declare function glyphLooseQuad(run: PageGeometryRun, index: number): PdfQuad;
+/**
+ * Uniform AABB view over either run variant: the glyph's loose box, or the
+ * enclosing bounds of its oriented cell when the run is rotated. The
+ * conservative envelope for consumers that genuinely want a box (culling,
+ * scroll targets) — never a substitute for handling orientation in geometry
+ * that gets DRAWN.
+ */
+declare function glyphLooseBounds(run: PageGeometryRun, index: number): PdfRect;
 //#endregion
 //#region src/dto/PageRender.d.ts
 type PageRenderEncodedFormat = 'png' | 'webp' | 'bmp';
@@ -1426,8 +1876,8 @@ interface AnnotationAppearancesQuery {
  * (y-up), so the consumer can place the bitmap without a second read.
  *
  * Rotation convention: for annotations whose rotation lives in the AP
- * `/Matrix` — box-family kinds (square/circle/free-text/stamp) whose DTO
- * carries BOTH `rotation` and `unrotatedRect` — the raster renders
+ * `/Matrix` — box-family kinds (square/circle/free-text/stamp/caret) whose
+ * DTO carries BOTH `rotation` and `unrotatedRect` — the raster renders
  * ROTATION-STRIPPED and `rect` is the logical `unrotatedRect`; the consumer
  * re-applies the DTO's `rotation` as a view transform about the box centre
  * (e.g. CSS `rotate`), which makes the raster rotation-invariant (rotating
@@ -1586,6 +2036,14 @@ declare const EngineErrorCode: {
   readonly DocOpenFailed: "DocOpenFailed";
   readonly DocPasswordRequired: "DocPasswordRequired";
   readonly DocPasswordIncorrect: "DocPasswordIncorrect";
+  /**
+   * A share-token exchange (`open({ kind: 'share' })`) needs the grant's
+   * passphrase: none was supplied, or the supplied one was rejected —
+   * indistinguishable by design, mirroring the server. Prompt and retry
+   * with `sharePassword`. Distinct from `DocPasswordRequired`, which is
+   * about the PDF's own encryption password.
+   */
+  readonly SharePasswordRequired: "SharePasswordRequired";
   readonly Aborted: "Aborted";
   readonly Network: "Network";
   readonly Unauthenticated: "Unauthenticated";
@@ -1760,6 +2218,13 @@ interface AnnotationBase {
   rect: PdfRect;
   /** /Contents text. */
   contents: string | null;
+  /**
+   * `/Subj` — short subject line of a markup annotation (ISO 32000
+   * §12.5.6.2, Table 172). Normalized onto the base like `contents` /
+   * `author`: non-markup subtypes simply read `null`. Faithful read:
+   * `null` iff the key is absent (a present-but-empty `/Subj` reads `''`).
+   */
+  subject: string | null;
   /** /T author. */
   author: string | null;
   /** ISO 8601 from /CreationDate. */
@@ -1843,6 +2308,8 @@ interface AnnotationBase {
  */
 interface AnnotationPatchBase {
   contents?: string | null;
+  /** `/Subj`, three-state like `contents`: undefined=leave, null=remove, value=set. */
+  subject?: string | null;
   /** New appearance blend mode. Omit to preserve the current effective mode. */
   blendMode?: BlendMode;
   /**
@@ -2371,6 +2838,64 @@ declare function refKey(ref: AnnotationRef): string;
  */
 declare function buildThreads(annotations: readonly AnnotationDTO[]): AnnotationThread[];
 //#endregion
+//#region src/annotation/comments.d.ts
+/** One reviewer's status, derived from an ISO §12.5.6.3 state annotation. */
+interface ReviewStatus {
+  /** Wire-normalized when known (`'accepted'`, …); verbatim when custom. */
+  state: string;
+  /** `'review'`, `'marked'`, or a custom model verbatim. */
+  stateModel: string;
+  /** Reviewer key: `/EMBD_Metadata` userId, else `/T`, else null. */
+  by: string | null;
+  /** `/M` ?? `/CreationDate` of the state annotation (ISO 8601). */
+  at: string | null;
+  /** The state annotation itself — for auditing or deletion. */
+  ref: AnnotationRef;
+}
+/**
+ * Review state of one thread. The two ISO state models are independent
+ * axes: `byReviewer` / `lastChange` cover the review axis (the standard
+ * `Review` model plus custom models), while the personal-checkmark
+ * `Marked` axis lives solely in `markedBy`.
+ */
+interface CommentThreadReview {
+  /** Latest review-axis status per reviewer key (unattributed skipped). */
+  byReviewer: Record<string, ReviewStatus>;
+  /** Latest review-axis change overall — a convenience, NOT a verdict. */
+  lastChange: ReviewStatus | null;
+  /** Reviewer keys whose latest Marked-model status is `'marked'`. */
+  markedBy: string[];
+  /**
+   * Every state annotation in the thread's subtree (both axes, all
+   * reviewers, chronological) — thread MEMBERSHIP, not status history:
+   * deleting a whole thread must delete its state annotations too, and
+   * the classified summaries above deliberately drop superseded refs.
+   */
+  statusRefs: AnnotationRef[];
+  /** `byReviewer[currentUserId]`; only set when the option was given. */
+  mine?: ReviewStatus | null;
+}
+interface CommentThread<T extends AnnotationDTO = AnnotationDTO> {
+  root: T;
+  pageObjectNumber: PageObjectNumber;
+  /** Whole-subtree replies, flattened chronologically; states excluded. */
+  replies: T[];
+  /** Every `/RT /Group` subordinate found in the subtree. */
+  groupedParts: T[];
+  review: CommentThreadReview;
+}
+interface BuildCommentThreadsOptions {
+  /** Compute `review.mine` against this reviewer key. */
+  currentUserId?: string;
+}
+/**
+ * An ISO 32000 §12.5.6.3 state annotation: a text annotation carrying a
+ * non-empty `/State` or `/StateModel`. Classification never relies on
+ * flags — producers disagree on how state annotations are flagged.
+ */
+declare function isStateAnnotation(a: AnnotationDTO): boolean;
+declare function buildCommentThreads(annotations: readonly AnnotationDTO[], opts?: BuildCommentThreadsOptions): CommentThread[];
+//#endregion
 //#region src/dto/LayerScopes.d.ts
 /**
  * Plane-scope block: a layer is a set of per-plane DELTAS
@@ -2455,6 +2980,19 @@ interface DocumentManifest {
    * caches stay warm across unrelated edits (the `layoutVersion` design).
    */
   attachmentsVersion: number;
+  /**
+   * Doc-level pin for the immutable whole-document annotation listing
+   * (`/annotations/items@annotationsVersion=N`) — the cloud's one-request
+   * hydration read. Bumps ONLY when annotation list BODIES change —
+   * annotation create/update/delete/move, page insert/delete,
+   * redaction-apply, flatten, and form field/widget structure — and
+   * deliberately NOT on form value writes (widget DTOs carry no value;
+   * only `/AP` rasters change, which the per-page `annotationVersion`
+   * covers), metadata, attachments, or page move/rotate (bulk page order
+   * is unspecified by contract). The same independent-cadence design as
+   * `layoutVersion` / `metadataVersion`.
+   */
+  annotationsVersion: number;
   /**
    * Audit-log head at this manifest's state — written in the same
    * transaction as the version bumps, so an event subscriber that starts
@@ -2473,61 +3011,6 @@ interface DocumentManifest {
   pages: ManifestPage[];
 }
 //#endregion
-//#region src/dto/PdfDestination.d.ts
-/**
- * An explicit PDF destination (ISO 32000-1 §12.3.2.2): a page, a location,
- * and a magnification. Produced by outlines/bookmarks, link annotations,
- * `/OpenAction`, and GoTo actions; named destinations resolve to one of
- * these through the catalog's `/Dests` dictionary or name tree — the
- * ENGINE does that resolution, so the viewer only ever sees this explicit
- * form.
- *
- * Coordinates are PDF user space (y-up, points, absolute — NOT
- * crop-relative). `null` means "retain the current value" (the spec's
- * meaning for null array entries); a `/XYZ` zoom of `0` is equivalent to
- * null. The `fitB*` kinds refer to the page's content BOUNDING box rather
- * than the crop box.
- *
- * Viewers translate these onto the stage's reveal primitive — see
- * `destinationToReveal` in `@embedpdf/plugin-stage`.
- */
-type PdfDestination = {
-  kind: 'xyz';
-  pageObjectNumber: PageObjectNumber;
-  left?: number | null;
-  top?: number | null;
-  zoom?: number | null;
-} | {
-  kind: 'fit';
-  pageObjectNumber: PageObjectNumber;
-} | {
-  kind: 'fitH';
-  pageObjectNumber: PageObjectNumber;
-  top?: number | null;
-} | {
-  kind: 'fitV';
-  pageObjectNumber: PageObjectNumber;
-  left?: number | null;
-} | {
-  kind: 'fitR';
-  pageObjectNumber: PageObjectNumber;
-  left: number;
-  bottom: number;
-  right: number;
-  top: number;
-} | {
-  kind: 'fitB';
-  pageObjectNumber: PageObjectNumber;
-} | {
-  kind: 'fitBH';
-  pageObjectNumber: PageObjectNumber;
-  top?: number | null;
-} | {
-  kind: 'fitBV';
-  pageObjectNumber: PageObjectNumber;
-  left?: number | null;
-};
-//#endregion
 //#region src/dto/PdfLinkTarget.d.ts
 /**
  * Where a link annotation points, NORMALIZED. A link may carry either a
@@ -2604,6 +3087,14 @@ type PdfLinkTargetWritable = Extract<PdfLinkTarget, {
 interface CacheDelta {
   previousDocVersion: number;
   docVersion: number;
+  /**
+   * New doc-level bulk annotations pin, present when this mutation bumped
+   * it (annotation CRUD, page insert/delete, redaction, flatten, form
+   * structure — see `DocumentManifest.annotationsVersion`). Absorbing it
+   * keeps the client's cached manifest addressing the fresh bulk leaf
+   * without a 404-refresh round trip.
+   */
+  annotationsVersion?: number;
   pages: Array<{
     pageObjectNumber: PageObjectNumber;
     cache: CachePins;
@@ -3316,6 +3807,59 @@ type FormFieldValue = {
 /** Serialized form-data interchange formats. */
 type FormDataFormat = 'fdf' | 'xfdf';
 //#endregion
+//#region src/forms/submission.d.ts
+/**
+ * One resolved entry of a form submission. The viewer resolved it with the
+ * ISO 32000-2 Table 239/240 semantics already applied (Include/Exclude +
+ * descendants, the unconditional NoExport veto, push-button and
+ * unsupported-value exclusion), so the home never re-derives selection.
+ * `value === null` is a NAME-ONLY entry (the IncludeNoValueFields shape);
+ * `string[]` is a multi-select list box.
+ */
+interface FormSubmissionEntry {
+  name: string;
+  value: string | string[] | null;
+}
+/**
+ * What a submit-capable document HOME receives — the resolved dataset plus
+ * the document's declared intent as METADATA. The stack never fetches the
+ * declared URL itself (a PDF-controlled URL reaching a server-side fetcher
+ * is the SSRF class this contract exists to prevent); the home stores the
+ * intent so its consumers can decide what to honor.
+ *
+ * Deliberately ABSENT: identity. The home derives who submitted from its
+ * OWN verified session (the JWT it authenticated) — a client-supplied
+ * identity would be a spoofing surface.
+ */
+interface FormSubmissionRequest {
+  entries: FormSubmissionEntry[];
+  /** The document's declared routing wish, verbatim (metadata, not orders).
+   *  `url` is null for scripted submits that named no target. */
+  intent: {
+    url: string | null;
+    format: 'fdf' | 'html' | 'xfdf' | 'pdf';
+    method: 'post' | 'get';
+    /** Raw ISO Table 240 flag word (0 for scripted submits without one). */
+    flagsRaw: number;
+    /** /CharSet (PDF 2.0), extracted but never encoded by this stack. */
+    charSet?: string;
+  };
+  /** How the submission was triggered — the viewer-derived origin axis. */
+  origin: 'user' | 'hover' | 'lifecycle';
+  /** Client wall-clock, milliseconds since epoch. Informational — the home
+   *  stamps its own authoritative `receivedAt`. */
+  clientTimeMs: number;
+}
+/** The home's acknowledgment: the stored submission's durable identity. */
+interface FormSubmissionReceipt {
+  submissionId: string;
+  /** ISO 8601, the home's clock. */
+  receivedAt: string;
+}
+declare const FormSubmissionEntrySchema: z.ZodType<FormSubmissionEntry>;
+declare const FormSubmissionRequestSchema: z.ZodType<FormSubmissionRequest>;
+declare const FormSubmissionReceiptSchema: z.ZodType<FormSubmissionReceipt>;
+//#endregion
 //#region src/forms/effects.d.ts
 type FormFieldDisplay = 'visible' | 'hidden' | 'noPrint' | 'noView';
 /** Ordered, committed outputs of one client-side form script run. */
@@ -3438,6 +3982,85 @@ interface FormRepairResult {
   meta: MutationMeta;
 }
 //#endregion
+//#region src/text/layout.d.ts
+/**
+ * One merged visual line of a text range, in PDF user space. `quad` is the
+ * geometric authority (frame-geometric slot order: `p1..p4` = upper-start,
+ * upper-end, lower-start, lower-end — visual semantics, NOT reading order);
+ * `rect` is its axis-aligned bounds, produced by the same constructor.
+ * `advance` is the READING direction along the baseline, derived from the
+ * glyph SEQUENCE (+1 = the frame's +x), never inferred from geometry.
+ */
+interface PdfTextSegment {
+  quad: PdfQuad;
+  rect: PdfRect;
+  advance: 1 | -1;
+}
+/** One glyph in its frame's space. `loose` builds segments; `tight` hit-tests. */
+interface TextLayoutGlyph {
+  loose: PdfRect;
+  tight?: PdfRect;
+  flags: number;
+}
+/** A contiguous run of glyphs (a text object) in one frame. */
+interface TextLayoutRun {
+  /** First char index — identical to the flat glyph index (runs tile the page). */
+  charStart: number;
+  count: number;
+  /** Frame-local loose box (page space itself in frame 0). */
+  rect: PdfRect;
+  fontSize?: number;
+  /** Index into {@link PageTextLayout.frames}; 0 = page space (upright). */
+  frame: number;
+}
+/** An orientation cluster's orthonormal basis in page space. */
+interface TextLayoutFrame {
+  /** Unit vector along the reading baseline (+x of the frame). */
+  baseline: PdfPoint;
+  /** Unit vector toward the ascent side (+y of the frame), ⟂ baseline. */
+  ascent: PdfPoint;
+}
+/**
+ * A page's text laid out per-frame: a flat glyph list (index = text-page
+ * char index), the run structure, and the orientation frames.
+ */
+interface PageTextLayout {
+  glyphs: TextLayoutGlyph[];
+  runs: TextLayoutRun[];
+  frames: TextLayoutFrame[];
+}
+/**
+ * Flatten a page's geometry snapshot into the canonical layout. Upright runs
+ * copy their wire boxes verbatim (frame 0 — byte-identical to the
+ * pre-orientation behavior, wire run rects included); rotated runs project
+ * their glyph cells into their cluster's frame.
+ */
+declare function buildPageTextLayout(snapshot: PageGeometrySnapshot): PageTextLayout;
+/**
+ * The glyph (char) index at a page-space point, or null when nothing is near
+ * (so callers can show the pointer cursor off-text). PDFium `GetIndexAtPos`:
+ * exact tight-box containment first, then a tolerance pass (closest by
+ * Manhattan distance within `toleranceFactor × average glyph height`). Each
+ * run tests the point in ITS OWN frame, so rotated text hit-tests exactly.
+ */
+declare function textGlyphAt(layout: PageTextLayout, point: PdfPoint, toleranceFactor?: number): number | null;
+/** Double-click: the word around `glyph` (walk to space/empty glyphs both ways). */
+declare function expandTextRangeToWord(layout: PageTextLayout, glyph: number): [number, number];
+/** Triple-click: the full visual line — SAME-FRAME runs whose vertical extent
+ *  overlaps the anchor run's. A differently-oriented run is a line boundary. */
+declare function expandTextRangeToLine(layout: PageTextLayout, glyph: number): [number, number];
+/**
+ * A single glyph's oriented cell in page space, or null for degenerate
+ * glyphs — the anchor for caret placement at a selection boundary.
+ */
+declare function textGlyphQuad(layout: PageTextLayout, glyph: number): PdfQuad | null;
+/**
+ * Merged visual-line segments for the half-open char range
+ * `[charStart, charStart + charCount)` — THE canonical segmentation. Chars
+ * outside the layout are ignored.
+ */
+declare function textSegmentsForRange(layout: PageTextLayout, charStart: number, charCount: number): PdfTextSegment[];
+//#endregion
 //#region src/search/types.d.ts
 /**
  * What to search for — THE one shape, engine → wire → plugin state →
@@ -3548,19 +4171,26 @@ interface SearchSnippet {
   matchLength: number;
 }
 /**
- * One hit. `charStart`/`charCount` index the page's text-page character
- * space — the same space as `PageTextSnapshot.text` offsets and
- * `PageGeometryRun.charStart` — so a match joins the selection subsystem
- * (extend-selection-from-match, highlight annotations) without any
- * re-mapping. `rects` are merged line boxes in PDF user space (y-up),
- * built by the same line-merge as text selection — matches highlight
- * exactly like selections, one rect per visual line, never per glyph.
+ * One hit. `charStart`/`charCount` are a half-open range in the page's
+ * CHARACTER space — the space `PageGeometryRun.charStart` tiles and
+ * selection ranges live in, NOT string offsets into `PageTextSnapshot.text`
+ * (engines convert match string-ranges through the snapshot's `charMap`
+ * before building the hit; see engine-core `text/charmap.ts`). That is what
+ * lets a match join the selection subsystem — select-this-match, markup
+ * creation — with no re-mapping, and it means zero-width characters
+ * adjacent to the matched text are never inside the range. Snippet offsets
+ * are the one exception: they are string offsets INTERNAL to the snippet's
+ * own `text`. `segments` are the CANONICAL visual-line segments (the same
+ * engine-core text layout selection uses) — a match highlights exactly like
+ * a selection of the same characters, one oriented segment per visual line,
+ * never per glyph. Each segment carries the exact quad, its AABB `rect`,
+ * and the reading `advance`.
  */
 interface SearchMatch {
   pageObjectNumber: PageObjectNumber;
   charStart: number;
   charCount: number;
-  rects: PdfRect[];
+  segments: PdfTextSegment[];
   snippet?: SearchSnippet;
 }
 /**
@@ -3724,10 +4354,14 @@ declare function buildSnippet(text: string, range: SearchMatchRange, context?: n
 //#endregion
 //#region src/search/rects.d.ts
 /**
- * Merged line rects for the text-page char range
- * `[charStart, charStart + charCount)`. Ranges index the same space as
- * `PageGeometryRun.charStart`; chars outside the snapshot are ignored.
+ * Match-range → canonical visual-line segments. Thin wrappers over the ONE
+ * text layout (`src/text/layout.ts`) — search owns matching and cursors,
+ * never segmentation, so a match highlights exactly like a selection of the
+ * same characters. No frame or merge logic lives here.
  */
+/** Canonical segments for `[charStart, charStart + charCount)`. */
+declare function searchSegmentsForRange(snapshot: PageGeometrySnapshot, charStart: number, charCount: number): PdfTextSegment[];
+/** The segments' AABBs — for consumers that genuinely want boxes. */
 declare function searchRectsForRange(snapshot: PageGeometrySnapshot, charStart: number, charCount: number): PdfRect[];
 //#endregion
 //#region src/search/epoch.d.ts
@@ -3917,6 +4551,29 @@ interface PageInsertResult {
   cache: PageStructureCache | null;
 }
 //#endregion
+//#region src/mutation/PageInsertBlankInput.d.ts
+/**
+ * Upper bound on `count` for a single `pages.insertBlank()` call. A CONTRACT
+ * cap, enforced identically by every engine (the cloud input schema carries
+ * the same number), so a UI never discovers a lower server limit by surprise.
+ * Larger batches are a loop at the call site.
+ */
+declare const PAGE_INSERT_BLANK_MAX_COUNT = 100;
+/**
+ * Spec for `pages.insertBlank()`: create `count` blank pages of `size`.
+ *
+ * `size` is explicit and in PDF points, un-rotated — the same convention as
+ * `PageLayout.size`. The "match my neighbour" default developers expect is a
+ * registry read, so it lives in the page-edit capability, not here: the
+ * engine wire never guesses (the `rotateBy` law).
+ */
+interface PageInsertBlankSpec {
+  /** Page size in PDF points. Both dimensions must be finite and > 0. */
+  size: PdfSize;
+  /** Pages to create, in `[1, PAGE_INSERT_BLANK_MAX_COUNT]`. Default 1. */
+  count?: number;
+}
+//#endregion
 //#region src/mutation/PageFlattenResult.d.ts
 type PageFlattenUsage = 'display' | 'print';
 type PageFlattenStatus = 'applied' | 'unchanged' | 'failed' | 'skipped';
@@ -4388,12 +5045,16 @@ interface LinkPatch extends AnnotationPatchBase {
   target?: PdfLinkTargetWritable | null;
 }
 //#endregion
-//#region src/annotation/kinds/link/schema.d.ts
+//#region src/dto/PdfDestination.schema.d.ts
 /**
- * Runtime schema for {@link PdfDestination}. Lives with the link kind (its
- * first wire consumer); the outline/bookmark port reuses it from here.
+ * Runtime schema for {@link PdfDestination}. Lives beside its DTO in `dto/`
+ * so every destination-shaped surface (link targets, action-node payloads,
+ * the document `openDestination`) shares one schema without an import cycle
+ * through the annotation tree.
  */
 declare const PdfDestinationSchema: z.ZodType<PdfDestination>;
+//#endregion
+//#region src/annotation/kinds/link/schema.d.ts
 declare const PdfLinkTargetSchema: z.ZodType<PdfLinkTarget>;
 /** Drafts/patches only author `goto`/`uri` — see {@link PdfLinkTargetWritable}. */
 declare const PdfLinkTargetWritableSchema: z.ZodType<PdfLinkTargetWritable>;
@@ -4558,6 +5219,9 @@ interface CaretDraft extends AnnotationDraftBase, ColorStyleDraftFields {
   rect: PdfRect;
   /** `/RD` inset of the drawn caret from `/Rect`. */
   rectDifferences?: PdfRectDifferences | null;
+  /** Tri-state box-rotation pair (see the DTO): omitted/`null` = upright. */
+  rotation?: number | null;
+  unrotatedRect?: PdfRect | null;
 }
 //#endregion
 //#region src/annotation/kinds/caret/dto.d.ts
@@ -4565,6 +5229,12 @@ interface CaretDraft extends AnnotationDraftBase, ColorStyleDraftFields {
  * Caret annotation — a visual marker for a proposed text insertion or edit
  * point. It carries no geometry of its own beyond `/Rect`: just a `/C` color,
  * `/CA` opacity, and an optional `/RD` inset of the drawn symbol from `/Rect`.
+ *
+ * A caret anchored to ROTATED text carries the box-family rotation pair:
+ * `rotation` (`/EMBD_Metadata/Rotation`, PDF-convention degrees) tilts the
+ * baked symbol to ride its text's baseline, `unrotatedRect` is the logical
+ * box, and `/Rect` stays the rotated visual AABB — exactly the shape/free-text
+ * contract, so the generic AP machinery bakes it.
  */
 type CaretAnnotationDTO = AnnotationBase & ColorStyleFields & {
   subtype: 'caret';
@@ -4572,6 +5242,10 @@ type CaretAnnotationDTO = AnnotationBase & ColorStyleFields & {
   intent: CaretIntent | null;
   /** `/RD` inset of the drawn caret from `/Rect`; `null` when absent. */
   rectDifferences: PdfRectDifferences | null;
+  /** `/EMBD_Metadata/Rotation` — degrees, normalized `[0,360)`. */
+  rotation?: number;
+  /** `/EMBD_Metadata/UnrotatedRect` — the logical box (required when rotation != 0). */
+  unrotatedRect?: PdfRect;
 };
 //#endregion
 //#region src/annotation/kinds/caret/patch.d.ts
@@ -4581,6 +5255,10 @@ interface CaretPatch extends AnnotationPatchBase, ColorStylePatchFields {
   rect?: PdfRect;
   /** Tri-state: omitted preserves, a value sets, `null` removes `/RD`. */
   rectDifferences?: PdfRectDifferences | null;
+  /** Tri-state: omitted preserves, `null`/`0` flattens, a value sets (needs the box). */
+  rotation?: number | null;
+  /** Tri-state: omitted preserves, `null` removes, a value sets. */
+  unrotatedRect?: PdfRect | null;
 }
 //#endregion
 //#region src/annotation/kinds/caret/schema.d.ts
@@ -4608,6 +5286,16 @@ interface TextDraft extends AnnotationDraftBase, ColorStyleDraftFields {
   rect: PdfRect;
   /** `/Name` icon. Default `'note'` (the ISO 32000 default). */
   icon?: NoteIcon;
+  /**
+   * Write `/State` + `/StateModel`, making this draft an ISO 32000
+   * §12.5.6.3 review-status reply (pair with `inReplyTo` → the annotation
+   * under review). `state` requires `stateModel` — the engine throws
+   * `InvalidArg` otherwise. `stateModel` alone is valid: the model's
+   * default state applies (`none` for review, `unmarked` for marked).
+   */
+  state?: AnnotationState;
+  /** See {@link state}. */
+  stateModel?: AnnotationStateModel;
 }
 //#endregion
 //#region src/annotation/kinds/text/dto.d.ts
@@ -4621,6 +5309,17 @@ type TextAnnotationDTO = AnnotationBase & ColorStyleFields & {
   subtype: 'text';
   /** `/Name` icon; an absent `/Name` reads as `'note'` (the ISO default). */
   icon: NoteIcon;
+  /**
+   * `/State` — ISO 32000 §12.5.6.3 annotation state, carried by a
+   * review-status reply (a text annotation whose `inReplyTo` points at
+   * the annotation being reviewed). Faithful read: `null` iff the key
+   * is absent. ISO defaulting — a `stateModel` present with no explicit
+   * `state` implies `none` (review) / `unmarked` (marked) — is a
+   * thread-composer concern, deliberately not applied here.
+   */
+  state: AnnotationState | null;
+  /** `/StateModel` — see {@link state}. `null` iff the key is absent. */
+  stateModel: AnnotationStateModel | null;
 };
 //#endregion
 //#region src/annotation/kinds/text/patch.d.ts
@@ -4628,6 +5327,10 @@ interface TextPatch extends AnnotationPatchBase, ColorStylePatchFields {
   subtype: 'text';
   rect?: PdfRect;
   icon?: NoteIcon;
+  /** `/State`, three-state: undefined=leave, null=remove the entry, value=set. */
+  state?: AnnotationState | null;
+  /** `/StateModel`, three-state: undefined=leave, null=remove the entry, value=set. */
+  stateModel?: AnnotationStateModel | null;
 }
 //#endregion
 //#region src/annotation/kinds/text/schema.d.ts
@@ -5019,11 +5722,27 @@ declare const AnnotationPatchSchema: z.ZodType<WireAnnotationPatch>;
 /**
  * Whole-document raw read response. Returned by
  * `DocumentAnnotationsService.listRawAll()` and over the wire as the
- * cloud layer annotation reads. Page order matches the document's
- * page index.
+ * cloud layer annotation reads.
+ *
+ * One entry per page. ORDER IS UNSPECIFIED — the local engine serves
+ * document order while the cloud engine serves manifest (pageObjectNumber
+ * registry) order; join `pageState.pageObjectNumber` against
+ * `pages.list()` when display order matters.
  */
 interface AnnotationListSnapshotAllPages {
   pages: AnnotationListPageSnapshot[];
+  /**
+   * Audit-log position this snapshot is consistent with (cloud only;
+   * absent locally, where no audit log exists). Every page reflects
+   * exactly the mutations with `serverId <= auditHead` and none newer —
+   * the reads are pinned to one manifest, whose `auditHead` is written in
+   * the same transaction as its version bumps.
+   *
+   * This is the reconciliation cursor for consumers that keep a snapshot
+   * fresh from `doc.events`: drop events with `origin.serverId <=
+   * auditHead` (already inside the snapshot), apply the rest.
+   */
+  auditHead?: number;
 }
 /**
  * Single-page raw or full read response. Returned by
@@ -5039,5 +5758,5 @@ interface AnnotationListPageSnapshot {
   annotations: AnnotationDTO[];
 }
 //#endregion
-export { CaretDraftSchema as $, AnnotationIdentityQuality as $a, LayerScopes as $i, searchRectsForRange as $n, pdfQuadCorners as $o, ListBoxFieldDraft as $r, revisionTokensEqual as $s, CircleDraftSchema as $t, FileAttachmentWireDraftSchema as A, EmbeddedFileItem as Aa, PdfSize as Ac, AnnotationCreateResult as Ai, HighlightDraft as An, PageImageHandle as Ao, FormFieldDeleteResult as Ar, filterMatches as As, LineDraft as At, StampAnnotationDTO as B, BinarySource as Ba, PdfPageActions as Bc, changesAnnotationList as Bi, PageFlattenStatus as Bn, PageRenderOptions as Bo, FormFieldDisplay as Br, CollabEntity as Bs, PolygonPatch as Bt, RedactDraft as C, GeometryStyleDraftFields as Ca, InkList as Cc, ToggleFieldWidget as Ci, UnderlineAnnotationDTO as Cn, AnnotationAppearancesQuery as Co, SearchQuery as Cr, CollabTarget as Cs, LinkAnnotationDTO as Ct, FileAttachmentDTOSchema as D, AttachmentFileBase as Da, PdfQuad as Dc, FormWidgetRef as Di, HighlightPatchSchema as Dn, WeakAnnotationState as Do, SearchSnippet as Dr, checkSetGroup as Ds, LinePatchSchema as Dt, WidgetDraft as E, AttachmentContent as Ea, PdfPoint as Ec, FormFieldRef as Ei, HighlightDraftSchema as En, UNKNOWN_WEAK_ANNOTATION_STATE as Eo, SearchSliceBudget as Er, checkCollab as Es, LineDraftSchema as Et, StampDTOSchema as F, normalizeAnnotationPatch as Fa, PdfActionTree as Fc, AppearanceImpact as Fi, RedactionApplyScope as Fn, PageNetworkRenderFormat as Fo, FormWidgetLinkResult as Fr, validateScopeArray as Fs, PolylineAnnotationDTO as Ft, TextDTOSchema as G, ANNOTATION_SUBTYPES as Ga, CacheDelta as Gi, PageRotateResult as Gn, PageGeometryGlyph as Go, FormFieldPatch as Gr, ParsedCollab as Gs, VertexPatchFields as Gt, StampFit as H, WireResource as Ha, DocumentMetadataTrapped as Hc, shiftsExistingAnnotationIndices as Hi, PageInsertResult as Hn, PageRenderTarget as Ho, FormFieldValue as Hr, DocCapability as Hs, PolygonDraft as Ht, StampWireDraftSchema as I, BinaryMetadata as Ia, PdfActionType as Ic, AppearanceOutcome as Ii, RedactionApplyStatus as In, PageRaster as Io, FormEffect as Ir, PDF_BITS as Is, PolylineDraft as It, TextPatch as J, PDF_SUBTYPE_TO_CODE as Ja, PdfLinkTargetWritable as Ji, PageMoveResult as Jn, PageTextSnapshot as Jo, TextFieldPatch as Jr, ParsedWildcard as Js, SquarePatchSchema as Jt, TextDraftSchema as K, AnnotationSubtype as Ka, MutationMeta as Ki, PageRotateInput as Kn, PageGeometryRun as Ko, ListBoxFieldPatch as Kr, ParsedScope as Ks, SquareDTOSchema as Kt, StampWirePatchSchema as L, BinaryMimeType as La, PdfActionWarning as Lc, appearanceImpactOf as Li, PageFlattenInput as Ln, PageRenderBackground as Lo, FormEffectResult as Lr, decodePdfBits as Ls, PolygonDTOSchema as Lt, FileAttachmentPatch as M, NormalizedDraft as Ma, DocumentActionsSnapshot as Mc, AnnotationMoveResult as Mi, MetadataUpdateResult as Mn, PageImageOptions as Mo, FormImportResult as Mr, MissingIdentity as Ms, PolylineDraftSchema as Mt, FileAttachmentAnnotationDTO as N, NormalizedPatch as Na, NamedJavaScriptAction as Nc, AnnotationUpdateResult as Ni, RedactionApplyItemResult as Nn, PageImageResult as No, FormRepairResult as Nr, PermissionDenied as Ns, PolylinePatchSchema as Nt, FileAttachmentIconSchema as O, AttachmentFileInfo as Oa, PdfRect as Oc, decodeFieldRefKey as Oi, HighlightPatch as On, knownWeakAnnotationState as Oo, FormDataExport as Or, expandRawScope as Os, LinePatch as Ot, ResourceRefSchema as P, normalizeAnnotationDraft as Pa, PdfActionNode as Pc, AppearanceAction as Pi, RedactionApplyResult as Pn, PageImageSource as Po, FormSetValueResult as Pr, parseScope as Ps, PolylinePatch as Pt, CaretDTOSchema as Q, AnnotationBase as Qa, LayerScopePlane as Qi, searchContentEpoch as Qn, pdfQuadBounds as Qo, FormFieldOptionInput as Qr, RevisionToken as Qs, CircleDTOSchema as Qt, StampPatch as R, sniffBinaryMetadata as Ra, PdfAnnotationActions as Rc, semanticEqual as Ri, PageFlattenItemResult as Rn, PageRenderEncodedFormat as Ro, FormEffectStatus as Rr, AnnotationActor as Rs, PolygonDraftSchema as Rt, RedactAnnotationDTO as S, FilledStylePatchFields as Sa, CalloutLine as Sc, TextFieldDTO as Si, UnderlinePatch as Sn, AnnotationAppearanceRenderOptions as So, SearchMode as Sr, pdfPermissions as Ss, LinkPatch as St, WidgetAnnotationDTO as T, GeometryStylePatchFields as Ta, LinePoints as Tc, FormValueEntry as Ti, HighlightDTOSchema as Tn, PageState as To, SearchSlice as Tr, checkCapability as Ts, LineDTOSchema as Tt, StampWireDraft as U, WireResourceMap as Ua, AnnotationListMutationMeta as Ui, PageDeleteResult as Un, PageRenderViewport as Uo, CheckboxFieldPatch as Ur, IdentityClaims as Us, VertexAnnotationFields as Ut, StampDraft as V, ResourceRef as Va, DocumentMetadata as Vc, invalidatesWeakIndexRefs as Vi, PageFlattenUsage as Vn, PageRenderQuery as Vo, FormDataFormat as Vr, CollabFilter as Vs, PolygonAnnotationDTO as Vt, NoteIconSchema as W, resolveBinarySource as Wa, RefetchReason as Wi, PageDeleteInput as Wn, createPageImageHandle as Wo, ComboBoxFieldPatch as Wr, ParsedCapability as Ws, VertexDraftFields as Wt, NoteIcon as X, subtypeFromCode as Xa, DocumentManifest as Xi, PageMoveInput as Xn, PdfQuadCorners as Xo, ComboBoxFieldDraft as Xr, AnnotationDraftBase as Xs, SquareAnnotationDTO as Xt, TextAnnotationDTO as Y, PdfAnnotationSubtypeCode as Ya, PdfDestination as Yi, PageStructureCache as Yn, PdfOriginSize as Yo, CheckboxFieldDraft as Yr, PdfBits as Ys, SquarePatch as Yt, TextDraft as Z, AnnotationPatchBase as Za, ManifestPage as Zi, canonicalSearchQuery as Zn, normalizePdfRect as Zo, FormFieldDraft as Zr, AnnotationRef as Zs, SquareDraft as Zt, UnsupportedPatchSchema as _, ColorStyleDraftFields as _a, Rotation as _c, FormFieldOrigin as _i, SquigglyAnnotationDTO as _n, AnnotationAppearanceImagesResult as _o, SEARCH_FOLD_VERSION as _r, OpenOptions as _s, LinkDraftSchema as _t, AnnotationDTOSchema as a, AnnotationKindModule as aa, BlendMode as ac, WidgetAppearance as ai, ShapeDraftFields as an, SerializedEngineError as ao, SearchQueryValidation as ar, pdfRectWidth as as, FreeTextDraftSchema as at, UnsupportedAnnotationDTO as b, FilledStyleDraftFields as ba, StrikeoutIntent as bc, RadioFieldDTO as bi, UnderlineDraftSchema as bn, AnnotationAppearanceMode as bo, toOriginalRange as br, collab as bs, PdfLinkTargetSchema as bt, AnnotationKind as c, PatchOfKind as ca, FreeTextFont as cc, WidgetStyleFields as ci, StrikeoutDraftSchema as cn, EngineErrorCode as co, matchRegex as cr, PageLayout as cs, FreeTextAnnotationDTO as ct, AnnotationSubtypeOfKind as d, AttachmentsCache as da, LineEnding as dc, ComboBoxFieldDTO as di, StrikeoutAnnotationDTO as dn, FontSpec as do, foldOptionsFor as dr, OpenInput as ds, InkDraftSchema as dt, AnnotationRelationKind as ea, PageObjectNumber as ec, RadioFieldDraft as ei, CirclePatchSchema as en, AnnotationStableId as eo, SEARCH_SNIPPET_CONTEXT as er, pdfQuadFromCorners as es, CaretPatchSchema as et, KIND_BY_SUBTYPE as f, normalizeAttachmentFileSource as fa, LineEndings as fc, FormFieldBase as fi, StrikeoutDraft as fn, DEFAULT_PDF_SAVE_MODE as fo, matchLiteral as fr, OpenInputById as fs, InkPatchSchema as ft, UnsupportedDraftSchema as g, WireAttachmentFile as ga, Rect as gc, FormFieldOption as gi, SquigglyPatch as gn, AnnotationAppearanceImageOptions as go, FoldedText as gr, OpenInputToken as gs, LinkDTOSchema as gt, UnsupportedDTOSchema as h, FileAttachmentWireDraft as ha, Point as hc, FormFieldFlags as hi, SquigglyPatchSchema as hn, AnnotationAppearanceImage as ho, FoldOptions as hr, OpenInputLayerSource as hs, InkDraft as ht, AnnotationDTO as i, refKey as ia, AnnotationReplyType as ic, FormSnapshot as ii, ShapeAnnotationFields as in, EngineErrorOptions as io, SearchQueryIssue as ir, pdfRectToOriginSize as is, FreeTextDTOSchema as it, WireAttachmentFileSchema as j, EmbeddedFileRef as ja, ActionReadBudget as jc, AnnotationDeleteResult as ji, MetadataCache as jn, PageImageObjectUrl as jo, FormFieldUpdateResult as jr, InvalidScope as js, PolylineDTOSchema as jt, FileAttachmentPatchSchema as k, AttachmentFileSource as ka, PdfRotation as kc, encodeFieldRefKey as ki, HighlightAnnotationDTO as kn, PageImageBlobSource as ko, FormFieldCreateResult as kr, expandedCapabilities as ks, LineAnnotationDTO as kt, AnnotationPatch as l, AttachmentCreateResult as la, FreeTextIntent as lc, WidgetStylePatchFields as li, StrikeoutPatchSchema as ln, FontHandle as lo, validateSearchQuery as lr, PageRotation as ls, FreeTextDraft as lt, WireAnnotationPatch as m, FileAttachmentIcon as ma, PdfRectDifferences as mc, FormFieldFamily as mi, SquigglyDraftSchema as mn, CachePins as mo, wordBefore as mr, OpenInputLayerBytes as ms, InkAnnotationDTO as mt, AnnotationListSnapshotAllPages as n, buildThreads as na, AnnotationBorderStyle as nc, WidgetPlacement as ni, CircleAnnotationDTO as nn, encodeStableIdKey as no, matchPageText as nr, pdfRectHeight as ns, CaretAnnotationDTO as nt, AnnotationDraft as o, DTOOfKind as oa, CaretIntent as oc, WidgetAppearanceSchema as oi, ShapePatchFields as on, deserializeError as oo, SearchRegexIssue as or, PageListSnapshot as os, FreeTextPatchSchema as ot, WireAnnotationDraft as p, FileAttachmentDraft as pa, NO_ANNOTATION_FLAGS as pc, FormFieldDTO as pi, SquigglyDTOSchema as pn, PdfSaveMode as po, wordAt as pr, OpenInputBytes as ps, InkPatch as pt, TextPatchSchema as q, PDF_CODE_TO_SUBTYPE as qa, PdfLinkTarget as qi, PageMoveCache as qn, PageGeometrySnapshot as qo, RadioFieldPatch as qr, ParsedVirtual as qs, SquareDraftSchema as qt, ANNOTATION_KINDS as r, classifyRelation as ra, AnnotationFlags as rc, FormKind as ri, CircleDraft as rn, EngineError as ro, SEARCH_REGEX_MAX_LENGTH as rr, pdfRectSize as rs, CaretDraft as rt, AnnotationDraftSchema as s, DraftOfKind as sa, Color as sc, WidgetStyleDraftFields as si, StrikeoutDTOSchema as sn, serializeError as so, SearchRegexValidation as sr, PageBoxes as ss, FreeTextPatch as st, AnnotationListPageSnapshot as t, AnnotationThread as ta, isValidPageObjectNumber as tc, TextFieldDraft as ti, CirclePatch as tn, decodeStableIdKey as to, buildSnippet as tr, pdfRectFromOriginSize as ts, CaretPatch as tt, AnnotationPatchSchema as u, AttachmentDeleteResult as ua, InkIntent as uc, CheckboxFieldDTO as ui, StrikeoutPatch as un, FontKey as uo, validateSearchRegex as ur, MetadataPatch as us, InkDTOSchema as ut, UnsupportedPatch as v, ColorStyleFields as va, Size as vc, ListBoxFieldDTO as vi, SquigglyDraft as vn, AnnotationAppearanceManifest as vo, SearchMatchRange as vr, TokenSource as vs, LinkPatchSchema as vt, WidgetPatch as w, GeometryStyleFields as wa, InkStroke as wc, UnknownFieldDTO as wi, UnderlineDraft as wn, AnnotationAppearancesResult as wo, SearchRequest as wr, checkAnyCapability as ws, LinkDraft as wt, RedactPatch as x, FilledStyleFields as xa, TextAlignment as xc, SignatureFieldDTO as xi, UnderlinePatchSchema as xn, AnnotationAppearanceRaster as xo, SearchMatch as xr, materializePdfPermissions as xs, PdfLinkTargetWritableSchema as xt, UnsupportedDraft as y, ColorStylePatchFields as ya, StandardFont as yc, PushButtonFieldDTO as yi, UnderlineDTOSchema as yn, AnnotationAppearanceManifestEntry as yo, foldText as yr, caps as ys, PdfDestinationSchema as yt, StampWirePatch as z, BinaryPayload as za, PdfFieldActions as zc, AnnotationMutationKind as zi, PageFlattenResult as zn, PageRenderFormat as zo, FormEffectsResult as zr, CollabAction as zs, PolygonPatchSchema as zt };
-//# sourceMappingURL=AnnotationListSnapshot-W0RCsyDE.d.cts.map
+export { CaretDraftSchema as $, AttachmentFileInfo as $a, Rect as $c, AnnotationUpdateResult as $i, canonicalSearchQuery as $n, knownWeakAnnotationState as $o, FormEffectsResult as $r, OpenInputLayerSource as $s, CircleDraftSchema as $t, FileAttachmentWireDraftSchema as A, AnnotationKindModule as Aa, ParsedCollab as Ac, CheckboxFieldDTO as Ai, isValidPageObjectNumber as Al, HighlightDraft as An, SerializedEngineError as Ao, SearchSnippet as Ar, charMapViolation as As, LineDraft as At, StampAnnotationDTO as B, FileAttachmentWireDraft as Ba, AnnotationFlags as Bc, RadioFieldDTO as Bi, PageFlattenStatus as Bn, AnnotationAppearanceImage as Bo, textGlyphQuad as Br, pdfRectHeight as Bs, PolygonPatch as Bt, RedactDraft as C, buildCommentThreads as Ca, AnnotationActor as Cc, FormKind as Ci, PdfFieldActions as Cl, UnderlineAnnotationDTO as Cn, AnnotationBase as Co, toOriginalRange as Cr, glyphLooseQuad as Cs, LinkAnnotationDTO as Ct, FileAttachmentDTOSchema as D, buildThreads as Da, DocCapability as Dc, WidgetStyleDraftFields as Di, decodeSubmitFormFlags as Dl, HighlightPatchSchema as Dn, encodeStableIdKey as Do, SearchRequest as Dr, CharMapAnchor as Ds, LinePatchSchema as Dt, WidgetDraft as E, AnnotationThread as Ea, CollabFilter as Ec, WidgetAppearanceSchema as Ei, SubmitFormPayload as El, HighlightDraftSchema as En, decodeStableIdKey as Eo, SearchQuery as Er, CharBoundaryBias as Es, LineDraftSchema as Et, StampDTOSchema as F, AttachmentDeleteResult as Fa, AnnotationDraftBase as Fc, FormFieldFlags as Fi, RedactionApplyScope as Fn, FontKey as Fo, TextLayoutRun as Fr, normalizePdfRect as Fs, PolylineAnnotationDTO as Ft, TextDTOSchema as G, FilledStyleDraftFields as Ga, FreeTextFont as Gc, FormValueEntry as Gi, PageDeleteResult as Gn, AnnotationAppearanceMode as Go, FormFieldUpdateResult as Gr, PageBoxes as Gs, VertexPatchFields as Gt, StampFit as H, ColorStyleDraftFields as Ha, BlendMode as Hc, TextFieldDTO as Hi, PAGE_INSERT_BLANK_MAX_COUNT as Hn, AnnotationAppearanceImagesResult as Ho, FormDataExport as Hr, pdfRectToOriginSize as Hs, PolygonDraft as Ht, StampWireDraftSchema as I, AttachmentsCache as Ia, AnnotationRef as Ic, FormFieldOption as Ii, RedactionApplyStatus as In, FontSpec as Io, buildPageTextLayout as Ir, pdfQuadBounds as Is, PolylineDraft as It, TextPatch as J, GeometryStyleDraftFields as Ja, LineEnding as Jc, decodeFieldRefKey as Ji, PageRotateInput as Jn, AnnotationAppearancesQuery as Jo, FormSetValueResult as Jr, MetadataPatch as Js, SquarePatchSchema as Jt, TextDraftSchema as K, FilledStyleFields as Ka, FreeTextIntent as Kc, FormFieldRef as Ki, PageDeleteInput as Kn, AnnotationAppearanceRaster as Ko, FormImportResult as Kr, PageLayout as Ks, SquareDTOSchema as Kt, StampWirePatchSchema as L, normalizeAttachmentFileSource as La, RevisionToken as Lc, FormFieldOrigin as Li, PageFlattenInput as Ln, DEFAULT_PDF_SAVE_MODE as Lo, expandTextRangeToLine as Lr, pdfQuadCorners as Ls, PolygonDTOSchema as Lt, FileAttachmentPatch as M, DraftOfKind as Ma, ParsedVirtual as Mc, FormFieldBase as Mi, DocumentMetadataTrapped as Ml, MetadataUpdateResult as Mn, serializeError as Mo, PdfTextSegment as Mr, sliceTextByChars as Ms, PolylineDraftSchema as Mt, FileAttachmentAnnotationDTO as N, PatchOfKind as Na, ParsedWildcard as Nc, FormFieldDTO as Ni, RedactionApplyItemResult as Nn, EngineErrorCode as No, TextLayoutFrame as Nr, PdfOriginSize as Ns, PolylinePatchSchema as Nt, FileAttachmentIconSchema as O, classifyRelation as Oa, IdentityClaims as Oc, WidgetStyleFields as Oi, PdfDestination as Ol, HighlightPatch as On, EngineError as Oo, SearchSlice as Or, boundaryTextOffset as Os, LinePatch as Ot, ResourceRefSchema as P, AttachmentCreateResult as Pa, PdfBits as Pc, FormFieldFamily as Pi, RedactionApplyResult as Pn, FontHandle as Po, TextLayoutGlyph as Pr, PdfQuadCorners as Ps, PolylinePatch as Pt, CaretDTOSchema as Q, AttachmentFileBase as Qa, Point as Qc, AnnotationMoveResult as Qi, PageMoveInput as Qn, WeakAnnotationState as Qo, FormEffectStatus as Qr, OpenInputLayerBytes as Qs, CircleDTOSchema as Qt, StampPatch as R, FileAttachmentDraft as Ra, revisionTokensEqual as Rc, ListBoxFieldDTO as Ri, PageFlattenItemResult as Rn, PdfSaveMode as Ro, expandTextRangeToWord as Rr, pdfQuadFromCorners as Rs, PolygonDraftSchema as Rt, RedactAnnotationDTO as S, ReviewStatus as Sa, decodePdfBits as Sc, WidgetPlacement as Si, PdfAnnotationActions as Sl, UnderlinePatch as Sn, AnnotationPatchBase as So, foldText as Sr, glyphLooseBounds as Ss, LinkPatch as St, WidgetAnnotationDTO as T, AnnotationRelationKind as Ta, CollabEntity as Tc, WidgetAppearance as Ti, SubmitFormFlags as Tl, HighlightDTOSchema as Tn, AnnotationStableId as To, SearchMode as Tr, PageTextSnapshot as Ts, LineDTOSchema as Tt, StampWireDraft as U, ColorStyleFields as Ua, CaretIntent as Uc, ToggleFieldWidget as Ui, PageInsertBlankSpec as Un, AnnotationAppearanceManifest as Uo, FormFieldCreateResult as Ur, pdfRectWidth as Us, VertexAnnotationFields as Ut, StampDraft as V, WireAttachmentFile as Va, AnnotationReplyType as Vc, SignatureFieldDTO as Vi, PageFlattenUsage as Vn, AnnotationAppearanceImageOptions as Vo, textSegmentsForRange as Vr, pdfRectSize as Vs, PolygonAnnotationDTO as Vt, NoteIconSchema as W, ColorStylePatchFields as Wa, Color as Wc, UnknownFieldDTO as Wi, PageInsertResult as Wn, AnnotationAppearanceManifestEntry as Wo, FormFieldDeleteResult as Wr, PageListSnapshot as Ws, VertexDraftFields as Wt, NoteIcon as X, GeometryStylePatchFields as Xa, NO_ANNOTATION_FLAGS as Xc, AnnotationCreateResult as Xi, PageMoveResult as Xn, PageState as Xo, FormEffect as Xr, OpenInputById as Xs, SquareAnnotationDTO as Xt, TextAnnotationDTO as Y, GeometryStyleFields as Ya, LineEndings as Yc, encodeFieldRefKey as Yi, PageMoveCache as Yn, AnnotationAppearancesResult as Yo, FormWidgetLinkResult as Yr, OpenInput as Ys, SquarePatch as Yt, TextDraft as Z, AttachmentContent as Za, PdfRectDifferences as Zc, AnnotationDeleteResult as Zi, PageStructureCache as Zn, UNKNOWN_WEAK_ANNOTATION_STATE as Zo, FormEffectResult as Zr, OpenInputBytes as Zs, SquareDraft as Zt, UnsupportedPatchSchema as _, LayerScopePlane as _a, MissingIdentity as _c, FormFieldDraft as _i, PdfActionNode as _l, SquigglyAnnotationDTO as _n, AnnotationSubtype as _o, wordBefore as _r, PageGeometryRun as _s, LinkDraftSchema as _t, AnnotationDTOSchema as a, AnnotationMutationKind as aa, collab as ac, FormSubmissionRequest as ai, CalloutLine as al, ShapeDraftFields as an, normalizeAnnotationDraft as ao, matchPageText as ar, PageImageSource as as, FreeTextDraftSchema as at, UnsupportedAnnotationDTO as b, CommentThread as ba, validateScopeArray as bc, RadioFieldDraft as bi, PdfActionType as bl, UnderlineDraftSchema as bn, PdfAnnotationSubtypeCode as bo, SEARCH_FOLD_VERSION as br, RotatedGeometryRun as bs, PdfLinkTargetWritableSchema as bt, AnnotationKind as c, shiftsExistingAnnotationIndices as ca, CollabTarget as cc, FormFieldValue as ci, LinePoints as cl, StrikeoutDraftSchema as cn, BinaryMimeType as co, SearchQueryValidation as cr, PageRenderBackground as cs, FreeTextAnnotationDTO as ct, AnnotationSubtypeOfKind as d, CacheDelta as da, checkCollab as dc, FormFieldPatch as di, PdfRect as dl, StrikeoutAnnotationDTO as dn, BinarySource as do, matchRegex as dr, PageRenderOptions as ds, InkDraftSchema as dt, AppearanceAction as ea, OpenInputShare as ec, FormFieldDisplay as ei, Rotation as el, CirclePatchSchema as en, AttachmentFileSource as eo, searchContentEpoch as er, PageImageBlobSource as es, CaretPatchSchema as et, KIND_BY_SUBTYPE as f, MutationMeta as fa, checkSetGroup as fc, ListBoxFieldPatch as fi, PdfRotation as fl, StrikeoutDraft as fn, ResourceRef as fo, validateSearchQuery as fr, PageRenderQuery as fs, InkPatchSchema as ft, UnsupportedDraftSchema as g, ManifestPage as ga, InvalidScope as gc, ComboBoxFieldDraft as gi, NamedJavaScriptAction as gl, SquigglyPatch as gn, ANNOTATION_SUBTYPES as go, wordAt as gr, PageGeometryGlyph as gs, LinkDTOSchema as gt, UnsupportedDTOSchema as h, DocumentManifest as ha, filterMatches as hc, CheckboxFieldDraft as hi, DocumentActionsSnapshot as hl, SquigglyPatchSchema as hn, resolveBinarySource as ho, matchLiteral as hr, createPageImageHandle as hs, InkDraft as ht, AnnotationDTO as i, semanticEqual as ia, caps as ic, FormSubmissionReceiptSchema as ii, TextAlignment as il, ShapeAnnotationFields as in, NormalizedPatch as io, buildSnippet as ir, PageImageResult as is, FreeTextDTOSchema as it, WireAttachmentFileSchema as j, DTOOfKind as ja, ParsedScope as jc, ComboBoxFieldDTO as ji, DocumentMetadata as jl, MetadataCache as jn, deserializeError as jo, PageTextLayout as jr, charRangeForTextOffsets as js, PolylineDTOSchema as jt, FileAttachmentPatchSchema as k, refKey as ka, ParsedCapability as kc, WidgetStylePatchFields as ki, PageObjectNumber as kl, HighlightAnnotationDTO as kn, EngineErrorOptions as ko, SearchSliceBudget as kr, charBoundaryAtTextOffset as ks, LineAnnotationDTO as kt, AnnotationPatch as l, AnnotationListMutationMeta as la, checkAnyCapability as lc, CheckboxFieldPatch as li, PdfPoint as ll, StrikeoutPatchSchema as ln, sniffBinaryMetadata as lo, SearchRegexIssue as lr, PageRenderEncodedFormat as ls, FreeTextDraft as lt, WireAnnotationPatch as m, PdfLinkTargetWritable as ma, expandedCapabilities as mc, TextFieldPatch as mi, ActionReadBudget as ml, SquigglyDraftSchema as mn, WireResourceMap as mo, foldOptionsFor as mr, PageRenderViewport as ms, InkAnnotationDTO as mt, AnnotationListSnapshotAllPages as n, AppearanceOutcome as na, OpenOptions as nc, FormSubmissionEntrySchema as ni, StandardFont as nl, CircleAnnotationDTO as nn, EmbeddedFileRef as no, searchSegmentsForRange as nr, PageImageObjectUrl as ns, CaretAnnotationDTO as nt, AnnotationDraft as o, changesAnnotationList as oa, materializePdfPermissions as oc, FormSubmissionRequestSchema as oi, InkList as ol, ShapePatchFields as on, normalizeAnnotationPatch as oo, SEARCH_REGEX_MAX_LENGTH as or, PageNetworkRenderFormat as os, FreeTextPatchSchema as ot, WireAnnotationDraft as p, PdfLinkTarget as pa, expandRawScope as pc, RadioFieldPatch as pi, PdfSize as pl, SquigglyDTOSchema as pn, WireResource as po, validateSearchRegex as pr, PageRenderTarget as ps, InkPatch as pt, TextPatchSchema as q, FilledStylePatchFields as qa, InkIntent as qc, FormWidgetRef as qi, PageRotateResult as qn, AnnotationAppearanceRenderOptions as qo, FormRepairResult as qr, PageRotation as qs, SquareDraftSchema as qt, ANNOTATION_KINDS as r, appearanceImpactOf as ra, TokenSource as rc, FormSubmissionReceipt as ri, StrikeoutIntent as rl, CircleDraft as rn, NormalizedDraft as ro, SEARCH_SNIPPET_CONTEXT as rr, PageImageOptions as rs, CaretDraft as rt, AnnotationDraftSchema as s, invalidatesWeakIndexRefs as sa, pdfPermissions as sc, FormDataFormat as si, InkStroke as sl, StrikeoutDTOSchema as sn, BinaryMetadata as so, SearchQueryIssue as sr, PageRaster as ss, FreeTextPatch as st, AnnotationListPageSnapshot as t, AppearanceImpact as ta, OpenInputToken as tc, FormSubmissionEntry as ti, Size as tl, CirclePatch as tn, EmbeddedFileItem as to, searchRectsForRange as tr, PageImageHandle as ts, CaretPatch as tt, AnnotationPatchSchema as u, RefetchReason as ua, checkCapability as uc, ComboBoxFieldPatch as ui, PdfQuad as ul, StrikeoutPatch as un, BinaryPayload as uo, SearchRegexValidation as ur, PageRenderFormat as us, InkDTOSchema as ut, UnsupportedPatch as v, LayerScopes as va, PermissionDenied as vc, FormFieldOptionInput as vi, PdfActionTargetRef as vl, SquigglyDraft as vn, PDF_CODE_TO_SUBTYPE as vo, FoldOptions as vr, PageGeometrySnapshot as vs, LinkPatchSchema as vt, WidgetPatch as w, isStateAnnotation as wa, CollabAction as wc, FormSnapshot as wi, PdfPageActions as wl, UnderlineDraft as wn, AnnotationIdentityQuality as wo, SearchMatch as wr, isRotatedGeometryRun as ws, LinkDraft as wt, RedactPatch as x, CommentThreadReview as xa, PDF_BITS as xc, TextFieldDraft as xi, PdfActionWarning as xl, UnderlinePatchSchema as xn, subtypeFromCode as xo, SearchMatchRange as xr, UprightGeometryRun as xs, PdfDestinationSchema as xt, UnsupportedDraft as y, BuildCommentThreadsOptions as ya, parseScope as yc, ListBoxFieldDraft as yi, PdfActionTree as yl, UnderlineDTOSchema as yn, PDF_SUBTYPE_TO_CODE as yo, FoldedText as yr, RotatedGeometryGlyph as ys, PdfLinkTargetSchema as yt, StampWirePatch as z, FileAttachmentIcon as za, AnnotationBorderStyle as zc, PushButtonFieldDTO as zi, PageFlattenResult as zn, CachePins as zo, textGlyphAt as zr, pdfRectFromOriginSize as zs, PolygonPatchSchema as zt };
+//# sourceMappingURL=AnnotationListSnapshot-C1U3XUxP.d.cts.map