@embedpdf/engine-core 3.0.0-next.0 → 3.0.0-next.10

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

@@ -116,9 +116,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 +294,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.
@@ -392,6 +426,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. */
@@ -932,9 +968,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 +985,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 +1211,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 +1339,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 +1368,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 +1434,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 +1656,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 +1816,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 +1998,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 +2088,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 +2618,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 +2760,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
@@ -2604,6 +2922,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;
@@ -3438,6 +3764,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 +3953,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 +4136,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 +4333,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';
@@ -4558,6 +4997,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 +5007,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 +5020,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 +5033,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 +5064,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 +5087,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 +5105,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 +5500,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 +5536,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 $, NormalizedPatch as $a, StandardFont as $c, AnnotationMutationKind as $i, canonicalSearchQuery as $n, PageImageResult as $o, FormEffectsResult as $r, caps as $s, CircleDraftSchema as $t, FileAttachmentWireDraftSchema as A, AttachmentDeleteResult as Aa, AnnotationDraftBase as Ac, FormFieldOption as Ai, HighlightDraft as An, FontKey as Ao, SearchSnippet as Ar, normalizePdfRect as As, LineDraft as At, StampAnnotationDTO as B, FilledStyleDraftFields as Ba, CaretIntent as Bc, FormFieldRef as Bi, PageFlattenStatus as Bn, AnnotationAppearanceMode as Bo, textGlyphQuad as Br, PageBoxes as Bs, PolygonPatch as Bt, RedactDraft as C, classifyRelation as Ca, IdentityClaims as Cc, WidgetStylePatchFields as Ci, UnderlineAnnotationDTO as Cn, EngineError as Co, toOriginalRange as Cr, boundaryTextOffset as Cs, LinkAnnotationDTO as Ct, FileAttachmentDTOSchema as D, DraftOfKind as Da, ParsedVirtual as Dc, FormFieldDTO as Di, HighlightPatchSchema as Dn, serializeError as Do, SearchRequest as Dr, sliceTextByChars as Ds, LinePatchSchema as Dt, WidgetDraft as E, DTOOfKind as Ea, ParsedScope as Ec, FormFieldBase as Ei, HighlightDraftSchema as En, deserializeError as Eo, SearchQuery as Er, charRangeForTextOffsets as Es, LineDraftSchema as Et, StampDTOSchema as F, FileAttachmentWireDraft as Fa, isValidPageObjectNumber as Fc, SignatureFieldDTO as Fi, RedactionApplyScope as Fn, AnnotationAppearanceImage as Fo, TextLayoutRun as Fr, pdfRectHeight as Fs, PolylineAnnotationDTO as Ft, TextDTOSchema as G, GeometryStylePatchFields as Ga, LineEnding as Gc, AnnotationDeleteResult as Gi, PageDeleteResult as Gn, PageState as Go, FormFieldUpdateResult as Gr, OpenInputById as Gs, VertexPatchFields as Gt, StampFit as H, FilledStylePatchFields as Ha, FreeTextFont as Hc, decodeFieldRefKey as Hi, PAGE_INSERT_BLANK_MAX_COUNT as Hn, AnnotationAppearanceRenderOptions as Ho, FormDataExport as Hr, PageRotation as Hs, PolygonDraft as Ht, StampWireDraftSchema as I, WireAttachmentFile as Ia, AnnotationBorderStyle as Ic, TextFieldDTO as Ii, RedactionApplyStatus as In, AnnotationAppearanceImageOptions as Io, buildPageTextLayout as Ir, pdfRectSize as Is, PolylineDraft as It, TextPatch as J, AttachmentFileInfo as Ja, PdfRectDifferences as Jc, AppearanceAction as Ji, PageRotateInput as Jn, knownWeakAnnotationState as Jo, FormSetValueResult as Jr, OpenInputLayerSource as Js, SquarePatchSchema as Jt, TextDraftSchema as K, AttachmentContent as Ka, LineEndings as Kc, AnnotationMoveResult as Ki, PageDeleteInput as Kn, UNKNOWN_WEAK_ANNOTATION_STATE as Ko, FormImportResult as Kr, OpenInputBytes as Ks, SquareDTOSchema as Kt, StampWirePatchSchema as L, ColorStyleDraftFields as La, AnnotationFlags as Lc, ToggleFieldWidget as Li, PageFlattenInput as Ln, AnnotationAppearanceImagesResult as Lo, expandTextRangeToLine as Lr, pdfRectToOriginSize as Ls, PolygonDTOSchema as Lt, FileAttachmentPatch as M, normalizeAttachmentFileSource as Ma, RevisionToken as Mc, ListBoxFieldDTO as Mi, MetadataUpdateResult as Mn, DEFAULT_PDF_SAVE_MODE as Mo, PdfTextSegment as Mr, pdfQuadCorners as Ms, PolylineDraftSchema as Mt, FileAttachmentAnnotationDTO as N, FileAttachmentDraft as Na, revisionTokensEqual as Nc, PushButtonFieldDTO as Ni, RedactionApplyItemResult as Nn, PdfSaveMode as No, TextLayoutFrame as Nr, pdfQuadFromCorners as Ns, PolylinePatchSchema as Nt, FileAttachmentIconSchema as O, PatchOfKind as Oa, ParsedWildcard as Oc, FormFieldFamily as Oi, HighlightPatch as On, EngineErrorCode as Oo, SearchSlice as Or, PdfOriginSize as Os, LinePatch as Ot, ResourceRefSchema as P, FileAttachmentIcon as Pa, PageObjectNumber as Pc, RadioFieldDTO as Pi, RedactionApplyResult as Pn, CachePins as Po, TextLayoutGlyph as Pr, pdfRectFromOriginSize as Ps, PolylinePatch as Pt, CaretDTOSchema as Q, NormalizedDraft as Qa, Size as Qc, semanticEqual as Qi, PageMoveInput as Qn, PageImageOptions as Qo, FormEffectStatus as Qr, TokenSource as Qs, CircleDTOSchema as Qt, StampPatch as R, ColorStyleFields as Ra, AnnotationReplyType as Rc, UnknownFieldDTO as Ri, PageFlattenItemResult as Rn, AnnotationAppearanceManifest as Ro, expandTextRangeToWord as Rr, pdfRectWidth as Rs, PolygonDraftSchema as Rt, RedactAnnotationDTO as S, buildThreads as Sa, DocCapability as Sc, WidgetStyleFields as Si, DocumentMetadataTrapped as Sl, UnderlinePatch as Sn, encodeStableIdKey as So, foldText as Sr, CharMapAnchor as Ss, LinkPatch as St, WidgetAnnotationDTO as T, AnnotationKindModule as Ta, ParsedCollab as Tc, ComboBoxFieldDTO as Ti, HighlightDTOSchema as Tn, SerializedEngineError as To, SearchMode as Tr, charMapViolation as Ts, LineDTOSchema as Tt, StampWireDraft as U, GeometryStyleDraftFields as Ua, FreeTextIntent as Uc, encodeFieldRefKey as Ui, PageInsertBlankSpec as Un, AnnotationAppearancesQuery as Uo, FormFieldCreateResult as Ur, MetadataPatch as Us, VertexAnnotationFields as Ut, StampDraft as V, FilledStyleFields as Va, Color as Vc, FormWidgetRef as Vi, PageFlattenUsage as Vn, AnnotationAppearanceRaster as Vo, textSegmentsForRange as Vr, PageLayout as Vs, PolygonAnnotationDTO as Vt, NoteIconSchema as W, GeometryStyleFields as Wa, InkIntent as Wc, AnnotationCreateResult as Wi, PageInsertResult as Wn, AnnotationAppearancesResult as Wo, FormFieldDeleteResult as Wr, OpenInput as Ws, VertexDraftFields as Wt, NoteIcon as X, EmbeddedFileItem as Xa, Rect as Xc, AppearanceOutcome as Xi, PageMoveResult as Xn, PageImageHandle as Xo, FormEffect as Xr, OpenInputToken as Xs, SquareAnnotationDTO as Xt, TextAnnotationDTO as Y, AttachmentFileSource as Ya, Point as Yc, AppearanceImpact as Yi, PageMoveCache as Yn, PageImageBlobSource as Yo, FormWidgetLinkResult as Yr, OpenInputShare as Ys, SquarePatch as Yt, TextDraft as Z, EmbeddedFileRef as Za, Rotation as Zc, appearanceImpactOf as Zi, PageStructureCache as Zn, PageImageObjectUrl as Zo, FormEffectResult as Zr, OpenOptions as Zs, SquareDraft as Zt, UnsupportedPatchSchema as _, ReviewStatus as _a, decodePdfBits as _c, FormKind as _i, PdfActionWarning as _l, SquigglyAnnotationDTO as _n, AnnotationPatchBase as _o, wordBefore as _r, glyphLooseBounds as _s, LinkDraftSchema as _t, AnnotationDTOSchema as a, CacheDelta as aa, checkCapability as ac, FormFieldPatch as ai, LinePoints as al, ShapeDraftFields as an, BinaryPayload as ao, matchPageText as ar, PageRenderFormat as as, FreeTextDraftSchema as at, UnsupportedAnnotationDTO as b, AnnotationRelationKind as ba, CollabEntity as bc, WidgetAppearanceSchema as bi, PdfPageActions as bl, UnderlineDraftSchema as bn, AnnotationStableId as bo, SEARCH_FOLD_VERSION as br, PageTextSnapshot as bs, PdfLinkTargetSchema as bt, AnnotationKind as c, PdfLinkTargetWritable as ca, expandRawScope as cc, TextFieldPatch as ci, PdfRect as cl, StrikeoutDraftSchema as cn, WireResource as co, SearchQueryValidation as cr, PageRenderTarget as cs, FreeTextAnnotationDTO as ct, AnnotationSubtypeOfKind as d, ManifestPage as da, InvalidScope as dc, FormFieldDraft as di, ActionReadBudget as dl, StrikeoutAnnotationDTO as dn, ANNOTATION_SUBTYPES as do, matchRegex as dr, PageGeometryGlyph as ds, InkDraftSchema as dt, changesAnnotationList as ea, collab as ec, FormFieldDisplay as ei, StrikeoutIntent as el, CirclePatchSchema as en, normalizeAnnotationDraft as eo, searchContentEpoch as er, PageImageSource as es, CaretPatchSchema as et, KIND_BY_SUBTYPE as f, LayerScopePlane as fa, MissingIdentity as fc, FormFieldOptionInput as fi, DocumentActionsSnapshot as fl, StrikeoutDraft as fn, AnnotationSubtype as fo, validateSearchQuery as fr, PageGeometryRun as fs, InkPatchSchema as ft, UnsupportedDraftSchema as g, CommentThreadReview as ga, PDF_BITS as gc, WidgetPlacement as gi, PdfActionType as gl, SquigglyPatch as gn, subtypeFromCode as go, wordAt as gr, UprightGeometryRun as gs, LinkDTOSchema as gt, UnsupportedDTOSchema as h, CommentThread as ha, validateScopeArray as hc, TextFieldDraft as hi, PdfActionTree as hl, SquigglyPatchSchema as hn, PdfAnnotationSubtypeCode as ho, matchLiteral as hr, RotatedGeometryRun as hs, InkDraft as ht, AnnotationDTO as i, RefetchReason as ia, checkAnyCapability as ic, ComboBoxFieldPatch as ii, InkStroke as il, ShapeAnnotationFields as in, sniffBinaryMetadata as io, buildSnippet as ir, PageRenderEncodedFormat as is, FreeTextDTOSchema as it, WireAttachmentFileSchema as j, AttachmentsCache as ja, AnnotationRef as jc, FormFieldOrigin as ji, MetadataCache as jn, FontSpec as jo, PageTextLayout as jr, pdfQuadBounds as js, PolylineDTOSchema as jt, FileAttachmentPatchSchema as k, AttachmentCreateResult as ka, PdfBits as kc, FormFieldFlags as ki, HighlightAnnotationDTO as kn, FontHandle as ko, SearchSliceBudget as kr, PdfQuadCorners as ks, LineAnnotationDTO as kt, AnnotationPatch as l, PdfDestination as la, expandedCapabilities as lc, CheckboxFieldDraft as li, PdfRotation as ll, StrikeoutPatchSchema as ln, WireResourceMap as lo, SearchRegexIssue as lr, PageRenderViewport as ls, FreeTextDraft as lt, WireAnnotationPatch as m, BuildCommentThreadsOptions as ma, parseScope as mc, RadioFieldDraft as mi, PdfActionNode as ml, SquigglyDraftSchema as mn, PDF_SUBTYPE_TO_CODE as mo, foldOptionsFor as mr, RotatedGeometryGlyph as ms, InkAnnotationDTO as mt, AnnotationListSnapshotAllPages as n, shiftsExistingAnnotationIndices as na, pdfPermissions as nc, FormFieldValue as ni, CalloutLine as nl, CircleAnnotationDTO as nn, BinaryMetadata as no, searchSegmentsForRange as nr, PageRaster as ns, CaretAnnotationDTO as nt, AnnotationDraft as o, MutationMeta as oa, checkCollab as oc, ListBoxFieldPatch as oi, PdfPoint as ol, ShapePatchFields as on, BinarySource as oo, SEARCH_REGEX_MAX_LENGTH as or, PageRenderOptions as os, FreeTextPatchSchema as ot, WireAnnotationDraft as p, LayerScopes as pa, PermissionDenied as pc, ListBoxFieldDraft as pi, NamedJavaScriptAction as pl, SquigglyDTOSchema as pn, PDF_CODE_TO_SUBTYPE as po, validateSearchRegex as pr, PageGeometrySnapshot as ps, InkPatch as pt, TextPatchSchema as q, AttachmentFileBase as qa, NO_ANNOTATION_FLAGS as qc, AnnotationUpdateResult as qi, PageRotateResult as qn, WeakAnnotationState as qo, FormRepairResult as qr, OpenInputLayerBytes as qs, SquareDraftSchema as qt, ANNOTATION_KINDS as r, AnnotationListMutationMeta as ra, CollabTarget as rc, CheckboxFieldPatch as ri, InkList as rl, CircleDraft as rn, BinaryMimeType as ro, SEARCH_SNIPPET_CONTEXT as rr, PageRenderBackground as rs, CaretDraft as rt, AnnotationDraftSchema as s, PdfLinkTarget as sa, checkSetGroup as sc, RadioFieldPatch as si, PdfQuad as sl, StrikeoutDTOSchema as sn, ResourceRef as so, SearchQueryIssue as sr, PageRenderQuery as ss, FreeTextPatch as st, AnnotationListPageSnapshot as t, invalidatesWeakIndexRefs as ta, materializePdfPermissions as tc, FormDataFormat as ti, TextAlignment as tl, CirclePatch as tn, normalizeAnnotationPatch as to, searchRectsForRange as tr, PageNetworkRenderFormat as ts, CaretPatch as tt, AnnotationPatchSchema as u, DocumentManifest as ua, filterMatches as uc, ComboBoxFieldDraft as ui, PdfSize as ul, StrikeoutPatch as un, resolveBinarySource as uo, SearchRegexValidation as ur, createPageImageHandle as us, InkDTOSchema as ut, UnsupportedPatch as v, buildCommentThreads as va, AnnotationActor as vc, FormSnapshot as vi, PdfAnnotationActions as vl, SquigglyDraft as vn, AnnotationBase as vo, FoldOptions as vr, glyphLooseQuad as vs, LinkPatchSchema as vt, WidgetPatch as w, refKey as wa, ParsedCapability as wc, CheckboxFieldDTO as wi, UnderlineDraft as wn, EngineErrorOptions as wo, SearchMatch as wr, charBoundaryAtTextOffset as ws, LinkDraft as wt, RedactPatch as x, AnnotationThread as xa, CollabFilter as xc, WidgetStyleDraftFields as xi, DocumentMetadata as xl, UnderlinePatchSchema as xn, decodeStableIdKey as xo, SearchMatchRange as xr, CharBoundaryBias as xs, PdfLinkTargetWritableSchema as xt, UnsupportedDraft as y, isStateAnnotation as ya, CollabAction as yc, WidgetAppearance as yi, PdfFieldActions as yl, UnderlineDTOSchema as yn, AnnotationIdentityQuality as yo, FoldedText as yr, isRotatedGeometryRun as ys, PdfDestinationSchema as yt, StampWirePatch as z, ColorStylePatchFields as za, BlendMode as zc, FormValueEntry as zi, PageFlattenResult as zn, AnnotationAppearanceManifestEntry as zo, textGlyphAt as zr, PageListSnapshot as zs, PolygonPatchSchema as zt };
+//# sourceMappingURL=AnnotationListSnapshot-DDxHpJQU.d.cts.map