@embedpdf/core-annotation 3.0.0-next.0

package/dist/index.d.cts

@@ -0,0 +1,1636 @@
+import { AnnotationDTO, AnnotationFlags, AnnotationFlags as AnnotationFlags$1, AnnotationRef, BlendMode, BlendMode as BlendMode$1, CaretIntent, InkIntent, LineEnding, LineEndings, NO_ANNOTATION_FLAGS, PdfLinkTarget, PdfPoint, PdfRect, StrikeoutIntent } from "@embedpdf/engine-core/runtime";
+import { PageObjectNumber } from "@embedpdf/core";
+import { PageRotation, Point, Rect as Rect$1, Size } from "@embedpdf/core-geometry";
+//#region src/flags.d.ts
+/** The `/F` every freshly DRAWN annotation starts with: `print` set (Acrobat
+ *  parity — without it the annotation silently disappears when printed). */
+declare const DRAWN_FLAGS: AnnotationFlags;
+/** All ten flags, for iteration/equality — kept in the primitives' order. */
+declare const FLAG_KEYS: ReadonlyArray<keyof AnnotationFlags>;
+declare const flagsEqual: (a: AnnotationFlags, b: AnnotationFlags) => boolean;
+/** Merge a partial write over the current flags. */
+declare const mergeFlags: (base: AnnotationFlags, patch: Partial<AnnotationFlags>) => AnnotationFlags;
+/**
+ * On-screen visibility. `hidden` beats everything; `noView` hides unless
+ * `toggleNoView` and the annotation is ENGAGED — the spec says hover/selection,
+ * and v1 uses selection (the model tracks no hover).
+ */
+declare const viewable: (f: AnnotationFlags, engaged?: boolean) => boolean;
+/** Any pointer interaction (click-to-select, hover). ReadOnly kills it. */
+declare const interactive: (f: AnnotationFlags) => boolean;
+/** The subset of an Annot these predicates read — keeps them testable bare. */
+interface FlagBearer {
+  subtype: string;
+  flags: AnnotationFlags;
+}
+/** Interaction gate for a concrete annotation: widget kinds ignore `readOnly`
+ *  (ISO 32000 — a ReadOnly form field must still be movable by a form designer;
+ *  the form-filling layer enforces field ReadOnly itself). */
+declare const annotInteractive: (a: FlagBearer) => boolean;
+/** Geometry/style/delete mutations — `locked` freezes the OBJECT, not its
+ *  contents (that's `lockedContents`). */
+declare const annotTransformable: (a: FlagBearer) => boolean;
+/** `/Contents` text edits — the contents counterpart of `locked`. */
+declare const annotContentsEditable: (a: FlagBearer) => boolean;
+//#endregion
+//#region src/types.d.ts
+/**
+ * Content-space point/rect (y-down, PDF points, crop-relative) — the viewer space.
+ * These are the shared `@embedpdf/core-geometry` primitives: a `Vec` IS a `Point`
+ * and `Rect` IS geometry's `Rect`, so the whole stack speaks one vocabulary and
+ * the coordinate math lives in ONE package.
+ */
+type Vec = Point;
+type Rect = Rect$1;
+/** Four content-space points (a /QuadPoints quad). */
+type Quad = [Vec, Vec, Vec, Vec];
+type Id = string;
+type Cursor = string;
+type PolySubtype = 'polygon' | 'polyline';
+/**
+ * The per-page view environment the screen-anchor projection consumes:
+ * `zoom` — the page's zoom RELATIVE to its 100% baseline (dimensionless;
+ * 1 = Acrobat's 100% = `viewUnitsPerPoint × userUnit` view px per point) —
+ * and the TOTAL display rotation (document /Rotate + view rotation).
+ * Deliberately NOT a px-per-point scale: `noZoom` means "hold the body at its
+ * 100%-zoom size", a statement about zoom, so feeding it a units conversion
+ * (the old mistake) shrank bodies at 100%. Per-event / per-call context (the
+ * `pageBox` pattern) — never stored on the model; the pointer drafts capture
+ * it at DOWN so anchored gestures project and commit with the view they
+ * started under. See anchor.ts.
+ */
+interface ViewEnv {
+  zoom: number;
+  rotation: PageRotation;
+}
+type Subtype = 'highlight' | 'underline' | 'squiggly' | 'strikeout' | 'square' | 'circle' | 'line' | 'polygon' | 'polyline' | 'caret' | 'ink' | 'stamp' | 'text' | 'file-attachment' | 'redact' | 'link' | (string & {});
+/**
+ * Content-space geometry — the ONE thing hit-testing, editing, and rendering work
+ * on. A small closed union covers every kind: shapes (rect/ellipse), line,
+ * polygon/polyline (poly), text markup (quads), and caret.
+ */
+/**
+ * A free-text callout's leader: the `/CL` line + `/LE` arrow. `tip` is the
+ * called-out point (the arrow is drawn here); `knee` is the optional elbow. The
+ * point where the leader meets the text box (the third `/CL` point) is NEVER
+ * stored — it is DERIVED from the box + the knee (see `calloutConnection`), so it
+ * can't drift when the box or knee moves. Content space (y-down).
+ */
+interface Callout {
+  tip: Vec;
+  knee?: Vec;
+  ending: LineEnding;
+}
+/**
+ * Rotation (degrees, clockwise in content space, normalized `[0,360)`) carried by
+ * the rotatable `Geom` variants. The semantics differ by family, which is exactly
+ * the box-vs-vertex split:
+ *
+ * - **Box** (`rect`, `text`): `rect` is the UNROTATED local box and `rot` is the
+ *   applied tilt — together they reconstruct the visual. The repository emits
+ *   `rect` as `unrotatedRect`, `rot` as the rendered `/EMBD_Metadata/Rotation`,
+ *   and the rotated visual AABB as `/Rect`, so PDFium bakes a portable `/AP`.
+ * - **Vertex** (`line`, `poly`, `ink`): the points are ALREADY rotated (they are
+ *   the portable visual), so `rot` is an ADVISORY scalar — the cumulative tilt the
+ *   user applied since authoring. It lets EmbedPDF reconstruct an oriented
+ *   selection box (`obbFromTheta`) and offer reset-to-0; it is inert for
+ *   rendering (PDFium ignores a lone `Rotation` with no `UnrotatedRect`).
+ */
+type Geom = {
+  t: 'rect';
+  rect: Rect;
+  ellipse: boolean;
+  rot?: number;
+} | {
+  t: 'line';
+  a: Vec;
+  b: Vec;
+  ends?: LineEndings;
+  rot?: number;
+} | {
+  t: 'poly';
+  points: Vec[];
+  closed: boolean;
+  ends?: LineEndings;
+  rot?: number;
+} | {
+  t: 'quads';
+  quads: Quad[];
+} | {
+  t: 'caret';
+  rect: Rect;
+} | {
+  t: 'ink';
+  strokes: Vec[][];
+  rot?: number;
+} | {
+  t: 'text';
+  rect: Rect;
+  callout?: Callout;
+  rot?: number;
+};
+/**
+ * How a shape's outline is stroked. A discriminated union so illegal combinations
+ * — a dash array on a cloudy border, an intensity on a dashed one — are simply
+ * unrepresentable. Maps onto the engine's `/BS /S` (`borderStyle`), `/BS /D`
+ * (`dashArray`), and `/BE /I` (`cloudyIntensity`) wire fields. Cloudy is only
+ * honoured for shapes (square/circle); other kinds treat it as solid.
+ */
+type Border = {
+  kind: 'solid';
+} | {
+  kind: 'dashed';
+  dash: number[];
+} | {
+  kind: 'cloudy';
+  intensity: number;
+};
+interface Style {
+  /** `/C` colour — stroke for geometric kinds, highlight colour for markup. */
+  color: string;
+  /** `/IC` interior (fill) colour. `null` when the annotation has no fill. */
+  interiorColor: string | null;
+  strokeWidth: number;
+  opacity: number;
+  /** Effective blend mode of the annotation's normal appearance. */
+  blendMode: BlendMode$1;
+  /** Outline style — defaults to `{ kind: 'solid' }`. */
+  border: Border;
+}
+type TextAlign = 'left' | 'center' | 'right';
+/**
+ * Content-space text styling for a text-editable kind (free text) — the text
+ * counterpart of {@link Style}, projected from the DTO's `/DA` fields the same
+ * way `style` is projected from `/C`/`/CA`/`/BS`. CSS colour string; the engine
+ * `Color` seam is crossed only in the plugin repository.
+ */
+interface TextStyle {
+  /** A PDF standard font name or a registered font key. */
+  fontFamily: string;
+  /** Content units (PDF points). */
+  fontSize: number;
+  fontColor: string;
+  textAlign: TextAlign;
+}
+/**
+ * The ONE flat vocabulary for editable appearance properties — what property
+ * sidebars/toolbars read and write, regardless of where each property is stored
+ * internally (`style`, `geom.ends`, or `text`). Which keys apply to a kind, and
+ * in what UI order, is declared per kind in the KIND table (`propsFor`).
+ */
+interface AnnotationProps extends Style, TextStyle {
+  /** `/LE` endings (line / polyline). */
+  lineEndings: LineEndings;
+  /**
+   * `/Name` icon of an icon kind (text note, file attachment). Optional in
+   * the bag — each kind falls back to its own spec default ('comment',
+   * 'paperclip') at creation, so one flat vocabulary needs no per-kind base
+   * value. Valid values are the `options` of the kind's `icon` PropSpec.
+   */
+  icon?: string;
+  /**
+   * Where this annotation LINKS to, or `null` for none. Optional in the bag
+   * like `icon`. One key, two storages (the props.ts routing rule): on the
+   * link kind it is the annotation's OWN target (`/A`); on every other
+   * linkable kind it is the target of the ATTACHED link child(ren) —
+   * grouped `/Link` annotations the model folds into their parent (the
+   * serialization the PDF spec forces, since only Link annotations are
+   * clickable). Writing it creates/retargets/deletes those children through
+   * the ONE `syncLink` seam.
+   */
+  link?: PdfLinkTarget | null;
+}
+type PropKey = keyof AnnotationProps;
+/**
+ * What a committed edit CHANGED — carried on the `patch` effect so the shell
+ * emits exactly that intent (repository `toScopedPatch`) instead of
+ * reconstructing a full projection. `geometry` covers every gesture commit
+ * (move/resize/rotate/vertex edit); `props` forwards the user's patch keys
+ * verbatim. Text content never rides this effect (the debounced text-edit
+ * write owns `contents`).
+ */
+type PatchScope = {
+  kind: 'geometry';
+} | {
+  kind: 'props';
+  keys: PropKey[];
+};
+/** A partial property write. `lineEndings` merges per side (set just `end`
+ *  without knowing `start`); every other key overwrites. */
+type AnnotationPropsPatch = { [K in PropKey]?: K extends 'lineEndings' ? Partial<LineEndings> : AnnotationProps[K]; };
+interface Annot {
+  id: Id;
+  ref: AnnotationRef | null;
+  pon: PageObjectNumber;
+  subtype: Subtype;
+  geom: Geom;
+  style: Style;
+  /** Text styling — present only for text-editable kinds (free text). Like
+   *  `style`, a content-space projection of `data`, editable via `setProps`. */
+  text?: TextStyle;
+  /** Redaction label (`/OverlayText` + `/Repeat`) — redact kind only. A
+   *  projection of `data` like `text`; the hover preview scene draws it. */
+  label?: {
+    text: string;
+    repeat: boolean;
+  };
+  /** `/Name` icon — present only for icon kinds (text note, file attachment).
+   *  Like `style`, a projection of `data`, editable via `setProps`. */
+  icon?: string;
+  /**
+   * The `/F` annotation flags, verbatim from the DTO (freshly drawn annotations
+   * start at {@link DRAWN_FLAGS} — `print` set). NEVER read individual keys to
+   * gate behavior — the predicates in `flags.ts` (`annotInteractive`,
+   * `annotTransformable`, `annotContentsEditable`, `viewable`) are the one
+   * interpretation of the spec, and `anchorModeOf` owns `noZoom`/`noRotate`.
+   */
+  flags: AnnotationFlags$1;
+  source: 'baked' | 'vector';
+  /**
+   * Content-space box of the engine appearance raster (the AP `/Rect`), set when
+   * the annotation is derived from a DTO. While `source === 'baked'` the renderer
+   * blits the engine bitmap into this box; a move translates it (a rigid shift
+   * keeps the raster valid), so the bitmap rides along without re-rendering.
+   * Ignored once `source === 'vector'`.
+   */
+  apBox?: Rect;
+  /**
+   * Rotation (deg, CW) that was STRIPPED from the baked raster — present only
+   * when the engine rendered this appearance rotation-free (a box-family kind
+   * whose DTO carries BOTH `rotation` and `unrotatedRect`; `apBox` is then the
+   * unrotated box). The blit re-applies it as a view transform about the box
+   * centre. Vertex kinds pre-rotate their geometry, so this stays unset there
+   * and their rasters blit untransformed.
+   */
+  apRot?: number;
+  /**
+   * Revision of the engine-baked `/AP` CONTENT (absent ≡ 0). The raster a baked
+   * annotation shows depends on exactly this and the render scale — never on
+   * position (`apBox` translates the blit) or rotation (`apRot` transforms it) —
+   * so the shell re-fetches appearances precisely when it changes. Bumped by the
+   * `upsert` that confirms an engine re-bake with new content: a geometry patch
+   * that changed the authoring frame's SIZE resolving (`Effect.apChanged`), or a
+   * remote edit folding in. A move or rotate leaves it untouched: the old raster
+   * is still pixel-exact, so those cost zero re-renders.
+   */
+  apVersion?: number;
+  /**
+   * The canonical engine DTO this annotation was derived from (PDF-space, sRGB)
+   * — the single source of truth for its data. `geom` and `style` are
+   * content-space RENDER PROJECTIONS of it, recomputed (never edited directly)
+   * whenever `data` changes, so the two can't drift. Absent only for a vector
+   * draft that hasn't been committed to the engine yet (no DTO exists).
+   */
+  data?: AnnotationDTO;
+  /** Normalized PDF `/IT` for intent-bearing annotations authored before a DTO exists. */
+  intent?: CaretIntent | StrikeoutIntent | InkIntent;
+  /**
+   * The `link` prop's value (see {@link AnnotationProps.link}): the link
+   * kind's own target, or — on other linkable kinds — the folded attached
+   * link's target. Editable via `setProps`.
+   */
+  link?: PdfLinkTarget | null;
+  /**
+   * INTERNAL join keys, never a prop: the engine refs of the attached link
+   * child annotation(s) this parent's `link` value is materialized as (one
+   * per visual segment for markup). Maintained by the repository fold and
+   * consumed by the shell's `syncLink` reconciler + delete expansion — the
+   * ONLY code allowed to touch those children. Absent on the link kind
+   * itself and on anything without an attached link.
+   */
+  linkRefs?: AnnotationRef[];
+  /**
+   * Relationship to another annotation. `irt` ("in reply to") links a child to a
+   * parent — a reply in a comment thread, or a caret bound to its strikeout in a
+   * replace-text pair. `group` ties a set into one composite unit (created and,
+   * typically, deleted together). Both are unused until comments / replace-text
+   * land, but the field lives here from the start so select/delete/persistence
+   * never have to be retrofitted around it.
+   */
+  irt?: Id;
+  group?: string;
+}
+/** A draggable handle: a resize corner/edge (rect) or a vertex (line/poly). */
+interface Handle {
+  id: string;
+  at: Vec;
+  cursor: Cursor;
+}
+/** An alignment guide produced by move-snapping: a vertical (`axis: 'x'`) or
+ *  horizontal (`axis: 'y'`) line at `at`, spanning `lo..hi` (content units). */
+interface Guide {
+  axis: 'x' | 'y';
+  at: number;
+  lo: number;
+  hi: number;
+}
+/** Snapping behaviour — seeded from the plugin config, live-adjustable via the
+ *  `setSnap` msg (so an app can wire a UI toggle). */
+interface SnapSettings {
+  /** Alignment guides while moving (snap to other annotations + the page). */
+  guides: boolean;
+  /** Guide snap tolerance, content units (PDF pt) — the `hitMargin` convention. */
+  guideThreshold: number;
+  /** Snap the rotate gesture onto `rotationAngles`. */
+  rotation: boolean;
+  rotationAngles: number[];
+  /** Rotation snap tolerance, degrees. */
+  rotationThreshold: number;
+}
+/**
+ * The `defaults` key a creation draft resolves its props from — the authoring
+ * TOOL that started it, which may differ from the PDF `subtype`. Two tools can
+ * share a subtype but carry distinct defaults (an "arrow" is a `line` with an
+ * arrowhead default); the preset keeps them apart. Absent → fall back to
+ * `subtype` (a headless / programmatic caller that isn't tool-driven), so the
+ * built-in tools where preset === subtype behave exactly as before.
+ */
+type Draft = {
+  g: 'create-rect';
+  subtype: Subtype;
+  preset?: string;
+  pon: PageObjectNumber;
+  from: Vec;
+  to: Vec;
+  ellipse: boolean;
+  /** Display rotation + upright policy captured at DOWN (the gesture's home
+   *  page), so the commit counter-rotates against what the author SAW even
+   *  if the up sample resolves elsewhere. See {@link PointerInput}. */
+  displayRotation?: PageRotation;
+  upright?: boolean;
+  /** The tool's click-create policy, captured at DOWN like `upright`. */
+  clickCreate?: ClickCreate | false;
+  /** The tool's `/F` seed, captured at DOWN like `upright` — merged over
+   *  {@link DRAWN_FLAGS} at commit (a note tool sets noZoom/noRotate). */
+  flags?: Partial<AnnotationFlags$1>;
+} | {
+  g: 'create-line';
+  subtype: Subtype;
+  preset?: string;
+  pon: PageObjectNumber;
+  from: Vec;
+  to: Vec;
+  /** The tool's click-create policy, captured at DOWN like `upright`. */
+  clickCreate?: ClickCreate | false;
+  /** The tool's `/F` seed, captured at DOWN (see the rect draft). */
+  flags?: Partial<AnnotationFlags$1>;
+} | {
+  g: 'create-poly';
+  subtype: Subtype;
+  preset?: string;
+  pon: PageObjectNumber;
+  points: Vec[];
+  cur: Vec;
+  closed: boolean;
+  /** The tool's `/F` seed, captured at DOWN (see the rect draft). */
+  flags?: Partial<AnnotationFlags$1>;
+} | {
+  g: 'create-ink';
+  subtype: Subtype;
+  preset?: string;
+  pon: PageObjectNumber;
+  strokes: Vec[][];
+  intent?: InkIntent;
+  /** The tool's `/F` seed, captured at DOWN (see the rect draft). */
+  flags?: Partial<AnnotationFlags$1>;
+} | {
+  g: 'create-callout';
+  subtype: Subtype;
+  preset?: string;
+  pon: PageObjectNumber;
+  step: 'knee' | 'box';
+  tip: Vec;
+  knee?: Vec;
+  cur: Vec;
+  boxFrom?: Vec;
+  boxTo?: Vec;
+  /** Display rotation + upright policy captured at the TIP click (the
+   *  gesture's home page) — the text BOX commits counter-rotated so it
+   *  reads upright; the leader (tip/knee) is page-space and never turns.
+   *  Same capture rule as the rect draft. */
+  displayRotation?: PageRotation;
+  upright?: boolean;
+  /** The tool's `/F` seed, captured at DOWN (see the rect draft). */
+  flags?: Partial<AnnotationFlags$1>;
+} | {
+  g: 'move';
+  ids: Id[];
+  start: Vec;
+  delta: Vec;
+  guides: Guide[];
+} | {
+  g: 'handle';
+  id: Id;
+  handle: string;
+  base: Geom;
+  cur: Geom;
+  view?: ViewEnv;
+} | {
+  g: 'rotate';
+  ids: Id[];
+  pivot: Vec;
+  start: Vec;
+  cur: Vec;
+  free?: boolean;
+  view?: ViewEnv;
+} | {
+  g: 'group';
+  op: 'resize';
+  ids: Id[];
+  handle: string;
+  anchor: Vec;
+  base: Rect;
+  cur: Rect;
+  view?: ViewEnv;
+} | {
+  g: 'marquee';
+  pon: PageObjectNumber;
+  from: Vec;
+  to: Vec;
+};
+/** A live text-markup preview (the in-progress selection rendered as the markup it
+ *  will become). Per page, since a selection can span pages. */
+interface MarkupPreview {
+  subtype: Subtype;
+  /** Defaults key, distinct from subtype for presets such as replace-text. */
+  preset: string;
+  byPage: Record<number, Quad[]>;
+}
+/** Anchor + affordance state for UI that controls an in-progress creation draft. */
+interface CreationDraftAnchor {
+  kind: 'poly';
+  subtype: PolySubtype;
+  pon: PageObjectNumber;
+  bounds: Rect;
+  pointCount: number;
+  minPoints: number;
+  canFinish: boolean;
+}
+interface Model {
+  byId: Record<Id, Annot>;
+  order: Id[];
+  selected: Id[];
+  /** The annotation under the pointer (topmost hit), or null. View-model
+   *  state like `selected` — drives hover affordances (a redaction mark's
+   *  applied-look preview) purely from the scene. Updated on CHANGE only
+   *  (enter/leave cadence, never per-move). */
+  hovered: Id | null;
+  draft: Draft | null;
+  /** Transient ghost of an in-progress markup selection (null when idle). */
+  preview: MarkupPreview | null;
+  seq: number;
+  /** The base style new annotations inherit (per-tool `defaults` layer on top). */
+  style: Style;
+  /** Per-tool (keyed by subtype / tool id) property overrides for newly drawn
+   *  annotations — the SAME flat vocabulary `setProps` uses. `lineEndings` is
+   *  stored fully resolved (merged at `setDefaults` time). */
+  defaults: Record<string, AnnotationPropsPatch>;
+  /** Extra clickable margin (content units) around a stroke — bump it for touch. */
+  hitMargin: number;
+  /** The free-text annotation currently in TEXT-EDIT mode (its `contentEditable`
+   *  is focused), or null. Distinct from `selected`: you select to move/resize,
+   *  you edit to type. */
+  editing: Id | null;
+  /** Snapping behaviour (alignment guides + rotation). */
+  snap: SnapSettings;
+}
+/**
+ * Selection-chrome geometry in CONTENT units — the grab zones and the knob
+ * stalk. The core is unit-agnostic and zoom-free: callers own the px→content
+ * conversion (settings are CSS px; divide by the page's view scale), so grab
+ * zones stay screen-constant across zoom.
+ */
+interface ChromeGeom {
+  /** Half-side of a resize/vertex handle's square grab zone. */
+  handleTol: number;
+  /** Half-side of the rotate knob's square grab zone. */
+  knobTol: number;
+  /** How far the rotate knob hangs off the selection edge. */
+  knobOffset: number;
+}
+interface PointerInput {
+  pon: PageObjectNumber;
+  point: Vec;
+  shift: boolean;
+  finish?: boolean;
+  /**
+   * The page's content box (`{0, 0, crop.width, crop.height}`) — when present,
+   * gestures are CLAMPED to it: a move keeps the selection's bounds inside the
+   * page (sliding along the edge when the pointer overshoots), resize/create
+   * points pin to the edge. Annotations are page-bound; the pointer isn't.
+   */
+  pageBox?: Rect;
+  /**
+   * Chrome grab-zone geometry for this event — per-event environmental context
+   * exactly like `pageBox` (the caller converts its CSS-px settings by the
+   * page's view scale at dispatch). Absent → `DEFAULT_CHROME_GEOM`.
+   */
+  chrome?: ChromeGeom;
+  /**
+   * The page's TOTAL display rotation (document /Rotate + view rotation) at the
+   * gesture — per-event environmental context like `pageBox`. A creation DOWN
+   * captures it on the draft (an `upright` commit counter-rotates against how
+   * the page was DISPLAYED); edit gestures read it per sample, paired with
+   * `scale`, so screen-anchored (`noZoom`/`noRotate`) annotations hit-test and
+   * clamp at their EFFECTIVE geometry. Content space itself never rotates.
+   */
+  displayRotation?: PageRotation;
+  /**
+   * The page's zoom RELATIVE to its 100% baseline at the event — the other
+   * half of the {@link ViewEnv} pair with `displayRotation` (dimensionless,
+   * `transform.zoom`; NOT the px-per-point scale the caller uses for its
+   * CSS-px chrome conversion). Absent → 1 (headless callers; screen-anchored
+   * bodies then hit-test at rect size).
+   */
+  zoom?: number;
+  /**
+   * Counter-rotate the created annotation so it reads upright at
+   * `displayRotation` — the authoring TOOL's `upright` policy, resolved by the
+   * caller (the core knows subtypes, not tools). Box kinds only (free-text /
+   * stamp are the ones with a natural reading orientation); vertex kinds and
+   * callouts ignore it.
+   */
+  upright?: boolean;
+  /**
+   * Ids invisible to hit-testing and marquee for THIS event — per-event
+   * environmental context like `pageBox`. The caller (plugin shell) resolves
+   * its engaged Behaviors (form widgets under a fill tool render their own
+   * DOM and must not select/move), so the core stays behavior-agnostic.
+   */
+  inert?: ReadonlySet<Id>;
+}
+/**
+ * What a bare CLICK (a press-release under the drag threshold) creates for a
+ * tool: a default-size box with an EXPLICIT anchor (`center` unless stated —
+ * free text declares `top-left` so the box hangs where you'll type,
+ * display-frame-aware under `upright`), or a default-length line from the
+ * point (`angleDeg` 0 = rightward, CW-positive in y-down space). Resolved
+ * from the TOOL by the caller and passed on the message — the core knows
+ * subtypes, not tools (the `upright` pattern). `false` suppresses a kind's
+ * own click fallback (free text always click-creates by default).
+ * Anchoring is policy DATA, never inferred from the kind — the same policy
+ * drives annotation commits, footprint ghosts, and form-field placement
+ * (see `resolveClickPlacement`).
+ */
+type ClickCreate = {
+  width: number;
+  height: number;
+  anchor?: 'center' | 'top-left';
+} | {
+  length: number;
+  angleDeg?: number;
+};
+type Msg = {
+  t: 'editPointer';
+  phase: 'down' | 'move' | 'up';
+  in: PointerInput;
+} | {
+  t: 'marqueePointer';
+  phase: 'down' | 'move' | 'up';
+  in: PointerInput;
+} | {
+  t: 'createPointer';
+  phase: 'down' | 'move' | 'up';
+  subtype: Subtype;
+  /** The authoring tool's `defaults` key (see {@link Draft}). Defaults to `subtype`. */
+  preset?: string;
+  /** PDF intent carried by an ink authoring preset. */
+  intent?: InkIntent;
+  /** The tool's click-create policy (see {@link ClickCreate}). */
+  clickCreate?: ClickCreate | false;
+  /** The tool's `/F` seed — merged over {@link DRAWN_FLAGS} at commit (a
+   *  note tool passes `{ noZoom: true, noRotate: true }`). */
+  flags?: Partial<AnnotationFlags$1>;
+  /** Keep a completed ink stroke in the draft until `finishInkDraft`. */
+  deferInkCommit?: boolean;
+  /** Optional pure straight-line recognition applied to each completed stroke. */
+  straightenInk?: InkStraightenOptions;
+  in: PointerInput;
+} | {
+  t: 'finishInkDraft';
+} | {
+  t: 'finishCreationDraft';
+} | {
+  t: 'createCaret';
+  pon: PageObjectNumber;
+  rect: Rect;
+  flags?: Partial<AnnotationFlags$1>;
+} | {
+  t: 'createReplaceText';
+  pon: PageObjectNumber;
+  rects: Rect[];
+  endRect: Rect;
+  preset?: string;
+} | {
+  t: 'createMarkup';
+  subtype: Subtype;
+  pon: PageObjectNumber;
+  rects: Rect[];
+  preset?: string;
+  /** The tool's `/F` seed — merged over {@link DRAWN_FLAGS} at commit. */
+  flags?: Partial<AnnotationFlags$1>;
+} | {
+  t: 'setMarkupPreview';
+  subtype: Subtype;
+  rectsByPage: Record<number, Rect[]>;
+  preset?: string;
+} | {
+  t: 'clearMarkupPreview';
+} | {
+  t: 'deselect';
+  ids?: Id[];
+} |
+/** Pointer entered/left an annotation (topmost hit id, or null). Pure state. */
+{
+  t: 'hover';
+  id: Id | null;
+} | {
+  t: 'select';
+  ids: Id[];
+  add?: boolean;
+} | {
+  t: 'setProps';
+  patch: AnnotationPropsPatch;
+} | {
+  t: 'setFlags';
+  patch: Partial<AnnotationFlags$1>;
+  ids?: Id[];
+} | {
+  t: 'setDefaults';
+  subtype: Subtype;
+  patch: AnnotationPropsPatch;
+} | {
+  t: 'setSnap';
+  patch: Partial<SnapSettings>;
+} | {
+  t: 'rotate90';
+} | {
+  t: 'resetRotation';
+} | {
+  t: 'delete';
+} | {
+  t: 'cancel';
+} | {
+  t: 'loaded';
+  annots: Annot[];
+} | {
+  t: 'created';
+  tempId: Id;
+  id: Id;
+  ref: AnnotationRef;
+} | {
+  t: 'createFailed';
+  tempId: Id;
+} | {
+  t: 'upsert';
+  annots: Annot[];
+  bumpAp?: boolean;
+} | {
+  t: 'bumpAp';
+  ids: Id[];
+} | {
+  t: 'remove';
+  ids: Id[];
+} | {
+  t: 'beginTextEdit';
+  id: Id;
+} | {
+  t: 'setText';
+  id: Id;
+  text: string;
+} | {
+  t: 'endTextEdit';
+};
+type Effect = {
+  fx: 'create';
+  id: Id;
+} | {
+  fx: 'createGroup';
+  primary: Id;
+  members: Id[];
+} |
+/** `apChanged` is set (to `true`) ONLY when this patch INVALIDATED a baked
+ *  raster — the annotation stayed `baked` (an opaque-body kind) and the edit
+ *  resized its `/AP` frame, so the engine's re-bake produces new content (in
+ *  practice: a stamp resize). The shell's resolve handler then turns it into
+ *  an `upsert` with `bumpAp`. Absent for everything else — moves/rotations
+ *  (the blit repositions the same pixels) and any kind that flipped to
+ *  `vector` (it renders live; the raster stops mattering) — so those keep the
+ *  bare `{ fx, id }` shape and trigger no appearance re-fetch. */
+{
+  fx: 'patch';
+  id: Id;
+  scope: PatchScope;
+  apChanged?: true;
+} |
+/** A `/F`-only engine write for one committed annotation: the shell emits a
+ *  flags-only patch (the model already holds the merged flags) and re-syncs
+ *  PRESERVING the render source — flags never re-bake an appearance. */
+{
+  fx: 'flags';
+  id: Id;
+} |
+/** The parent's `link` prop changed on a NON-link kind: reconcile its
+ *  attached link children (create / retarget / delete) against the desired
+ *  state derived from `link` + the parent's geometry. Declarative — the
+ *  shell's reconciler is the only code that spells out child operations.
+ *  (Geometry commits don't emit this; the shell re-runs the reconciler on
+ *  any `patch` of an annotation that has `linkRefs`.) */
+{
+  fx: 'syncLink';
+  id: Id;
+} | {
+  fx: 'delete';
+  ref: AnnotationRef;
+};
+/** Per-annotation render data — its content geometry + style + live state. */
+interface RenderItem {
+  id: Id;
+  ref: AnnotationRef | null;
+  subtype: Subtype;
+  geom: Geom;
+  /**
+   * The VISUAL box (geometry + stroke + line endings) in content space — the SAME
+   * `geomVisualBounds` that feeds the engine `/Rect`. The renderer paints into THIS
+   * box and does no bounds math of its own, so the on-screen box and the baked
+   * appearance can never drift (the v2 "patch computes the rect" rule).
+   */
+  box: Rect;
+  /**
+   * Content-space box the engine appearance raster occupies (the AP `/Rect`),
+   * with the live move gesture applied — so a baked annotation's bitmap follows
+   * a drag. Only meaningful when `source === 'baked'`; absent otherwise.
+   */
+  apBox?: Rect;
+  /**
+   * Rotation (deg, CW) to apply to the baked raster as a view transform —
+   * exactly the rotation the engine STRIPPED from it (see `Annot.apRot`).
+   * Live for `opaqueBody` kinds (a stamp spins with the rotate gesture);
+   * absent when the raster already contains its rotation (vertex kinds).
+   */
+  apRot?: number;
+  style: Style;
+  /** Text styling (/DA projection) — present for text-bearing kinds (free
+   *  text, text/choice widgets). Lets a behavior renderer's focused editor
+   *  match the baked appearance's font. */
+  text?: TextStyle;
+  source: 'baked' | 'vector' | 'ghost';
+  selected: boolean;
+  /** The pointer is over this annotation — scene-level hover affordances
+   *  (e.g. a redaction mark previews its applied look). */
+  hovered?: boolean;
+  /** Redaction label projection (redact kind only) — see {@link Annot.label}. */
+  label?: {
+    text: string;
+    repeat: boolean;
+  };
+  /**
+   * Applied rotation (deg, CW), or 0/undefined. For BOX kinds (`rect`/`text`)
+   * `box` is the UNROTATED visual box and the renderer applies this rotation
+   * about its centre (CSS/SVG transform). For VERTEX kinds the geometry is
+   * already rotated, so this is advisory only — the renderer must NOT re-apply it.
+   */
+  rot?: number;
+  /**
+   * Mix-blend-mode the annotation composites with against the page (highlights
+   * multiply). The vector painter reads blend per scene node; the baked /AP image
+   * has no scene, so it reads this. Undefined = normal compositing.
+   */
+  blend?: Exclude<BlendMode$1, 'normal'>;
+}
+/** The dumb draw vocabulary the framework renderer maps to SVG (content space).
+ *  A CLOSED node (rect, ellipse, closed poly) takes the annotation's FILL colour;
+ *  an open node (line, open poly — open arrows, butt, slash) is stroke-only. The
+ *  stroke colour applies to every node. Closed-ness is the only fill signal. */
+type RenderNode = {
+  kind: 'rect';
+  rect: Rect;
+} | {
+  kind: 'ellipse';
+  rect: Rect;
+} | {
+  kind: 'line';
+  a: Vec;
+  b: Vec;
+} | {
+  kind: 'poly';
+  points: Vec[];
+  closed: boolean;
+} | {
+  kind: 'path';
+  d: string;
+};
+/**
+ * How to paint one node. The pure core fills this in (per kind/subtype), and a
+ * framework renderer applies it verbatim — so ALL appearance logic (markup fill vs
+ * stroke, blend, dash, derived widths) lives once, in the portable core, not in
+ * every framework. Omitted `fill`/`stroke` mean none.
+ */
+interface Paint {
+  fill?: string;
+  stroke?: string;
+  width?: number;
+  opacity?: number;
+  dash?: number[];
+  blend?: Exclude<BlendMode$1, 'normal'>;
+  cap?: 'round';
+  join?: 'round';
+}
+/**
+ * A fully-painted draw node: geometry + paint. `scene(item)` returns these and a
+ * per-framework painter maps each to ONE element, applying `paint` — the entire
+ * surface a new framework renderer must implement. Supersedes the geometry-only
+ * `RenderNode` for rendering; `geomScene` stays the internal geometry helper.
+ */
+type SceneNode = {
+  kind: 'rect';
+  rect: Rect;
+  paint: Paint;
+} | {
+  kind: 'ellipse';
+  rect: Rect;
+  paint: Paint;
+} | {
+  kind: 'line';
+  a: Vec;
+  b: Vec;
+  paint: Paint;
+} | {
+  kind: 'poly';
+  points: Vec[];
+  closed: boolean;
+  paint: Paint;
+} | {
+  kind: 'path';
+  d: string;
+  paint: Paint;
+} |
+/** Painted (non-interactive) text — `at` is the BASELINE start point in
+ *  content units. Editable text (free text) stays a framework element;
+ *  this is for pure pixels, e.g. a redaction label preview. */
+{
+  kind: 'text';
+  at: Vec;
+  text: string;
+  fontSize: number;
+  fontFamily?: string;
+  paint: Paint;
+};
+/** Pure geometry settings for recognising and axis-snapping a freehand stroke. */
+interface InkStraightenOptions {
+  /** Maximum `max perpendicular deviation / endpoint distance`. */
+  deviationThreshold: number;
+  /** Degrees from horizontal/vertical within which the line snaps to that axis. */
+  axisSnapDegrees: number;
+}
+type ChromeNode = {
+  kind: 'outline';
+  rect: Rect;
+} | {
+  kind: 'obb';
+  corners: [Vec, Vec, Vec, Vec];
+  angle: number;
+} | {
+  kind: 'handle';
+  at: Vec;
+  cursor: Cursor;
+  rot?: number;
+} | {
+  kind: 'rotate-knob';
+  at: Vec;
+  from: Vec;
+} | {
+  kind: 'guide';
+  axis: 'x' | 'y';
+  at: number;
+  lo: number;
+  hi: number;
+} | {
+  kind: 'angle-chip';
+  at: Vec;
+  angle: number;
+} | {
+  kind: 'rotate-guides';
+  center: Vec;
+  angle: number;
+  lines: Array<{
+    a: Vec;
+    b: Vec;
+    role: 'axis' | 'indicator';
+  }>;
+} | {
+  kind: 'marquee';
+  rect: Rect;
+};
+//#endregion
+//#region src/anchor.d.ts
+/** Which display factors this annotation is exempt from: `zoom` =
+ *  screen-constant size, `upright` = screen-constant orientation. */
+interface AnchorMode {
+  zoom: boolean;
+  upright: boolean;
+}
+/**
+ * The anchor behaviors of one annotation: its `/F` flags OR'd with the kind's
+ * statics — the spec's "Text (note) annotations behave as if NoZoom and
+ * NoRotate are ALWAYS set", expressed as kind caps. Null when not anchored.
+ */
+declare function anchorModeOf(a: FlagBearer): AnchorMode | null;
+/** The fixed page point: the geometry's bounds top-left in content space
+ *  (y-down) — which IS the spec's "upper-left corner of the annotation
+ *  rectangle", since `/Rect` is emitted from these bounds. */
+declare const anchorOf: (g: Geom) => Vec;
+/**
+ * THE effective content-space geometry of a screen-anchored body at `view`:
+ * the stored geometry scaled by `1/max(zoom, 1)` about the anchor (`zoom`
+ * exemption, Adobe-clamped) and counter-rotated by `-rotation` about it
+ * (`upright`), so that after the page's own display transform the body reads
+ * at its 100%-zoom size and its authored tilt, hanging from the fixed anchor.
+ * Returns `g` unchanged when there is nothing to do — callers apply it
+ * unconditionally.
+ */
+declare function anchoredGeom(g: Geom, mode: AnchorMode | null, view: ViewEnv | undefined): Geom;
+/**
+ * The exact inverse of {@link anchoredGeom} for a VIEW-space geometry a
+ * gesture produced: the stored geometry whose OWN projection is `target`.
+ *
+ * Solving `anchoredGeom(stored) = target` where the projection anchors at
+ * `stored`'s (unknown) bounds top-left `a` gives a closed form: map `target`
+ * through the pure linear part (scale `s` + rotate `r` about the origin),
+ * then translate so the result's bounds top-left `b` lands where the
+ * projection needs it — at `a = R(-r)·b / s`, the unique fixed point. This is
+ * what makes a released gesture commit EXACTLY what its preview showed.
+ */
+declare function unanchoredGeom(target: Geom, mode: AnchorMode | null, view: ViewEnv | undefined): Geom;
+/** Stroke width in the projected (view) space: a `noZoom` body's line weight
+ *  scales with its geometry so it stays screen-constant — through the SAME
+ *  factors (incl. the ≤100% clamp) the geometry projects with. */
+declare const anchoredStrokeWidth: (width: number, mode: AnchorMode | null, view: ViewEnv | undefined) => number;
+/**
+ * The similarity image of an axis-aligned box (a baked raster's AP `/Rect`)
+ * under the anchor projection, as the blit vocabulary expects it: an
+ * UNROTATED box (the projected centre + scaled size) plus the rotation to
+ * re-apply about its centre. `anchor` is the OWNING GEOMETRY's anchor — the
+ * raster rides its annotation's projection, it doesn't anchor itself. Null
+ * when the projection is the identity.
+ */
+declare function anchoredBox(box: {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}, anchor: Vec, mode: AnchorMode | null, view: ViewEnv | undefined): {
+  box: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  };
+  rot: number;
+} | null;
+//#endregion
+//#region src/update.d.ts
+/** The click ↔ drag threshold (content units): a press-release whose width AND
+ *  height both stay under it is a CLICK. Exported so every gesture owner (the
+ *  draw handler, the form plugin's place handler) shares ONE definition. */
+declare const MIN_DRAG = 3;
+declare const initialStyle: Style;
+declare const initialModel: Model;
+/**
+ * Resolve a tool's effective defaults as a FULL flat props bag: the base `style`
+ * + the font/endings base, with the per-tool override layered on top. This is
+ * what a defaults-editing UI reads, and what creation projects `style`/`text`
+ * from (`styleFromProps` / `textStyleFromProps`).
+ */
+declare function defaultsFor(m: Model, subtype: Subtype): AnnotationProps;
+/**
+ * The live rotation of a rotate draft, snapping applied — the ONE angle rule
+ * shared by the preview (`effGeom`), the commit (`editUp`) and the angle chip,
+ * so they can never disagree. The selection's ABSOLUTE angle (a single member's
+ * `rot` + the raw pointer delta; a group's raw delta from 0) locks onto the
+ * configured angles within the threshold; `free` (shift held) bypasses.
+ * `delta` is what `geomRotateAbout` applies; `angle` is what the chip shows.
+ */
+declare function rotateDraftDelta(m: Model, d: Extract<Draft, {
+  g: 'rotate';
+}>): {
+  delta: number;
+  angle: number;
+  snapped: boolean;
+};
+declare function update(m: Model, msg: Msg): [Model, Effect[]];
+//#endregion
+//#region src/placement.d.ts
+/** A resolved click placement: what the click will occupy, page-clamped. */
+type ClickPlacement = {
+  kind: 'box';
+  rect: Rect;
+  /** Upright counter-rotation captured for the commit (deg CW; 0 = none). */
+  rot: number;
+} | {
+  kind: 'segment';
+  a: Vec;
+  b: Vec;
+};
+/** Slide a rect (as a unit) to sit inside `box`; pins at the origin edge when
+ *  it doesn't fit. Placements are page-bound; the pointer isn't. */
+declare const clampRectToBox: (r: Rect, box: Rect | undefined) => Rect;
+/**
+ * Resolve a click-create POLICY at a content point. `anchor` defaults to
+ * `center`; under `upright` a box counter-rotates against the page's display
+ * rotation exactly as the drag commit would (centre-anchored boxes transpose
+ * about their centre, top-left boxes anchor in the DISPLAY frame).
+ */
+declare function resolveClickPlacement(point: Vec, policy: ClickCreate, opts?: {
+  pageBox?: Rect;
+  upright?: boolean;
+  displayRotation?: PageRotation;
+}): ClickPlacement;
+/**
+ * ANNOTATION-ONLY: convert a placement into the `Geom` the commit stores and
+ * the ghost paints, for a routing kind. This is where annotation VISUAL
+ * semantics live — ellipse for circles, the cloudy outer-box via
+ * `shapeRectFor`. Forms never call this; a field box is the placement rect
+ * itself. Null for kinds a click cannot author.
+ */
+declare function clickCreateGeom(subtype: Subtype, placement: ClickPlacement, def: AnnotationProps): Geom | null;
+//#endregion
+//#region src/snap.d.ts
+interface SnapResult {
+  delta: Vec;
+  guides: Guide[];
+}
+/**
+ * Snap a move delta: shift the selection's union bounds by `raw`, compare its
+ * 3 keys per axis (min / center / max) against every target's, and take the
+ * closest in-threshold pair per axis as an adjustment. Targets are the page box
+ * (edges + center) and every non-moving annotation on the page.
+ */
+declare function computeMoveSnap(m: Model, ids: Id[], pon: number, raw: Vec, threshold: number, pageBox: Rect | undefined): SnapResult;
+//#endregion
+//#region src/view.d.ts
+declare function pageItems(m: Model, pon: number, view?: ViewEnv): RenderItem[];
+/** One free-text box, geometry only (the live move/resize gesture applied), with
+ *  its edit flag. The framework renders an editable element here; the plugin
+ *  layers the DTO-derived text style on top. */
+interface TextBox {
+  id: Id;
+  box: Rect;
+  editing: boolean;
+  /** Applied rotation (deg, CW). `box` is the UNROTATED text box; the framework
+   *  rotates the editable element about its centre by this. 0/undefined = none. */
+  rot?: number;
+}
+/** The free-text boxes on a page — the text counterpart of `pageItems`. */
+declare function textBoxes(m: Model, pon: number, view?: ViewEnv): TextBox[];
+/** The currently selected annotations as render items (live gesture applied) —
+ *  cross-page, for selection-aware toolbars (style + line-ending editing). */
+declare function selectedItems(m: Model, view?: ViewEnv): RenderItem[];
+/**
+ * The rotate knob for the current selection on `pon` — the SAME knob `chrome`
+ * draws — or null when the selection has none (non-rotatable single, or a group
+ * whose caps aren't rotatable). A single shape's knob hangs off its OBB top edge;
+ * a group's off the union box. With `pageBox` the knob is placed PAGE-BOUND
+ * (`placeRotateKnob`: flip below / clamp inside) — off-page it would be visible
+ * but unreachable, since pointer dispatch resolves pages by containment. Shared
+ * by `chrome` (to draw) and `selectionAnchor` (to push the menu clear of it), so
+ * the two can never disagree on where it is.
+ *
+ * The placement DECISION is made at rest; a gesture never re-decides — it RIDES.
+ * During a live rotate the knob starts exactly where it was grabbed (the rest
+ * placement on the COMMITTED geometry) and turns rigidly about the pivot by the
+ * same snapped delta the shape uses; the policy re-evaluates only on release.
+ * Re-deciding per frame would jump at grab and side-switch mid-spin.
+ */
+declare function selectionKnob(m: Model, pon: number, pageBox?: Rect, knobOffset?: number, view?: ViewEnv): {
+  at: Vec;
+  from: Vec;
+} | null;
+declare function chrome(m: Model, pon: number, pageBox?: Rect, knobOffset?: number, view?: ViewEnv): ChromeNode[];
+/** The content-space union of the selectable selected items on `pon`, or null if
+ *  the page holds none. This is the SAME box the chrome outline draws, so a
+ *  floating menu sits exactly on the selection. */
+declare function selectionBoundsOnPage(m: Model, pon: number, view?: ViewEnv): Rect | null;
+/** The anchor for a selection-aware floating menu: the PRIMARY page (the first
+ *  selectable selected id) + the union box of the selection on that page (content
+ *  space). Null when nothing selectable is selected. A cross-page selection
+ *  anchors to its primary page, so there is exactly one menu. `pageBoxOf` is a
+ *  lookup (the anchor resolves its own page) feeding the page-bound knob
+ *  placement — the menu then dodges the knob where it ACTUALLY sits. */
+declare function selectionAnchor(m: Model, pageBoxOf?: (pon: number) => Rect | undefined, knobOffsetOf?: (pon: number) => number | undefined, viewOf?: (pon: number) => ViewEnv | undefined): {
+  pon: number;
+  bounds: Rect;
+  knob?: Vec;
+} | null;
+/** Anchor for controls that finish/cancel an active multi-click creation draft.
+ *  It is rect-based like selectionAnchor, using the committed vertices only so
+ *  the menu remains stable while the hover preview follows the pointer. */
+declare function creationDraftAnchor(m: Model): CreationDraftAnchor | null;
+//#endregion
+//#region src/hit.d.ts
+type Target = {
+  t: 'handle';
+  id: Id;
+  handle: string;
+  cursor: Cursor;
+} | {
+  t: 'rotate';
+  ids: Id[];
+  pivot: Vec;
+} | {
+  t: 'group-handle';
+  ids: Id[];
+  handle: string;
+  cursor: Cursor;
+  box: Rect;
+} | {
+  t: 'annot';
+  id: Id;
+} | {
+  t: 'empty';
+};
+/** Can this annotation be clicked to select? (`/F` interaction flags override
+ *  all caps — hidden/noView/readOnly are inert; LOCKED stays selectable, it
+ *  just won't transform.) */
+declare const isSelectable: (m: Model, id: Id) => boolean;
+/** Can this annotation be dragged by its body to move? (`locked` freezes it.) */
+declare const canMove: (m: Model, id: Id) => boolean;
+/**
+ * What's under the content point.
+ *  1. a resize/vertex handle of the single selection,
+ *  2. an editable annotation body — a SELECTED one anywhere in its bounds (so you
+ *     can drag to move it), an UNSELECTED one only on its stroke/fill (margin-aware,
+ *     so an unfilled circle is grabbed only on its outline),
+ *  3. else empty.
+ */
+declare function hitTest(m: Model, pon: number, p: Vec, geom: ChromeGeom, strokeMargin: number, pageBox?: Rect, inert?: ReadonlySet<Id>, view?: ViewEnv): Target;
+/** The cursor to show on hover: a resize cursor over a handle, move/pointer over a body. */
+declare function cursorAt(m: Model, pon: number, p: Vec, geom: ChromeGeom, strokeMargin: number, pageBox?: Rect, inert?: ReadonlySet<Id>, view?: ViewEnv): Cursor | null;
+//#endregion
+//#region src/group.d.ts
+/**
+ * The transform capabilities of a multi-target (group) selection: a group can
+ * move/resize/rotate only if EVERY member's kind allows that group op AND no
+ * member is locked. This is the SINGLE resolver every adapter consumes (v2
+ * duplicated the `.every(...)` across three framework components). The iso-vs-
+ * aniso resize choice is computed separately, per-gesture, since it depends on
+ * the live `rot` of the members, not the static caps.
+ */
+interface GroupCaps {
+  movable: boolean;
+  resizable: boolean;
+  rotatable: boolean;
+}
+declare function groupCaps(m: Model, ids: Id[]): GroupCaps;
+/**
+ * The key of the group `id` belongs to, or `null` when it is ungrouped. A
+ * subordinate's key is its `group` field; a primary's key is its own id (it is
+ * the target of at least one member's `group`). An annotation that is neither a
+ * subordinate nor the target of any subordinate is ungrouped.
+ */
+declare function groupKeyOf(m: Model, id: Id): Id | null;
+/**
+ * Every member of the group containing `id` (primary first), or just `[id]`
+ * when it is ungrouped. The primary is the annotation whose id is the key; the
+ * rest are everything whose `group` equals the key, in `order`.
+ */
+declare function groupMembers(m: Model, id: Id): Id[];
+/** Union of every id's full group — the selection seen as whole groups. */
+declare function expandGroups(m: Model, ids: Id[]): Id[];
+//#endregion
+//#region src/kinds.d.ts
+/**
+ * One editable property of a kind, as a UI contract: which {@link AnnotationProps}
+ * key, rendered how (the union arm fixes the control + its constraints), labelled
+ * what by default. A property sidebar is a `switch (spec.key)` over these — the
+ * per-kind lists below are the v2 snippet's hand-rolled `TOOL_PROPERTIES` schema,
+ * promoted into the library so every consumer gets it for free.
+ *
+ * `label` is a default (English) display name — apps with i18n map `key`s to
+ * their own strings and ignore it. Array ORDER is display order.
+ */
+type PropSpec = {
+  key: 'color';
+  label: string;
+} | {
+  key: 'interiorColor';
+  label: string;
+} | {
+  key: 'fontColor';
+  label: string;
+} | {
+  key: 'opacity';
+  label: string;
+  min: number;
+  max: number;
+  step: number;
+} | {
+  key: 'strokeWidth';
+  label: string;
+  min: number;
+  max: number;
+  step: number;
+} | {
+  key: 'fontSize';
+  label: string;
+  min: number;
+  max: number;
+  step: number;
+} |
+/** Border style picker; `cloudy` says whether this kind honours a cloudy border. */
+{
+  key: 'border';
+  label: string;
+  cloudy: boolean;
+} | {
+  key: 'lineEndings';
+  label: string;
+} | {
+  key: 'fontFamily';
+  label: string;
+} | {
+  key: 'textAlign';
+  label: string;
+} | {
+  key: 'blendMode';
+  label: string;
+} |
+/** `/Name` icon picker for icon kinds; `options` are the legal names. */
+{
+  key: 'icon';
+  label: string;
+  options: readonly string[];
+} |
+/** Link-target editor (URL / page destination). Declared by the link kind
+ *  (its own target) and by every kind that may carry an ATTACHED link;
+ *  kinds that omit it (widgets, caret, redact…) simply cannot be links —
+ *  `applyProps` drops the key and menus never show the control. */
+{
+  key: 'link';
+  label: string;
+};
+/** Orthogonal capability flags. Static data — the annotation's `/F` flags are
+ *  the runtime overrides (a locked annotation is never transformable, a hidden
+ *  one never renders, regardless of these — see flags.ts). */
+interface KindCaps {
+  /** Can be clicked to select. */
+  selectable: boolean;
+  /** Can be dragged (by its body) to translate. */
+  movable: boolean;
+  /** Exposes the 8 box resize handles (shapes). */
+  resizable: boolean;
+  /** Exposes per-vertex handles (line endpoints, polygon/polyline vertices). */
+  vertexEditable: boolean;
+  /** Can be rotated (shapes, free text, lines/polys/ink). */
+  rotatable: boolean;
+  /** Can be MOVED as part of a multi-target (group) transform. */
+  groupMovable: boolean;
+  /** Can be uniformly SCALED as part of a multi-target (group) transform — ON
+   *  even for vertex kinds that have no single-shape box resize (their handles
+   *  ARE the vertices; in a group they scale fine). */
+  groupResizable: boolean;
+  /** Can be ROTATED as part of a multi-target (group) transform. */
+  groupRotatable: boolean;
+  /** Carries editable text content (free text, the comment popup). */
+  textEditable: boolean;
+  /** Can carry a comment/note + threaded replies (`/Contents` + `/Popup`). */
+  commentable: boolean;
+  /** Has a popup as its primary surface (the comment/Text icon). */
+  hasPopup: boolean;
+  /** Bound to underlying text (markup, caret) — never freely moved/resized. */
+  anchored: boolean;
+  /** Has an interior fill (`/IC`). */
+  hasFill: boolean;
+  /** Has line endings (`/LE` — line, polyline). */
+  hasEndings: boolean;
+  /** Can take a cloudy border effect (`/BE` — shapes). */
+  hasCloudy: boolean;
+  /** The whole body is visible content, so hit-testing grabs anywhere inside
+   *  the box (stamp images) — NOT just the stroke/fill like outline shapes. */
+  opaqueBody: boolean;
+  /** The `/F` ReadOnly flag is IGNORED for this kind (ISO 32000: widgets — a
+   *  ReadOnly form FIELD must still be movable by a form designer; the
+   *  form-filling layer enforces field ReadOnly itself). */
+  ignoresReadOnly: boolean;
+  /** Behaves as if `/F` NoZoom is always set (screen-constant size — the
+   *  spec's rule for Text/note icons). See anchor.ts. */
+  noZoom: boolean;
+  /** Behaves as if `/F` NoRotate is always set (screen-upright — the spec's
+   *  rule for Text/note icons). See anchor.ts. */
+  noRotate: boolean;
+}
+interface AnnotationKind {
+  subtype: Subtype;
+  /** Future: PDF `/IT` intent (free-text vs callout, caret insert vs replace). */
+  intent?: string;
+  variant: Geom['t'];
+  caps: KindCaps;
+  /** The kind's editable properties, in DISPLAY ORDER — the contract a property
+   *  sidebar renders from (see {@link PropSpec}). Empty = nothing to edit. */
+  props: PropSpec[];
+}
+/** The built-in kinds. Shapes resize, lines/polys vertex-edit, markup is anchored
+ *  (selectable + recolor/delete, never move/resize). */
+declare const KINDS: Record<string, AnnotationKind>;
+/** The capabilities of a subtype, or the read-only default for unknown kinds. */
+declare const capsFor: (subtype: string) => KindCaps;
+/** A kind's editable properties in display order — empty for unknown kinds.
+ *  Stable references, so selectors can compare by identity. */
+declare const propsFor: (subtype: string) => PropSpec[];
+//#endregion
+//#region src/props.d.ts
+/** Base text styling for kinds/tools with no explicit defaults. */
+declare const initialTextStyle: TextStyle;
+/** The `Style` slice of a resolved props bag (the create-time projection). */
+declare const styleFromProps: (p: AnnotationProps) => Style;
+/** The `TextStyle` slice of a resolved props bag (the create-time projection). */
+declare const textStyleFromProps: (p: AnnotationProps) => TextStyle;
+/**
+ * Read one property off an annotation — from wherever it lives — or `undefined`
+ * when the annotation's kind doesn't carry it (a `fontSize` on a square, endings
+ * on a polygon). The read side of `applyProps`.
+ */
+declare function readProp<K extends PropKey>(a: Annot, key: K): AnnotationProps[K] | undefined;
+/**
+ * Apply a property patch to one annotation, honouring its kind's declared keys.
+ * Returns the changed annotation, or `null` when nothing applied (locked /
+ * read-only per its `/F` flags, or no declared key in the patch) — so the
+ * caller emits no spurious engine write. Flags themselves are NOT props: they
+ * write through the `setFlags` message, which is deliberately not gated here
+ * (unlocking must work on a locked annotation).
+ */
+declare function applyProps(a: Annot, patch: AnnotationPropsPatch): Annot | null;
+/**
+ * The ordered property specs EVERY given kind declares — the schema for a mixed
+ * selection, in the FIRST kind's display order. One kind → its own list, verbatim.
+ */
+declare function sharedProps(subtypes: readonly string[]): PropSpec[];
+//#endregion
+//#region src/geometry.d.ts
+type RectHandle = 'nw' | 'n' | 'ne' | 'e' | 'se' | 's' | 'sw' | 'w';
+declare const RECT_HANDLES: RectHandle[];
+/** The resize cursor for a handle on a box tilted by `rot` deg: rotate the
+ *  handle's compass direction with the box and pick the nearest 45° sector.
+ *  At `rot = 0` this reproduces {@link RECT_CURSOR} exactly. */
+declare const rotatedHandleCursor: (h: RectHandle, rot: number) => Cursor;
+declare const rectFromPoints: (a: Vec, b: Vec) => Rect;
+declare function unionRect(pts: Vec[]): Rect;
+/** How far (content units) the rotate knob hangs off the top edge of the box. */
+declare const ROTATE_KNOB_OFFSET = 24;
+/** Fallback chrome geometry (content units) when the caller supplies none —
+ *  the pre-settings behavior, so bare-core callers and tests stay stable. */
+declare const DEFAULT_CHROME_GEOM: {
+  readonly handleTol: 6;
+  readonly knobTol: 6;
+  readonly knobOffset: 24;
+};
+/** Normalize degrees into `[0, 360)`. */
+declare const normalizeDeg: (d: number) => number;
+/** A geom's applied rotation (deg), or 0 for the non-rotatable kinds. */
+declare function geomRotation(g: Geom): number;
+/**
+ * The rotation PIVOT for a single shape: a box turns about its own `rect`
+ * centre; a vertex shape about the CENTROID of its points (the mean). Rotating a
+ * point set about its centroid leaves the centroid fixed, so the advisory `rot`
+ * stays cleanly additive across gestures and reset is exact.
+ */
+declare function centroidOf(g: Geom): Vec;
+/** Is this kind rotatable (the geometry carries a meaningful `rot`)? */
+declare function isRotatableGeom(g: Geom): boolean;
+/**
+ * Rotate a geom by `deltaDeg` (clockwise) about `pivot`.
+ *  - BOX (`rect`/plain `text`): orbit the box centre about the pivot (a rigid
+ *    translation of the unrotated `rect`) and add the angle to `rot`. When the
+ *    pivot IS the box centre this is a pure `rot += delta`.
+ *  - VERTEX (`line`/`poly`/`ink`): map every point through the rotation AND bump
+ *    the advisory `rot` (the points stay the authoritative visual).
+ * Non-rotatable kinds (caret/quads, callouts) are returned unchanged.
+ */
+declare function geomRotateAbout(g: Geom, pivot: Vec, deltaDeg: number): Geom;
+/** The AABB of `rect` rotated `deg` about its own centre. */
+declare function rotatedAabb(rect: Rect, deg: number): Rect;
+/**
+ * The counter-rotation (CW content degrees) that makes an annotation read
+ * upright at `displayRotation`: on screen the two compose to 0.
+ */
+declare const uprightRotation: (displayRotation: number) => number;
+/** `rect` with width↔height swapped about its own centre — the unrotated box
+ *  whose quarter-turn AABB is exactly `rect` again. */
+declare function transposedAboutCenter(rect: Rect): Rect;
+/**
+ * The unrotated content rect for a DEFAULT-SIZE upright box "placed at" a
+ * point: positioned so that, after the upright counter-rotation, the box shows
+ * `width`×`height` with its TOP-LEFT at `anchor` in the ROTATED view — the
+ * same on-screen feel as the rotation-0 `{ x: anchor.x, y: anchor.y }` box at
+ * every quarter-turn (a click-created free-text box always opens down-right of
+ * the cursor as the author sees it). Derived by placing the box in the display
+ * frame and pulling its AABB back through the quarter-turn; the page dims
+ * cancel, so no page box is needed.
+ */
+declare function uprightAnchoredRect(anchor: Vec, width: number, height: number, displayRotation: number): Rect;
+/**
+ * The LOGICAL (unrotated) content-space box for a stamp placed at `center`,
+ * sized `desired` (points), fit onto the page and clamped fully within it —
+ * the v2 rubber-stamp rule: keep the image's own size unless it would overflow
+ * the page, then scale down (aspect preserved, never up) so it just fits.
+ *
+ * Under an upright quarter-turn the on-page FOOTPRINT is the box transposed
+ * (w↔h), so BOTH the fit and the edge clamp use that footprint — a landscape
+ * stamp uprighted onto a portrait page fits by its rotated silhouette, not its
+ * logical box. The box centre and its footprint AABB centre coincide (rotation
+ * is about the centre), so clamping one clamps the other.
+ */
+declare function fitStampBox(center: Vec, desired: Size, page: Size, rotCW: number): Rect;
+/** Reset a geom to its as-authored orientation (`rot → 0`). Box: drop `rot`.
+ *  Vertex: spin the points by `-rot` about their centroid so they return to the
+ *  orientation they were drawn at, in place. */
+declare function geomResetRotation(g: Geom): Geom;
+/**
+ * The oriented selection box (OBB) of a rotatable geom: four corners (in order
+ * nw, ne, se, sw of the LOCAL box, transformed) + the angle. For a box this is
+ * the `rect` rotated about its centre; for a vertex shape it is reconstructed
+ * from the advisory `rot` — un-rotate the points to recover the as-authored
+ * shape, take that tight local box, then rotate it back — giving the snug tilted
+ * rectangle. Returns null for non-rotatable kinds.
+ */
+declare function obbFromGeom(g: Geom, strokeWidth: number, border?: Border): {
+  corners: [Vec, Vec, Vec, Vec];
+  angle: number;
+} | null;
+/** The fixed point of a group resize: the OPPOSITE handle's point on the box. */
+declare function groupResizeAnchor(base: Rect, handle: string): Vec;
+/**
+ * The live group resize box for a drag. Anisotropic = the plain axis-aligned
+ * `resizeRect`; isotropic = a uniform scale of `base` about the anchor by the
+ * larger of the two drag ratios (so the preview matches the committed scale and
+ * never shears a rotated member).
+ */
+declare function groupResizeBox(base: Rect, handle: string, to: Vec, isotropic: boolean): Rect;
+/** The (sx, sy) factors a `base`→`cur` group resize applied about its anchor. */
+declare function groupResizeFactors(base: Rect, cur: Rect): {
+  sx: number;
+  sy: number;
+};
+/**
+ * Scale a geom about `anchor` by `(sx, sy)`. For a rotated box (iso scale, so
+ * `sx === sy`) the unrotated `rect` is scaled about the anchor and `rot` is
+ * preserved (a uniform scale commutes with rotation). For unrotated members
+ * (the anisotropic case) every point/extent scales directly.
+ */
+declare function geomScaleAbout(g: Geom, anchor: Vec, sx: number, sy: number): Geom;
+/** Where the rotate knob sits, given the OBB corners (nw, ne, se, sw) and the
+ *  outward offset (content units). `from` is the top-edge midpoint the connector
+ *  stalk anchors to; `at` is the grab dot, offset along the outward normal. */
+declare function rotateKnob(corners: [Vec, Vec, Vec, Vec], offset: number): {
+  at: Vec;
+  from: Vec;
+};
+/**
+ * `rotateKnob` with a TOTAL page-bound placement policy: annotations, gestures
+ * and chrome are all page-bound, so the grab dot must land inside `pageBox` —
+ * off-page it is unreachable (the pointer dispatch resolves pages by
+ * containment). Policy: top edge (the default) → FLIP to the bottom edge when
+ * the stalk exits the page → CLAMP the top candidate inside (degenerate: the
+ * selection spans ~the whole page; the knob may then overlap the shape, and
+ * hit-testing checks it first so it stays grabbable). Both render (`chrome`)
+ * and hit-test (`hitTest`) place the knob through THIS function, so what you
+ * see is what you can grab — by construction. No `pageBox` → the raw knob.
+ */
+declare function placeRotateKnob(corners: [Vec, Vec, Vec, Vec], offset: number, pageBox?: Rect): {
+  at: Vec;
+  from: Vec;
+};
+/** The box-edge midpoint the leader connects to: the side `ref` (the knee, else
+ *  the tip) points toward, by horizontal/vertical dominance vs the box centre.
+ *  With `rot` (a callout box tilted by the upright policy) the decision runs in
+ *  the box's LOCAL frame and the midpoint lands back on the ROTATED edge — the
+ *  edge the user actually sees. Mirror of v2's `computeCalloutConnectionPoint`. */
+declare function calloutConnection(box: Rect, ref: Vec, rot?: number): Vec;
+/** The leader polyline `[tip, knee?, conn]`, with `conn` derived from the box
+ *  (its ROTATED footprint when the box carries `rot`). */
+declare function calloutLinePoints(g: Extract<Geom, {
+  t: 'text';
+}>): Vec[];
+/**
+ * The stored `rect` for a freshly-drawn shape, given the box the user dragged. A
+ * cloudy border stores the OUTER box (dragged + cloud extent), so the dragged box
+ * is its inner edge and the scallops bulge out to the stored box — just like a
+ * solid shape, whose /Rect is the dragged box. So `g.rect` is ALWAYS the outer box;
+ * the cloud-vs-solid difference lives only here, at creation.
+ */
+declare function shapeRectFor(dragged: Rect, ellipse: boolean, style: Style): Rect;
+declare function caretRectFromTextEnd(lineRect: Rect): Rect;
+/** Miter limit shared by the bounds math AND the SVG renderer (`stroke-miterlimit`),
+ *  so the computed box and the drawn stroke always agree on where a sharp join
+ *  bevels instead of spiking. 10 = the PDF default (also what the baked /AP uses). */
+declare const MITER_LIMIT = 10;
+/**
+ * A geom's VISUAL bounds: the rect that encloses the drawn appearance, so the
+ * baked /AP is never clipped and the selection outline wraps exactly what's drawn.
+ *
+ * A shape's `rect` IS its visual box (the PDF /Rect): solid/dashed strokes draw
+ * inside it, and a cloudy border's scallops also inset back into it (the dragged
+ * inner edge sits `/RD` in from it — see `shapeRectFor`). So growing the stroke or
+ * the cloud thickens inward, never spilling past the handles. Lines / polylines /
+ * ink have no box, so they expand by the stroke (+ endings) — the SAME math feeds
+ * `geomScene`, so the visual box and what's drawn always agree.
+ *
+ * `border` matters for ONE case: a CLOSED poly with a cloudy border, whose curls
+ * are centred on the vertex path and reach OUTWARD (there is no outer box to
+ * inset into) — the bounds grow by the cloud extent, and the engine `/Rect`
+ * (via `geomPdfBounds`) grows with them so the baked scallops are never clipped.
+ */
+declare function geomVisualBounds(g: Geom, strokeWidth: number, border?: Border): Rect;
+/**
+ * The rect the SELECTION wraps — and the region a SELECTED annotation can be grabbed
+ * from. Centre-line geometries (line / polyline / polygon / ink) straddle their path,
+ * so this is their VISUAL bounds (the join-aware stroke outline + endings) — a
+ * polygon's outline wraps its stroke exactly like a polyline. Box kinds (square /
+ * circle / free-text) sit tight on their `rect` (their stroke draws INSIDE the box,
+ * so the 8 resize handles land on the corners). The chrome outline AND the selected
+ * hit-test both call this, so what you see highlighted is exactly what you can grab —
+ * they can never drift.
+ */
+declare function selectionBounds(g: Geom, strokeWidth: number, border?: Border): Rect;
+/**
+ * The four corners of the ORIENTED selection box — the SAME quad `chrome` draws.
+ * For a rotatable kind this is the OBB (the tilted box, from `obbFromGeom`); at
+ * `rot == 0` those are just the axis-aligned corners of `selectionBounds`, and
+ * for non-rotatable kinds (markup quads, callouts) it falls back to the rect
+ * corners. The grab region, the floating-menu anchor and the multi/group union
+ * all consume this, so what you can grab / where the menu sits never drifts from
+ * the outline you see.
+ */
+declare function selectionQuad(g: Geom, strokeWidth: number, border?: Border): [Vec, Vec, Vec, Vec];
+/** Is the point inside the (convex) selection quad? Even-odd ring test. */
+declare const pointInQuad: (p: Vec, quad: [Vec, Vec, Vec, Vec]) => boolean;
+/**
+ * Does the (convex) selection quad intersect an axis-aligned rect? Separating
+ * axis test on the only four candidate axes — the rect's x/y plus the quad's
+ * two edge normals; a gap on any axis proves disjoint, otherwise they overlap
+ * (touching counts). This is the marquee's predicate: it must catch a tilted
+ * shape by the ORIENTED box that is actually drawn — the AABB of that quad has
+ * empty corners covering most of the unrotated footprint, so testing it selects
+ * shapes the marquee never touched. At `rot 0` the quad is axis-aligned and
+ * this degenerates to exactly `rectsIntersect`.
+ */
+declare function quadIntersectsRect(quad: [Vec, Vec, Vec, Vec], r: Rect): boolean;
+/**
+ * The centre of the ORIENTED selection box — the middle of the rect you see.
+ * For box kinds this is the rect centre (so squares/circles are unchanged); for
+ * vertex kinds it is the OBB centre, so rotation spins the shape in place rather
+ * than swinging it about the off-centre vertex mean (`centroidOf`).
+ */
+declare function selectionCenter(g: Geom, strokeWidth: number): Vec;
+declare function geomBounds(g: Geom): Rect;
+/**
+ * Is the content point ON the annotation: within `margin` of the stroke, or
+ * inside the fill (when `filled`). The stroke band widens with the stroke width.
+ *
+ * A shape's stroke is drawn INSIDE its box, centred on `insetRect(rect, sw/2)`
+ * (see `geomScene`), so the clickable band follows that inset centre-line — not
+ * the box edge. The fill still reaches the box. (Cloudy scallops aren't modelled
+ * here; with their typically thin stroke the inset is sub-pixel, so this matches.)
+ */
+declare function geomHit(g: Geom, p: Vec, margin: number, filled: boolean, strokeWidth: number): boolean;
+declare function geomHandles(g: Geom): Handle[];
+declare function geomTranslate(g: Geom, d: Vec): Geom;
+declare function geomDragHandle(g: Geom, handle: string, to: Vec): Geom;
+declare function geomScene(g: Geom, strokeWidth?: number, border?: Border): RenderNode[];
+declare const pdfToContentPoint: (p: PdfPoint, crop: PdfRect) => Vec;
+declare const contentToPdfPoint: (p: Vec, crop: PdfRect) => PdfPoint;
+declare const pdfToContentRect: (pdf: PdfRect, crop: PdfRect) => Rect;
+declare const contentToPdfRect: (r: Rect, crop: PdfRect) => PdfRect;
+/** A geom's VISUAL bounding box (geometry + stroke + line endings) as a PdfRect —
+ *  the engine requires an explicit `rect` that encloses the baked /AP. */
+declare const geomPdfBounds: (g: Geom, strokeWidth: number, crop: PdfRect, border?: Border) => PdfRect;
+//#endregion
+//#region src/cloudy.d.ts
+/**
+ * The per-side inset (content units) from a shape's outer box to the cloud's
+ * inner boundary — the scallop radius plus half the stroke. This IS the `/RD`
+ * the engine stores, and it's sized so the scallop peaks reach back out to the
+ * box edge: the box remains the annotation's outer boundary.
+ */
+declare function cloudyBorderExtent(intensity: number, strokeWidth: number, ellipse: boolean): number;
+/**
+ * SVG path data for a cloudy square (rect) or circle (ellipse), in ABSOLUTE
+ * content coordinates. The scallops are generated on the box inset by
+ * `cloudyBorderExtent` and bulge back out to `box`'s edge.
+ */
+declare function cloudyPath(box: Rect, ellipse: boolean, intensity: number, strokeWidth: number): string;
+//#endregion
+//#region src/scene.d.ts
+/** The full painted scene for one annotation. */
+declare function scene(item: RenderItem): SceneNode[];
+//#endregion
+//#region src/ink.d.ts
+/**
+ * Recognise a sufficiently straight freehand stroke and axis-snap it when it is
+ * close to horizontal or vertical. Diagonal strokes remain untouched: this is
+ * a highlighter aid, not a general line simplifier.
+ */
+declare function straightenInkStroke(points: readonly Vec[], options: InkStraightenOptions): Vec[];
+//#endregion
+export { type AnchorMode, type Annot, type AnnotationFlags, type AnnotationKind, type AnnotationProps, type AnnotationPropsPatch, type BlendMode, type Border, type Callout, type ChromeGeom, type ChromeNode, type ClickCreate, type ClickPlacement, type CreationDraftAnchor, type Cursor, DEFAULT_CHROME_GEOM, DRAWN_FLAGS, type Draft, type Effect, FLAG_KEYS, type FlagBearer, type Geom, type GroupCaps, type Guide, type Handle, type Id, type InkStraightenOptions, KINDS, type KindCaps, type LineEnding, type LineEndings, MIN_DRAG, MITER_LIMIT, type Model, type Msg, NO_ANNOTATION_FLAGS, type Paint, type PatchScope, type PointerInput, type PropKey, type PropSpec, type Quad, RECT_HANDLES, ROTATE_KNOB_OFFSET, type Rect, type RectHandle, type RenderItem, type RenderNode, type SceneNode, type SnapResult, type SnapSettings, type Style, type Subtype, type Target, type TextAlign, type TextBox, type TextStyle, type Vec, type ViewEnv, anchorModeOf, anchorOf, anchoredBox, anchoredGeom, anchoredStrokeWidth, annotContentsEditable, annotInteractive, annotTransformable, applyProps, calloutConnection, calloutLinePoints, canMove, capsFor, caretRectFromTextEnd, centroidOf, chrome, clampRectToBox, clickCreateGeom, cloudyBorderExtent, cloudyPath, computeMoveSnap, contentToPdfPoint, contentToPdfRect, creationDraftAnchor, cursorAt, defaultsFor, expandGroups, fitStampBox, flagsEqual, geomBounds, geomDragHandle, geomHandles, geomHit, geomPdfBounds, geomResetRotation, geomRotateAbout, geomRotation, geomScaleAbout, geomScene, geomTranslate, geomVisualBounds, groupCaps, groupKeyOf, groupMembers, groupResizeAnchor, groupResizeBox, groupResizeFactors, hitTest, initialModel, initialStyle, initialTextStyle, interactive, isRotatableGeom, isSelectable, mergeFlags, normalizeDeg, obbFromGeom, pageItems, pdfToContentPoint, pdfToContentRect, placeRotateKnob, pointInQuad, propsFor, quadIntersectsRect, readProp, rectFromPoints, resolveClickPlacement, rotateDraftDelta, rotateKnob, rotatedAabb, rotatedHandleCursor, scene, selectedItems, selectionAnchor, selectionBounds, selectionBoundsOnPage, selectionCenter, selectionKnob, selectionQuad, shapeRectFor, sharedProps, straightenInkStroke, styleFromProps, textBoxes, textStyleFromProps, transposedAboutCenter, unanchoredGeom, unionRect, update, uprightAnchoredRect, uprightRotation, viewable };
+//# sourceMappingURL=index.d.cts.map