@embedpdf/plugin-annotation 1.4.1 → 2.0.0-next.0

package/dist/index.js

@@ -1,5 +1,5 @@
-import { clamp, BasePlugin, createBehaviorEmitter, SET_DOCUMENT } from "@embedpdf/core";
-import { PdfAnnotationSubtype, expandRect, rectFromPoints, uuidV4, PdfVerticalAlignment, PdfTextAlignment, PdfStandardFont, PdfAnnotationLineEnding, rotateAndTranslatePoint, PdfAnnotationBorderStyle, PdfAnnotationIcon, ignore, PdfTaskHelper, PdfErrorCode, Task, PdfBlendMode } from "@embedpdf/models";
+import { clamp, BasePlugin, createBehaviorEmitter } from "@embedpdf/core";
+import { PdfAnnotationSubtype, PdfBlendMode, PdfAnnotationBorderStyle, PdfAnnotationLineEnding, PdfVerticalAlignment, PdfTextAlignment, PdfStandardFont, expandRect, rectFromPoints, uuidV4, rotateAndTranslatePoint, PdfAnnotationIcon, ignore, PdfTaskHelper, PdfErrorCode, Task } from "@embedpdf/models";
 const ANNOTATION_PLUGIN_ID = "annotation";
 const manifest = {
   id: ANNOTATION_PLUGIN_ID,
@@ -16,51 +16,75 @@ const manifest = {
     selectAfterCreate: true
   }
 };
+const INIT_ANNOTATION_STATE = "ANNOTATION/INIT_STATE";
+const CLEANUP_ANNOTATION_STATE = "ANNOTATION/CLEANUP_STATE";
+const SET_ACTIVE_DOCUMENT = "ANNOTATION/SET_ACTIVE_DOCUMENT";
 const SET_ANNOTATIONS = "ANNOTATION/SET_ANNOTATIONS";
 const SELECT_ANNOTATION = "ANNOTATION/SELECT_ANNOTATION";
 const DESELECT_ANNOTATION = "ANNOTATION/DESELECT_ANNOTATION";
-const ADD_COLOR_PRESET = "ANNOTATION/ADD_COLOR_PRESET";
+const SET_ACTIVE_TOOL_ID = "ANNOTATION/SET_ACTIVE_TOOL_ID";
 const CREATE_ANNOTATION = "ANNOTATION/CREATE_ANNOTATION";
 const PATCH_ANNOTATION = "ANNOTATION/PATCH_ANNOTATION";
 const DELETE_ANNOTATION = "ANNOTATION/DELETE_ANNOTATION";
 const COMMIT_PENDING_CHANGES = "ANNOTATION/COMMIT";
 const PURGE_ANNOTATION = "ANNOTATION/PURGE_ANNOTATION";
-const SET_ACTIVE_TOOL_ID = "ANNOTATION/SET_ACTIVE_TOOL_ID";
+const ADD_COLOR_PRESET = "ANNOTATION/ADD_COLOR_PRESET";
 const SET_TOOL_DEFAULTS = "ANNOTATION/SET_TOOL_DEFAULTS";
 const ADD_TOOL = "ANNOTATION/ADD_TOOL";
-const setAnnotations = (p) => ({
+function initAnnotationState(documentId, state) {
+  return { type: INIT_ANNOTATION_STATE, payload: { documentId, state } };
+}
+function cleanupAnnotationState(documentId) {
+  return { type: CLEANUP_ANNOTATION_STATE, payload: documentId };
+}
+const setAnnotations = (documentId, annotations) => ({
   type: SET_ANNOTATIONS,
-  payload: p
+  payload: { documentId, annotations }
 });
-const selectAnnotation = (pageIndex, id) => ({
+const selectAnnotation = (documentId, pageIndex, id) => ({
   type: SELECT_ANNOTATION,
-  payload: { pageIndex, id }
+  payload: { documentId, pageIndex, id }
 });
-const deselectAnnotation = () => ({ type: DESELECT_ANNOTATION });
-const addColorPreset = (c) => ({
-  type: ADD_COLOR_PRESET,
-  payload: c
+const deselectAnnotation = (documentId) => ({
+  type: DESELECT_ANNOTATION,
+  payload: { documentId }
+});
+const setActiveToolId = (documentId, toolId) => ({
+  type: SET_ACTIVE_TOOL_ID,
+  payload: { documentId, toolId }
+});
+const createAnnotation = (documentId, pageIndex, annotation) => ({
+  type: CREATE_ANNOTATION,
+  payload: { documentId, pageIndex, annotation }
 });
-const createAnnotation = (pageIndex, annotation) => ({ type: CREATE_ANNOTATION, payload: { pageIndex, annotation } });
-const patchAnnotation = (pageIndex, id, patch) => ({ type: PATCH_ANNOTATION, payload: { pageIndex, id, patch } });
-const deleteAnnotation = (pageIndex, id) => ({
+const patchAnnotation = (documentId, pageIndex, id, patch) => ({
+  type: PATCH_ANNOTATION,
+  payload: { documentId, pageIndex, id, patch }
+});
+const deleteAnnotation = (documentId, pageIndex, id) => ({
   type: DELETE_ANNOTATION,
-  payload: { pageIndex, id }
+  payload: { documentId, pageIndex, id }
+});
+const commitPendingChanges = (documentId) => ({
+  type: COMMIT_PENDING_CHANGES,
+  payload: { documentId }
 });
-const commitPendingChanges = () => ({ type: COMMIT_PENDING_CHANGES });
-const purgeAnnotation = (uid) => ({
+const purgeAnnotation = (documentId, uid) => ({
   type: PURGE_ANNOTATION,
-  payload: { uid }
+  payload: { documentId, uid }
 });
-const setActiveToolId = (id) => ({
-  type: SET_ACTIVE_TOOL_ID,
-  payload: id
+const addColorPreset = (c) => ({
+  type: ADD_COLOR_PRESET,
+  payload: c
 });
 const setToolDefaults = (toolId, patch) => ({
   type: SET_TOOL_DEFAULTS,
   payload: { toolId, patch }
 });
-const addTool = (tool) => ({ type: ADD_TOOL, payload: tool });
+const addTool = (tool) => ({
+  type: ADD_TOOL,
+  payload: tool
+});
 function isInk(a) {
   return a.object.type === PdfAnnotationSubtype.INK;
 }
@@ -113,6 +137,7 @@ const getAnnotations = (s) => {
   return out;
 };
 const getSelectedAnnotation = (s) => s.selectedUid ? s.byUid[s.selectedUid] : null;
+const getAnnotationByUid = (s, uid) => s.byUid[uid] ?? null;
 const getSelectedAnnotationByPageIndex = (s, pageIndex) => {
   if (!s.selectedUid) return null;
   const pageUids = s.pages[pageIndex] ?? [];
@@ -166,394 +191,942 @@ const getSidebarAnnotationsWithReplies = (s) => {
   }
   return out;
 };
-function useState(initialValue) {
-  let value = initialValue;
-  const getValue = () => value;
-  const setValue = (newValue) => {
-    value = newValue;
-  };
-  return [getValue, setValue];
-}
-const inkHandlerFactory = {
-  annotationType: PdfAnnotationSubtype.INK,
-  create(context) {
-    const { onCommit, onPreview, getTool, pageSize } = context;
-    const [getStrokes, setStrokes] = useState([]);
-    const [getIsDrawing, setIsDrawing] = useState(false);
-    const timerRef = { current: null };
-    const clampToPage = (pos) => ({
-      x: clamp(pos.x, 0, pageSize.width),
-      y: clamp(pos.y, 0, pageSize.height)
-    });
-    const getDefaults = () => {
-      const tool = getTool();
-      if (!tool) return null;
-      return {
-        ...tool.defaults,
-        strokeWidth: tool.defaults.strokeWidth ?? 1,
-        color: tool.defaults.color ?? "#000000",
-        opacity: tool.defaults.opacity ?? 1,
-        flags: tool.defaults.flags ?? ["print"]
-      };
-    };
-    const getPreview = () => {
-      const strokes = getStrokes();
-      if (strokes.length === 0 || strokes[0].points.length === 0) return null;
-      const defaults = getDefaults();
-      if (!defaults) return null;
-      const allPoints = strokes.flatMap((s) => s.points);
-      const bounds = expandRect(rectFromPoints(allPoints), defaults.strokeWidth / 2);
-      return {
-        type: PdfAnnotationSubtype.INK,
-        bounds,
-        data: {
-          ...defaults,
-          rect: bounds,
-          inkList: strokes
-        }
-      };
-    };
-    return {
-      onPointerDown: (pos, evt) => {
-        var _a;
-        const clampedPos = clampToPage(pos);
-        setIsDrawing(true);
-        if (timerRef.current) clearTimeout(timerRef.current);
-        const newStrokes = [...getStrokes(), { points: [clampedPos] }];
-        setStrokes(newStrokes);
-        onPreview(getPreview());
-        (_a = evt.setPointerCapture) == null ? void 0 : _a.call(evt);
-      },
-      onPointerMove: (pos) => {
-        if (!getIsDrawing()) return;
-        const strokes = getStrokes();
-        if (strokes.length === 0) return;
-        const clampedPos = clampToPage(pos);
-        strokes[strokes.length - 1].points.push(clampedPos);
-        setStrokes(strokes);
-        onPreview(getPreview());
-      },
-      onPointerUp: (_, evt) => {
-        var _a;
-        setIsDrawing(false);
-        (_a = evt.releasePointerCapture) == null ? void 0 : _a.call(evt);
-        if (timerRef.current) clearTimeout(timerRef.current);
-        timerRef.current = setTimeout(() => {
-          const strokes = getStrokes();
-          if (strokes.length > 0 && strokes[0].points.length > 1) {
-            const defaults = getDefaults();
-            if (!defaults) return;
-            const allPoints = strokes.flatMap((s) => s.points);
-            const rect = expandRect(rectFromPoints(allPoints), defaults.strokeWidth / 2);
-            onCommit({
-              ...defaults,
-              inkList: strokes,
-              rect,
-              type: PdfAnnotationSubtype.INK,
-              pageIndex: context.pageIndex,
-              id: uuidV4(),
-              created: /* @__PURE__ */ new Date()
-            });
-          }
-          setStrokes([]);
-          onPreview(null);
-        }, 800);
-      },
-      onPointerCancel: (_, evt) => {
-        var _a;
-        setStrokes([]);
-        setIsDrawing(false);
-        onPreview(null);
-        if (timerRef.current) clearTimeout(timerRef.current);
-        (_a = evt.releasePointerCapture) == null ? void 0 : _a.call(evt);
-      }
-    };
-  }
-};
-function useClickDetector({
-  threshold = 5,
-  getTool,
-  onClickDetected
-}) {
-  const [getStartPos, setStartPos] = useState(null);
-  const [getHasMoved, setHasMoved] = useState(false);
-  return {
-    onStart: (pos) => {
-      setStartPos(pos);
-      setHasMoved(false);
+const defaultTools = [
+  // Text Markup Tools
+  {
+    id: "highlight",
+    name: "Highlight",
+    matchScore: (a) => a.type === PdfAnnotationSubtype.HIGHLIGHT ? 1 : 0,
+    interaction: {
+      exclusive: false,
+      textSelection: true,
+      isDraggable: false,
+      isResizable: false
     },
-    onMove: (pos) => {
-      const start = getStartPos();
-      if (!start || getHasMoved()) return;
-      const distance = Math.sqrt(Math.pow(pos.x - start.x, 2) + Math.pow(pos.y - start.y, 2));
-      if (distance > threshold) {
-        setHasMoved(true);
-      }
+    defaults: {
+      type: PdfAnnotationSubtype.HIGHLIGHT,
+      color: "#FFCD45",
+      opacity: 1,
+      blendMode: PdfBlendMode.Multiply
+    }
+  },
+  {
+    id: "underline",
+    name: "Underline",
+    matchScore: (a) => a.type === PdfAnnotationSubtype.UNDERLINE ? 1 : 0,
+    interaction: {
+      exclusive: false,
+      textSelection: true,
+      isDraggable: false,
+      isResizable: false
     },
-    onEnd: (pos) => {
-      var _a;
-      const start = getStartPos();
-      if (start && !getHasMoved()) {
-        const tool = getTool();
-        if (tool && "clickBehavior" in tool && ((_a = tool.clickBehavior) == null ? void 0 : _a.enabled)) {
-          onClickDetected(pos, tool);
-        }
-      }
-      setStartPos(null);
-      setHasMoved(false);
+    defaults: {
+      type: PdfAnnotationSubtype.UNDERLINE,
+      color: "#E44234",
+      opacity: 1
+    }
+  },
+  {
+    id: "strikeout",
+    name: "Strikeout",
+    matchScore: (a) => a.type === PdfAnnotationSubtype.STRIKEOUT ? 1 : 0,
+    interaction: {
+      exclusive: false,
+      textSelection: true
     },
-    hasMoved: getHasMoved,
-    reset: () => {
-      setStartPos(null);
-      setHasMoved(false);
+    defaults: {
+      type: PdfAnnotationSubtype.STRIKEOUT,
+      color: "#E44234",
+      opacity: 1
     }
-  };
-}
-const freeTextHandlerFactory = {
-  annotationType: PdfAnnotationSubtype.FREETEXT,
-  create(context) {
-    const { onCommit, onPreview, getTool, pageSize, pageIndex } = context;
-    const [getStart, setStart] = useState(null);
-    const clampToPage = (pos) => ({
-      x: clamp(pos.x, 0, pageSize.width),
-      y: clamp(pos.y, 0, pageSize.height)
-    });
-    const getDefaults = () => {
-      const tool = getTool();
-      if (!tool) return null;
-      return {
-        ...tool.defaults,
-        fontColor: tool.defaults.fontColor ?? "#000000",
-        opacity: tool.defaults.opacity ?? 1,
-        fontSize: tool.defaults.fontSize ?? 12,
-        fontFamily: tool.defaults.fontFamily ?? PdfStandardFont.Helvetica,
-        backgroundColor: tool.defaults.backgroundColor ?? "transparent",
-        textAlign: tool.defaults.textAlign ?? PdfTextAlignment.Left,
-        verticalAlign: tool.defaults.verticalAlign ?? PdfVerticalAlignment.Top,
-        contents: tool.defaults.contents ?? "Insert text here",
-        flags: tool.defaults.flags ?? ["print"]
-      };
-    };
-    const clickDetector = useClickDetector({
-      threshold: 5,
-      getTool,
-      onClickDetected: (pos, tool) => {
-        const defaults = getDefaults();
-        if (!defaults) return;
-        const clickConfig = tool.clickBehavior;
-        if (!(clickConfig == null ? void 0 : clickConfig.enabled)) return;
-        const { width, height } = clickConfig.defaultSize;
-        const halfWidth = width / 2;
-        const halfHeight = height / 2;
-        const x = clamp(pos.x - halfWidth, 0, pageSize.width - width);
-        const y = clamp(pos.y - halfHeight, 0, pageSize.height - height);
-        const rect = {
-          origin: { x, y },
-          size: { width, height }
-        };
-        const contents = clickConfig.defaultContent ?? defaults.contents;
-        const anno = {
-          ...defaults,
-          contents,
-          type: PdfAnnotationSubtype.FREETEXT,
-          rect,
-          pageIndex,
-          id: uuidV4(),
-          created: /* @__PURE__ */ new Date()
-        };
-        onCommit(anno);
-      }
-    });
-    const getPreview = (current) => {
-      const start = getStart();
-      if (!start) return null;
-      const defaults = getDefaults();
-      if (!defaults) return null;
-      const minX = Math.min(start.x, current.x);
-      const minY = Math.min(start.y, current.y);
-      const width = Math.abs(start.x - current.x);
-      const height = Math.abs(start.y - current.y);
-      const rect = {
-        origin: { x: minX, y: minY },
-        size: { width, height }
-      };
-      return {
-        type: PdfAnnotationSubtype.FREETEXT,
-        bounds: rect,
-        data: {
-          ...defaults,
-          rect
-        }
-      };
-    };
-    return {
-      onPointerDown: (pos, evt) => {
-        var _a;
-        const clampedPos = clampToPage(pos);
-        setStart(clampedPos);
-        clickDetector.onStart(clampedPos);
-        onPreview(getPreview(clampedPos));
-        (_a = evt.setPointerCapture) == null ? void 0 : _a.call(evt);
-      },
-      onPointerMove: (pos) => {
-        const clampedPos = clampToPage(pos);
-        clickDetector.onMove(clampedPos);
-        if (getStart() && clickDetector.hasMoved()) {
-          onPreview(getPreview(clampedPos));
-        }
-      },
-      onPointerUp: (pos, evt) => {
-        var _a;
-        const start = getStart();
-        if (!start) return;
-        const defaults = getDefaults();
-        if (!defaults) return;
-        const clampedPos = clampToPage(pos);
-        if (!clickDetector.hasMoved()) {
-          clickDetector.onEnd(clampedPos);
-        } else {
-          const minX = Math.min(start.x, clampedPos.x);
-          const minY = Math.min(start.y, clampedPos.y);
-          const width = Math.abs(start.x - clampedPos.x);
-          const height = Math.abs(start.y - clampedPos.y);
-          const rect = {
-            origin: { x: minX, y: minY },
-            size: { width, height }
-          };
-          const anno = {
-            ...defaults,
-            type: PdfAnnotationSubtype.FREETEXT,
-            rect,
-            pageIndex: context.pageIndex,
-            id: uuidV4(),
-            created: /* @__PURE__ */ new Date()
-          };
-          onCommit(anno);
-        }
-        setStart(null);
-        onPreview(null);
-        clickDetector.reset();
-        (_a = evt.releasePointerCapture) == null ? void 0 : _a.call(evt);
-      },
-      onPointerLeave: (_, evt) => {
-        var _a;
-        setStart(null);
-        onPreview(null);
-        clickDetector.reset();
-        (_a = evt.releasePointerCapture) == null ? void 0 : _a.call(evt);
-      },
-      onPointerCancel: (_, evt) => {
-        var _a;
-        setStart(null);
-        onPreview(null);
-        clickDetector.reset();
-        (_a = evt.releasePointerCapture) == null ? void 0 : _a.call(evt);
-      }
-    };
-  }
-};
-function createArrowHandler(isClosed) {
-  const calculateGeometry = (sw) => {
-    const len = sw * 9;
-    const a = Math.PI / 6;
-    return {
-      x: -len * Math.cos(a),
-      y: len * Math.sin(a)
-    };
-  };
-  return {
-    getSvgPath: (sw) => {
-      const { x, y } = calculateGeometry(sw);
-      return isClosed ? `M 0 0 L ${x} ${y} L ${x} ${-y} Z` : `M ${x} ${y} L 0 0 L ${x} ${-y}`;
-    },
-    getLocalPoints: (sw) => {
-      const { x, y } = calculateGeometry(sw);
-      return [
-        { x: 0, y: 0 },
-        { x, y },
-        { x, y: -y }
-      ];
-    },
-    getRotation: (segmentAngle) => segmentAngle,
-    filled: isClosed
-  };
-}
-function createLineHandler(lengthFactor, rotationFn) {
-  const getHalfLength = (sw) => sw * lengthFactor / 2;
-  return {
-    getSvgPath: (sw) => {
-      const l = getHalfLength(sw);
-      return `M ${-l} 0 L ${l} 0`;
-    },
-    getLocalPoints: (sw) => {
-      const l = getHalfLength(sw);
-      return [
-        { x: -l, y: 0 },
-        { x: l, y: 0 }
-      ];
-    },
-    getRotation: rotationFn,
-    filled: false
-  };
-}
-const OpenArrowHandler = createArrowHandler(false);
-const ClosedArrowHandler = createArrowHandler(true);
-const LINE_ENDING_HANDLERS = {
-  [PdfAnnotationLineEnding.OpenArrow]: OpenArrowHandler,
-  [PdfAnnotationLineEnding.ClosedArrow]: ClosedArrowHandler,
-  [PdfAnnotationLineEnding.ROpenArrow]: {
-    ...OpenArrowHandler,
-    getRotation: (segmentAngle) => segmentAngle + Math.PI
   },
-  [PdfAnnotationLineEnding.RClosedArrow]: {
-    ...ClosedArrowHandler,
-    getRotation: (segmentAngle) => segmentAngle + Math.PI
+  {
+    id: "squiggly",
+    name: "Squiggly",
+    matchScore: (a) => a.type === PdfAnnotationSubtype.SQUIGGLY ? 1 : 0,
+    interaction: {
+      exclusive: false,
+      textSelection: true,
+      isDraggable: false,
+      isResizable: false
+    },
+    defaults: {
+      type: PdfAnnotationSubtype.SQUIGGLY,
+      color: "#E44234",
+      opacity: 1
+    }
   },
-  [PdfAnnotationLineEnding.Circle]: {
-    getSvgPath: (sw) => {
-      const r = sw * 5 / 2;
-      return `M ${r} 0 A ${r} ${r} 0 1 1 ${-r} 0 A ${r} ${r} 0 1 1 ${r} 0`;
+  // Drawing Tools
+  {
+    id: "ink",
+    name: "Pen",
+    matchScore: (a) => a.type === PdfAnnotationSubtype.INK && a.intent !== "InkHighlight" ? 5 : 0,
+    interaction: {
+      exclusive: false,
+      cursor: "crosshair",
+      isDraggable: true,
+      isResizable: true,
+      lockAspectRatio: false
     },
-    getLocalPoints: (sw) => {
-      const r = sw * 5 / 2;
-      return [
-        { x: -r, y: -r },
-        { x: r, y: r }
-      ];
+    defaults: {
+      type: PdfAnnotationSubtype.INK,
+      color: "#E44234",
+      opacity: 1,
+      strokeWidth: 6
+    }
+  },
+  {
+    id: "inkHighlighter",
+    name: "Ink Highlighter",
+    matchScore: (a) => a.type === PdfAnnotationSubtype.INK && a.intent === "InkHighlight" ? 10 : 0,
+    interaction: {
+      exclusive: false,
+      cursor: "crosshair",
+      isDraggable: true,
+      isResizable: true,
+      lockAspectRatio: false
     },
-    getRotation: () => 0,
-    filled: true
+    defaults: {
+      type: PdfAnnotationSubtype.INK,
+      intent: "InkHighlight",
+      color: "#FFCD45",
+      opacity: 1,
+      strokeWidth: 14,
+      blendMode: PdfBlendMode.Multiply
+    }
   },
-  [PdfAnnotationLineEnding.Square]: {
-    getSvgPath: (sw) => {
-      const h = sw * 6 / 2;
-      return `M ${-h} ${-h} L ${h} ${-h} L ${h} ${h} L ${-h} ${h} Z`;
+  // Shape Tools
+  {
+    id: "circle",
+    name: "Circle",
+    matchScore: (a) => a.type === PdfAnnotationSubtype.CIRCLE ? 1 : 0,
+    interaction: {
+      exclusive: false,
+      cursor: "crosshair",
+      isDraggable: true,
+      isResizable: true,
+      lockAspectRatio: false
     },
-    getLocalPoints: (sw) => {
-      const h = sw * 6 / 2;
-      return [
-        { x: -h, y: -h },
-        // TL
-        { x: h, y: -h },
-        // TR
-        { x: h, y: h },
-        // BR
-        { x: -h, y: h }
-        // BL
-      ];
+    defaults: {
+      type: PdfAnnotationSubtype.CIRCLE,
+      color: "transparent",
+      opacity: 1,
+      strokeWidth: 6,
+      strokeColor: "#E44234",
+      strokeStyle: PdfAnnotationBorderStyle.SOLID
     },
-    getRotation: (segmentAngle) => segmentAngle,
-    // keep your new orientation
-    filled: true
+    clickBehavior: {
+      enabled: true,
+      defaultSize: { width: 100, height: 100 }
+    }
   },
-  [PdfAnnotationLineEnding.Diamond]: {
-    getSvgPath: (sw) => {
-      const h = sw * 6 / 2;
-      return `M 0 ${-h} L ${h} 0 L 0 ${h} L ${-h} 0 Z`;
-    },
-    getLocalPoints: (sw) => {
-      const h = sw * 6 / 2;
-      return [
+  {
+    id: "square",
+    name: "Square",
+    matchScore: (a) => a.type === PdfAnnotationSubtype.SQUARE ? 1 : 0,
+    interaction: {
+      exclusive: false,
+      cursor: "crosshair",
+      isDraggable: true,
+      isResizable: true,
+      lockAspectRatio: false
+    },
+    defaults: {
+      type: PdfAnnotationSubtype.SQUARE,
+      color: "transparent",
+      opacity: 1,
+      strokeWidth: 6,
+      strokeColor: "#E44234",
+      strokeStyle: PdfAnnotationBorderStyle.SOLID
+    },
+    clickBehavior: {
+      enabled: true,
+      defaultSize: { width: 100, height: 100 }
+    }
+  },
+  {
+    id: "line",
+    name: "Line",
+    matchScore: (a) => a.type === PdfAnnotationSubtype.LINE && a.intent !== "LineArrow" ? 5 : 0,
+    interaction: {
+      exclusive: false,
+      cursor: "crosshair",
+      isDraggable: true,
+      isResizable: false,
+      lockAspectRatio: false
+    },
+    defaults: {
+      type: PdfAnnotationSubtype.LINE,
+      color: "transparent",
+      opacity: 1,
+      strokeWidth: 6,
+      strokeColor: "#E44234"
+    },
+    clickBehavior: {
+      enabled: true,
+      defaultLength: 100,
+      defaultAngle: 0
+    }
+  },
+  {
+    id: "lineArrow",
+    name: "Arrow",
+    matchScore: (a) => a.type === PdfAnnotationSubtype.LINE && a.intent === "LineArrow" ? 10 : 0,
+    interaction: {
+      exclusive: false,
+      cursor: "crosshair",
+      isDraggable: true,
+      isResizable: false,
+      lockAspectRatio: false
+    },
+    defaults: {
+      type: PdfAnnotationSubtype.LINE,
+      intent: "LineArrow",
+      color: "transparent",
+      opacity: 1,
+      strokeWidth: 6,
+      strokeColor: "#E44234",
+      lineEndings: {
+        start: PdfAnnotationLineEnding.None,
+        end: PdfAnnotationLineEnding.OpenArrow
+      }
+    },
+    clickBehavior: {
+      enabled: true,
+      defaultLength: 100,
+      defaultAngle: 0
+    }
+  },
+  {
+    id: "polyline",
+    name: "Polyline",
+    matchScore: (a) => a.type === PdfAnnotationSubtype.POLYLINE ? 1 : 0,
+    interaction: {
+      exclusive: false,
+      cursor: "crosshair",
+      isDraggable: true,
+      isResizable: false,
+      lockAspectRatio: false
+    },
+    defaults: {
+      type: PdfAnnotationSubtype.POLYLINE,
+      color: "transparent",
+      opacity: 1,
+      strokeWidth: 6,
+      strokeColor: "#E44234"
+    }
+  },
+  {
+    id: "polygon",
+    name: "Polygon",
+    matchScore: (a) => a.type === PdfAnnotationSubtype.POLYGON ? 1 : 0,
+    interaction: {
+      exclusive: false,
+      cursor: "crosshair",
+      isDraggable: true,
+      isResizable: false,
+      lockAspectRatio: false
+    },
+    defaults: {
+      type: PdfAnnotationSubtype.POLYGON,
+      color: "transparent",
+      opacity: 1,
+      strokeWidth: 6,
+      strokeColor: "#E44234"
+    }
+  },
+  // Text & Stamp
+  {
+    id: "freeText",
+    name: "Free Text",
+    matchScore: (a) => a.type === PdfAnnotationSubtype.FREETEXT ? 1 : 0,
+    interaction: {
+      exclusive: false,
+      cursor: "crosshair",
+      isDraggable: true,
+      isResizable: true,
+      lockAspectRatio: false
+    },
+    defaults: {
+      type: PdfAnnotationSubtype.FREETEXT,
+      contents: "Insert text",
+      fontSize: 14,
+      fontColor: "#E44234",
+      fontFamily: PdfStandardFont.Helvetica,
+      textAlign: PdfTextAlignment.Left,
+      verticalAlign: PdfVerticalAlignment.Top,
+      backgroundColor: "transparent",
+      opacity: 1
+    },
+    clickBehavior: {
+      enabled: true,
+      defaultSize: { width: 100, height: 20 },
+      defaultContent: "Insert text"
+    }
+  },
+  {
+    id: "stamp",
+    name: "Image",
+    matchScore: (a) => a.type === PdfAnnotationSubtype.STAMP ? 1 : 0,
+    interaction: {
+      exclusive: false,
+      cursor: "copy",
+      isDraggable: true,
+      isResizable: true,
+      lockAspectRatio: true
+    },
+    defaults: {
+      type: PdfAnnotationSubtype.STAMP
+      // No imageSrc by default, which tells the UI to open a file picker
+    }
+  }
+];
+const DEFAULT_COLORS = [
+  "#E44234",
+  "#FF8D00",
+  "#FFCD45",
+  "#5CC96E",
+  "#25D2D1",
+  "#597CE2",
+  "#C544CE",
+  "#7D2E25",
+  "#000000",
+  "#FFFFFF"
+];
+const initialDocumentState = () => ({
+  pages: {},
+  byUid: {},
+  selectedUid: null,
+  activeToolId: null,
+  hasPendingChanges: false
+});
+const patchAnno = (docState, uid, patch) => {
+  const prev = docState.byUid[uid];
+  if (!prev) return docState;
+  return {
+    ...docState,
+    byUid: {
+      ...docState.byUid,
+      [uid]: {
+        ...prev,
+        commitState: prev.commitState === "synced" ? "dirty" : prev.commitState,
+        object: { ...prev.object, ...patch }
+      }
+    },
+    hasPendingChanges: true
+  };
+};
+const initialState = (cfg) => {
+  const toolMap = /* @__PURE__ */ new Map();
+  defaultTools.forEach((t) => toolMap.set(t.id, t));
+  (cfg.tools || []).forEach((t) => toolMap.set(t.id, t));
+  return {
+    documents: {},
+    activeDocumentId: null,
+    // `Array.from(toolMap.values())` now correctly returns `AnnotationTool[]`, which matches the state's type.
+    tools: Array.from(toolMap.values()),
+    colorPresets: cfg.colorPresets ?? DEFAULT_COLORS
+  };
+};
+const reducer = (state, action) => {
+  switch (action.type) {
+    case INIT_ANNOTATION_STATE: {
+      const { documentId, state: docState } = action.payload;
+      return {
+        ...state,
+        documents: {
+          ...state.documents,
+          [documentId]: docState
+        },
+        // Set as active if no active document
+        activeDocumentId: state.activeDocumentId ?? documentId
+      };
+    }
+    case CLEANUP_ANNOTATION_STATE: {
+      const documentId = action.payload;
+      const { [documentId]: removed, ...remainingDocs } = state.documents;
+      return {
+        ...state,
+        documents: remainingDocs,
+        activeDocumentId: state.activeDocumentId === documentId ? null : state.activeDocumentId
+      };
+    }
+    case SET_ACTIVE_DOCUMENT: {
+      return {
+        ...state,
+        activeDocumentId: action.payload
+      };
+    }
+    case SET_ANNOTATIONS: {
+      const { documentId, annotations } = action.payload;
+      const docState = state.documents[documentId];
+      if (!docState) return state;
+      const newPages = {};
+      const newByUid = {};
+      for (const [pgStr, list] of Object.entries(annotations)) {
+        const pageIndex = Number(pgStr);
+        const oldUidsOnPage = docState.pages[pageIndex] || [];
+        for (const uid of oldUidsOnPage) {
+          delete newByUid[uid];
+        }
+        const newUidsOnPage = list.map((a) => {
+          const uid = a.id;
+          newByUid[uid] = { commitState: "synced", object: a };
+          return uid;
+        });
+        newPages[pageIndex] = newUidsOnPage;
+      }
+      return {
+        ...state,
+        documents: {
+          ...state.documents,
+          [documentId]: {
+            ...docState,
+            pages: newPages,
+            byUid: newByUid
+          }
+        }
+      };
+    }
+    case SELECT_ANNOTATION: {
+      const { documentId, id } = action.payload;
+      const docState = state.documents[documentId];
+      if (!docState) return state;
+      return {
+        ...state,
+        documents: {
+          ...state.documents,
+          [documentId]: { ...docState, selectedUid: id }
+        }
+      };
+    }
+    case DESELECT_ANNOTATION: {
+      const { documentId } = action.payload;
+      const docState = state.documents[documentId];
+      if (!docState) return state;
+      return {
+        ...state,
+        documents: {
+          ...state.documents,
+          [documentId]: { ...docState, selectedUid: null }
+        }
+      };
+    }
+    case SET_ACTIVE_TOOL_ID: {
+      const { documentId, toolId } = action.payload;
+      const docState = state.documents[documentId];
+      if (!docState) return state;
+      return {
+        ...state,
+        documents: {
+          ...state.documents,
+          [documentId]: { ...docState, activeToolId: toolId }
+        }
+      };
+    }
+    case CREATE_ANNOTATION: {
+      const { documentId, pageIndex, annotation } = action.payload;
+      const docState = state.documents[documentId];
+      if (!docState) return state;
+      const uid = annotation.id;
+      return {
+        ...state,
+        documents: {
+          ...state.documents,
+          [documentId]: {
+            ...docState,
+            pages: {
+              ...docState.pages,
+              [pageIndex]: [...docState.pages[pageIndex] ?? [], uid]
+            },
+            byUid: {
+              ...docState.byUid,
+              [uid]: { commitState: "new", object: annotation }
+            },
+            hasPendingChanges: true
+          }
+        }
+      };
+    }
+    case DELETE_ANNOTATION: {
+      const { documentId, pageIndex, id: uid } = action.payload;
+      const docState = state.documents[documentId];
+      if (!docState || !docState.byUid[uid]) return state;
+      return {
+        ...state,
+        documents: {
+          ...state.documents,
+          [documentId]: {
+            ...docState,
+            pages: {
+              ...docState.pages,
+              [pageIndex]: (docState.pages[pageIndex] ?? []).filter((u) => u !== uid)
+            },
+            byUid: {
+              ...docState.byUid,
+              [uid]: { ...docState.byUid[uid], commitState: "deleted" }
+            },
+            hasPendingChanges: true
+          }
+        }
+      };
+    }
+    case PATCH_ANNOTATION: {
+      const { documentId, id, patch } = action.payload;
+      const docState = state.documents[documentId];
+      if (!docState) return state;
+      return {
+        ...state,
+        documents: {
+          ...state.documents,
+          [documentId]: patchAnno(docState, id, patch)
+        }
+      };
+    }
+    case COMMIT_PENDING_CHANGES: {
+      const { documentId } = action.payload;
+      const docState = state.documents[documentId];
+      if (!docState) return state;
+      const cleaned = {};
+      for (const [uid, ta] of Object.entries(docState.byUid)) {
+        cleaned[uid] = {
+          ...ta,
+          commitState: ta.commitState === "dirty" || ta.commitState === "new" ? "synced" : ta.commitState
+        };
+      }
+      return {
+        ...state,
+        documents: {
+          ...state.documents,
+          [documentId]: { ...docState, byUid: cleaned, hasPendingChanges: false }
+        }
+      };
+    }
+    case PURGE_ANNOTATION: {
+      const { documentId, uid } = action.payload;
+      const docState = state.documents[documentId];
+      if (!docState) return state;
+      const { [uid]: _gone, ...rest } = docState.byUid;
+      return {
+        ...state,
+        documents: {
+          ...state.documents,
+          [documentId]: { ...docState, byUid: rest }
+        }
+      };
+    }
+    // Global actions
+    case ADD_TOOL: {
+      const toolMap = new Map(state.tools.map((t) => [t.id, t]));
+      toolMap.set(action.payload.id, action.payload);
+      return { ...state, tools: Array.from(toolMap.values()) };
+    }
+    case SET_TOOL_DEFAULTS: {
+      const { toolId, patch } = action.payload;
+      return {
+        ...state,
+        tools: state.tools.map((tool) => {
+          if (tool.id === toolId) {
+            return { ...tool, defaults: { ...tool.defaults, ...patch } };
+          }
+          return tool;
+        })
+      };
+    }
+    case ADD_COLOR_PRESET:
+      return state.colorPresets.includes(action.payload) ? state : { ...state, colorPresets: [...state.colorPresets, action.payload] };
+    default:
+      return state;
+  }
+};
+function useState(initialValue) {
+  let value = initialValue;
+  const getValue = () => value;
+  const setValue = (newValue) => {
+    value = newValue;
+  };
+  return [getValue, setValue];
+}
+const inkHandlerFactory = {
+  annotationType: PdfAnnotationSubtype.INK,
+  create(context) {
+    const { onCommit, onPreview, getTool, pageSize } = context;
+    const [getStrokes, setStrokes] = useState([]);
+    const [getIsDrawing, setIsDrawing] = useState(false);
+    const timerRef = { current: null };
+    const clampToPage = (pos) => ({
+      x: clamp(pos.x, 0, pageSize.width),
+      y: clamp(pos.y, 0, pageSize.height)
+    });
+    const getDefaults = () => {
+      const tool = getTool();
+      if (!tool) return null;
+      return {
+        ...tool.defaults,
+        strokeWidth: tool.defaults.strokeWidth ?? 1,
+        color: tool.defaults.color ?? "#000000",
+        opacity: tool.defaults.opacity ?? 1,
+        flags: tool.defaults.flags ?? ["print"]
+      };
+    };
+    const getPreview = () => {
+      const strokes = getStrokes();
+      if (strokes.length === 0 || strokes[0].points.length === 0) return null;
+      const defaults = getDefaults();
+      if (!defaults) return null;
+      const allPoints = strokes.flatMap((s) => s.points);
+      const bounds = expandRect(rectFromPoints(allPoints), defaults.strokeWidth / 2);
+      return {
+        type: PdfAnnotationSubtype.INK,
+        bounds,
+        data: {
+          ...defaults,
+          rect: bounds,
+          inkList: strokes
+        }
+      };
+    };
+    return {
+      onPointerDown: (pos, evt) => {
+        var _a;
+        const clampedPos = clampToPage(pos);
+        setIsDrawing(true);
+        if (timerRef.current) clearTimeout(timerRef.current);
+        const newStrokes = [...getStrokes(), { points: [clampedPos] }];
+        setStrokes(newStrokes);
+        onPreview(getPreview());
+        (_a = evt.setPointerCapture) == null ? void 0 : _a.call(evt);
+      },
+      onPointerMove: (pos) => {
+        if (!getIsDrawing()) return;
+        const strokes = getStrokes();
+        if (strokes.length === 0) return;
+        const clampedPos = clampToPage(pos);
+        strokes[strokes.length - 1].points.push(clampedPos);
+        setStrokes(strokes);
+        onPreview(getPreview());
+      },
+      onPointerUp: (_, evt) => {
+        var _a;
+        setIsDrawing(false);
+        (_a = evt.releasePointerCapture) == null ? void 0 : _a.call(evt);
+        if (timerRef.current) clearTimeout(timerRef.current);
+        timerRef.current = setTimeout(() => {
+          const strokes = getStrokes();
+          if (strokes.length > 0 && strokes[0].points.length > 1) {
+            const defaults = getDefaults();
+            if (!defaults) return;
+            const allPoints = strokes.flatMap((s) => s.points);
+            const rect = expandRect(rectFromPoints(allPoints), defaults.strokeWidth / 2);
+            onCommit({
+              ...defaults,
+              inkList: strokes,
+              rect,
+              type: PdfAnnotationSubtype.INK,
+              pageIndex: context.pageIndex,
+              id: uuidV4(),
+              created: /* @__PURE__ */ new Date()
+            });
+          }
+          setStrokes([]);
+          onPreview(null);
+        }, 800);
+      },
+      onPointerCancel: (_, evt) => {
+        var _a;
+        setStrokes([]);
+        setIsDrawing(false);
+        onPreview(null);
+        if (timerRef.current) clearTimeout(timerRef.current);
+        (_a = evt.releasePointerCapture) == null ? void 0 : _a.call(evt);
+      }
+    };
+  }
+};
+function useClickDetector({
+  threshold = 5,
+  getTool,
+  onClickDetected
+}) {
+  const [getStartPos, setStartPos] = useState(null);
+  const [getHasMoved, setHasMoved] = useState(false);
+  return {
+    onStart: (pos) => {
+      setStartPos(pos);
+      setHasMoved(false);
+    },
+    onMove: (pos) => {
+      const start = getStartPos();
+      if (!start || getHasMoved()) return;
+      const distance = Math.sqrt(Math.pow(pos.x - start.x, 2) + Math.pow(pos.y - start.y, 2));
+      if (distance > threshold) {
+        setHasMoved(true);
+      }
+    },
+    onEnd: (pos) => {
+      var _a;
+      const start = getStartPos();
+      if (start && !getHasMoved()) {
+        const tool = getTool();
+        if (tool && "clickBehavior" in tool && ((_a = tool.clickBehavior) == null ? void 0 : _a.enabled)) {
+          onClickDetected(pos, tool);
+        }
+      }
+      setStartPos(null);
+      setHasMoved(false);
+    },
+    hasMoved: getHasMoved,
+    reset: () => {
+      setStartPos(null);
+      setHasMoved(false);
+    }
+  };
+}
+const freeTextHandlerFactory = {
+  annotationType: PdfAnnotationSubtype.FREETEXT,
+  create(context) {
+    const { onCommit, onPreview, getTool, pageSize, pageIndex } = context;
+    const [getStart, setStart] = useState(null);
+    const clampToPage = (pos) => ({
+      x: clamp(pos.x, 0, pageSize.width),
+      y: clamp(pos.y, 0, pageSize.height)
+    });
+    const getDefaults = () => {
+      const tool = getTool();
+      if (!tool) return null;
+      return {
+        ...tool.defaults,
+        fontColor: tool.defaults.fontColor ?? "#000000",
+        opacity: tool.defaults.opacity ?? 1,
+        fontSize: tool.defaults.fontSize ?? 12,
+        fontFamily: tool.defaults.fontFamily ?? PdfStandardFont.Helvetica,
+        backgroundColor: tool.defaults.backgroundColor ?? "transparent",
+        textAlign: tool.defaults.textAlign ?? PdfTextAlignment.Left,
+        verticalAlign: tool.defaults.verticalAlign ?? PdfVerticalAlignment.Top,
+        contents: tool.defaults.contents ?? "Insert text here",
+        flags: tool.defaults.flags ?? ["print"]
+      };
+    };
+    const clickDetector = useClickDetector({
+      threshold: 5,
+      getTool,
+      onClickDetected: (pos, tool) => {
+        const defaults = getDefaults();
+        if (!defaults) return;
+        const clickConfig = tool.clickBehavior;
+        if (!(clickConfig == null ? void 0 : clickConfig.enabled)) return;
+        const { width, height } = clickConfig.defaultSize;
+        const halfWidth = width / 2;
+        const halfHeight = height / 2;
+        const x = clamp(pos.x - halfWidth, 0, pageSize.width - width);
+        const y = clamp(pos.y - halfHeight, 0, pageSize.height - height);
+        const rect = {
+          origin: { x, y },
+          size: { width, height }
+        };
+        const contents = clickConfig.defaultContent ?? defaults.contents;
+        const anno = {
+          ...defaults,
+          contents,
+          type: PdfAnnotationSubtype.FREETEXT,
+          rect,
+          pageIndex,
+          id: uuidV4(),
+          created: /* @__PURE__ */ new Date()
+        };
+        onCommit(anno);
+      }
+    });
+    const getPreview = (current) => {
+      const start = getStart();
+      if (!start) return null;
+      const defaults = getDefaults();
+      if (!defaults) return null;
+      const minX = Math.min(start.x, current.x);
+      const minY = Math.min(start.y, current.y);
+      const width = Math.abs(start.x - current.x);
+      const height = Math.abs(start.y - current.y);
+      const rect = {
+        origin: { x: minX, y: minY },
+        size: { width, height }
+      };
+      return {
+        type: PdfAnnotationSubtype.FREETEXT,
+        bounds: rect,
+        data: {
+          ...defaults,
+          rect
+        }
+      };
+    };
+    return {
+      onPointerDown: (pos, evt) => {
+        var _a;
+        const clampedPos = clampToPage(pos);
+        setStart(clampedPos);
+        clickDetector.onStart(clampedPos);
+        onPreview(getPreview(clampedPos));
+        (_a = evt.setPointerCapture) == null ? void 0 : _a.call(evt);
+      },
+      onPointerMove: (pos) => {
+        const clampedPos = clampToPage(pos);
+        clickDetector.onMove(clampedPos);
+        if (getStart() && clickDetector.hasMoved()) {
+          onPreview(getPreview(clampedPos));
+        }
+      },
+      onPointerUp: (pos, evt) => {
+        var _a;
+        const start = getStart();
+        if (!start) return;
+        const defaults = getDefaults();
+        if (!defaults) return;
+        const clampedPos = clampToPage(pos);
+        if (!clickDetector.hasMoved()) {
+          clickDetector.onEnd(clampedPos);
+        } else {
+          const minX = Math.min(start.x, clampedPos.x);
+          const minY = Math.min(start.y, clampedPos.y);
+          const width = Math.abs(start.x - clampedPos.x);
+          const height = Math.abs(start.y - clampedPos.y);
+          const rect = {
+            origin: { x: minX, y: minY },
+            size: { width, height }
+          };
+          const anno = {
+            ...defaults,
+            type: PdfAnnotationSubtype.FREETEXT,
+            rect,
+            pageIndex: context.pageIndex,
+            id: uuidV4(),
+            created: /* @__PURE__ */ new Date()
+          };
+          onCommit(anno);
+        }
+        setStart(null);
+        onPreview(null);
+        clickDetector.reset();
+        (_a = evt.releasePointerCapture) == null ? void 0 : _a.call(evt);
+      },
+      onPointerLeave: (_, evt) => {
+        var _a;
+        setStart(null);
+        onPreview(null);
+        clickDetector.reset();
+        (_a = evt.releasePointerCapture) == null ? void 0 : _a.call(evt);
+      },
+      onPointerCancel: (_, evt) => {
+        var _a;
+        setStart(null);
+        onPreview(null);
+        clickDetector.reset();
+        (_a = evt.releasePointerCapture) == null ? void 0 : _a.call(evt);
+      }
+    };
+  }
+};
+function createArrowHandler(isClosed) {
+  const calculateGeometry = (sw) => {
+    const len = sw * 9;
+    const a = Math.PI / 6;
+    return {
+      x: -len * Math.cos(a),
+      y: len * Math.sin(a)
+    };
+  };
+  return {
+    getSvgPath: (sw) => {
+      const { x, y } = calculateGeometry(sw);
+      return isClosed ? `M 0 0 L ${x} ${y} L ${x} ${-y} Z` : `M ${x} ${y} L 0 0 L ${x} ${-y}`;
+    },
+    getLocalPoints: (sw) => {
+      const { x, y } = calculateGeometry(sw);
+      return [
+        { x: 0, y: 0 },
+        { x, y },
+        { x, y: -y }
+      ];
+    },
+    getRotation: (segmentAngle) => segmentAngle,
+    filled: isClosed
+  };
+}
+function createLineHandler(lengthFactor, rotationFn) {
+  const getHalfLength = (sw) => sw * lengthFactor / 2;
+  return {
+    getSvgPath: (sw) => {
+      const l = getHalfLength(sw);
+      return `M ${-l} 0 L ${l} 0`;
+    },
+    getLocalPoints: (sw) => {
+      const l = getHalfLength(sw);
+      return [
+        { x: -l, y: 0 },
+        { x: l, y: 0 }
+      ];
+    },
+    getRotation: rotationFn,
+    filled: false
+  };
+}
+const OpenArrowHandler = createArrowHandler(false);
+const ClosedArrowHandler = createArrowHandler(true);
+const LINE_ENDING_HANDLERS = {
+  [PdfAnnotationLineEnding.OpenArrow]: OpenArrowHandler,
+  [PdfAnnotationLineEnding.ClosedArrow]: ClosedArrowHandler,
+  [PdfAnnotationLineEnding.ROpenArrow]: {
+    ...OpenArrowHandler,
+    getRotation: (segmentAngle) => segmentAngle + Math.PI
+  },
+  [PdfAnnotationLineEnding.RClosedArrow]: {
+    ...ClosedArrowHandler,
+    getRotation: (segmentAngle) => segmentAngle + Math.PI
+  },
+  [PdfAnnotationLineEnding.Circle]: {
+    getSvgPath: (sw) => {
+      const r = sw * 5 / 2;
+      return `M ${r} 0 A ${r} ${r} 0 1 1 ${-r} 0 A ${r} ${r} 0 1 1 ${r} 0`;
+    },
+    getLocalPoints: (sw) => {
+      const r = sw * 5 / 2;
+      return [
+        { x: -r, y: -r },
+        { x: r, y: r }
+      ];
+    },
+    getRotation: () => 0,
+    filled: true
+  },
+  [PdfAnnotationLineEnding.Square]: {
+    getSvgPath: (sw) => {
+      const h = sw * 6 / 2;
+      return `M ${-h} ${-h} L ${h} ${-h} L ${h} ${h} L ${-h} ${h} Z`;
+    },
+    getLocalPoints: (sw) => {
+      const h = sw * 6 / 2;
+      return [
+        { x: -h, y: -h },
+        // TL
+        { x: h, y: -h },
+        // TR
+        { x: h, y: h },
+        // BR
+        { x: -h, y: h }
+        // BL
+      ];
+    },
+    getRotation: (segmentAngle) => segmentAngle,
+    // keep your new orientation
+    filled: true
+  },
+  [PdfAnnotationLineEnding.Diamond]: {
+    getSvgPath: (sw) => {
+      const h = sw * 6 / 2;
+      return `M 0 ${-h} L ${h} 0 L 0 ${h} L ${-h} 0 Z`;
+    },
+    getLocalPoints: (sw) => {
+      const h = sw * 6 / 2;
+      return [
         { x: 0, y: -h },
         { x: h, y: 0 },
         { x: 0, y: h },
@@ -1434,162 +2007,9 @@ const patchLine = (orig, ctx) => {
       if (ctx.changes.linePoints) {
         const { start, end } = ctx.changes.linePoints;
         const rect = lineRectWithEndings([start, end], orig.strokeWidth, orig.lineEndings);
-        return {
-          rect,
-          linePoints: { start, end }
-        };
-      }
-      return ctx.changes;
-    case "move":
-      if (ctx.changes.rect) {
-        const dx = ctx.changes.rect.origin.x - orig.rect.origin.x;
-        const dy = ctx.changes.rect.origin.y - orig.rect.origin.y;
-        return {
-          rect: ctx.changes.rect,
-          linePoints: {
-            start: { x: orig.linePoints.start.x + dx, y: orig.linePoints.start.y + dy },
-            end: { x: orig.linePoints.end.x + dx, y: orig.linePoints.end.y + dy }
-          }
-        };
-      }
-      return ctx.changes;
-    case "resize":
-      if (ctx.changes.rect) {
-        const oldRect = orig.rect;
-        const newRect = ctx.changes.rect;
-        let scaleX = newRect.size.width / oldRect.size.width;
-        let scaleY = newRect.size.height / oldRect.size.height;
-        const minSize = 10;
-        if (newRect.size.width < minSize || newRect.size.height < minSize) {
-          scaleX = Math.max(scaleX, minSize / oldRect.size.width);
-          scaleY = Math.max(scaleY, minSize / oldRect.size.height);
-          ctx.changes.rect = {
-            origin: newRect.origin,
-            size: {
-              width: oldRect.size.width * scaleX,
-              height: oldRect.size.height * scaleY
-            }
-          };
-        }
-        if ((_a = ctx.metadata) == null ? void 0 : _a.maintainAspectRatio) {
-          const minScale = Math.min(scaleX, scaleY);
-          scaleX = minScale;
-          scaleY = minScale;
-          ctx.changes.rect.size = {
-            width: oldRect.size.width * minScale,
-            height: oldRect.size.height * minScale
-          };
-        }
-        const newLinePoints = {
-          start: {
-            x: ctx.changes.rect.origin.x + (orig.linePoints.start.x - oldRect.origin.x) * scaleX,
-            y: ctx.changes.rect.origin.y + (orig.linePoints.start.y - oldRect.origin.y) * scaleY
-          },
-          end: {
-            x: ctx.changes.rect.origin.x + (orig.linePoints.end.x - oldRect.origin.x) * scaleX,
-            y: ctx.changes.rect.origin.y + (orig.linePoints.end.y - oldRect.origin.y) * scaleY
-          }
-        };
-        return {
-          rect: ctx.changes.rect,
-          linePoints: newLinePoints
-        };
-      }
-      return ctx.changes;
-    case "property-update":
-      if (ctx.changes.strokeWidth || ctx.changes.lineEndings) {
-        const merged = { ...orig, ...ctx.changes };
-        const rect = lineRectWithEndings(
-          [merged.linePoints.start, merged.linePoints.end],
-          merged.strokeWidth,
-          merged.lineEndings
-        );
-        return { ...ctx.changes, rect };
-      }
-      return ctx.changes;
-    default:
-      return ctx.changes;
-  }
-};
-const patchPolyline = (orig, ctx) => {
-  var _a;
-  switch (ctx.type) {
-    case "vertex-edit":
-      if (ctx.changes.vertices && ctx.changes.vertices.length) {
-        return {
-          rect: lineRectWithEndings(ctx.changes.vertices, orig.strokeWidth, orig.lineEndings),
-          vertices: ctx.changes.vertices
-        };
-      }
-      return ctx.changes;
-    case "move":
-      if (ctx.changes.rect) {
-        const dx = ctx.changes.rect.origin.x - orig.rect.origin.x;
-        const dy = ctx.changes.rect.origin.y - orig.rect.origin.y;
-        const moved = orig.vertices.map((p) => ({ x: p.x + dx, y: p.y + dy }));
-        return {
-          rect: ctx.changes.rect,
-          vertices: moved
-        };
-      }
-      return ctx.changes;
-    case "resize":
-      if (ctx.changes.rect) {
-        const oldRect = orig.rect;
-        const newRect = ctx.changes.rect;
-        let scaleX = newRect.size.width / oldRect.size.width;
-        let scaleY = newRect.size.height / oldRect.size.height;
-        const minSize = 10;
-        if (newRect.size.width < minSize || newRect.size.height < minSize) {
-          scaleX = Math.max(scaleX, minSize / oldRect.size.width);
-          scaleY = Math.max(scaleY, minSize / oldRect.size.height);
-          ctx.changes.rect = {
-            origin: newRect.origin,
-            size: {
-              width: oldRect.size.width * scaleX,
-              height: oldRect.size.height * scaleY
-            }
-          };
-        }
-        if ((_a = ctx.metadata) == null ? void 0 : _a.maintainAspectRatio) {
-          const minScale = Math.min(scaleX, scaleY);
-          scaleX = minScale;
-          scaleY = minScale;
-          ctx.changes.rect.size = {
-            width: oldRect.size.width * minScale,
-            height: oldRect.size.height * minScale
-          };
-        }
-        const scaledVertices = orig.vertices.map((vertex) => ({
-          x: ctx.changes.rect.origin.x + (vertex.x - oldRect.origin.x) * scaleX,
-          y: ctx.changes.rect.origin.y + (vertex.y - oldRect.origin.y) * scaleY
-        }));
-        return {
-          rect: ctx.changes.rect,
-          vertices: scaledVertices
-        };
-      }
-      return ctx.changes;
-    case "property-update":
-      if (ctx.changes.strokeWidth !== void 0 || ctx.changes.lineEndings !== void 0) {
-        const merged = { ...orig, ...ctx.changes };
-        const rect = lineRectWithEndings(merged.vertices, merged.strokeWidth, merged.lineEndings);
-        return { ...ctx.changes, rect };
-      }
-      return ctx.changes;
-    default:
-      return ctx.changes;
-  }
-};
-const patchPolygon = (orig, ctx) => {
-  var _a;
-  switch (ctx.type) {
-    case "vertex-edit":
-      if (ctx.changes.vertices && ctx.changes.vertices.length) {
-        const pad = orig.strokeWidth / 2;
-        return {
-          rect: expandRect(rectFromPoints(ctx.changes.vertices), pad),
-          vertices: ctx.changes.vertices
+        return {
+          rect,
+          linePoints: { start, end }
         };
       }
       return ctx.changes;
@@ -1597,10 +2017,12 @@ const patchPolygon = (orig, ctx) => {
       if (ctx.changes.rect) {
         const dx = ctx.changes.rect.origin.x - orig.rect.origin.x;
         const dy = ctx.changes.rect.origin.y - orig.rect.origin.y;
-        const moved = orig.vertices.map((p) => ({ x: p.x + dx, y: p.y + dy }));
         return {
           rect: ctx.changes.rect,
-          vertices: moved
+          linePoints: {
+            start: { x: orig.linePoints.start.x + dx, y: orig.linePoints.start.y + dy },
+            end: { x: orig.linePoints.end.x + dx, y: orig.linePoints.end.y + dy }
+          }
         };
       }
       return ctx.changes;
@@ -1631,21 +2053,30 @@ const patchPolygon = (orig, ctx) => {
             height: oldRect.size.height * minScale
           };
         }
-        const scaledVertices = orig.vertices.map((vertex) => ({
-          x: ctx.changes.rect.origin.x + (vertex.x - oldRect.origin.x) * scaleX,
-          y: ctx.changes.rect.origin.y + (vertex.y - oldRect.origin.y) * scaleY
-        }));
+        const newLinePoints = {
+          start: {
+            x: ctx.changes.rect.origin.x + (orig.linePoints.start.x - oldRect.origin.x) * scaleX,
+            y: ctx.changes.rect.origin.y + (orig.linePoints.start.y - oldRect.origin.y) * scaleY
+          },
+          end: {
+            x: ctx.changes.rect.origin.x + (orig.linePoints.end.x - oldRect.origin.x) * scaleX,
+            y: ctx.changes.rect.origin.y + (orig.linePoints.end.y - oldRect.origin.y) * scaleY
+          }
+        };
         return {
           rect: ctx.changes.rect,
-          vertices: scaledVertices
+          linePoints: newLinePoints
         };
       }
       return ctx.changes;
     case "property-update":
-      if (ctx.changes.strokeWidth !== void 0) {
+      if (ctx.changes.strokeWidth || ctx.changes.lineEndings) {
         const merged = { ...orig, ...ctx.changes };
-        const pad = merged.strokeWidth / 2;
-        const rect = expandRect(rectFromPoints(merged.vertices), pad);
+        const rect = lineRectWithEndings(
+          [merged.linePoints.start, merged.linePoints.end],
+          merged.strokeWidth,
+          merged.lineEndings
+        );
         return { ...ctx.changes, rect };
       }
       return ctx.changes;
@@ -1653,921 +2084,804 @@ const patchPolygon = (orig, ctx) => {
       return ctx.changes;
   }
 };
-const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
-  constructor(id, registry, config) {
-    var _a, _b, _c;
-    super(id, registry);
-    this.ANNOTATION_HISTORY_TOPIC = "annotations";
-    this.state$ = createBehaviorEmitter();
-    this.pendingContexts = /* @__PURE__ */ new Map();
-    this.handlerFactories = /* @__PURE__ */ new Map();
-    this.activeTool$ = createBehaviorEmitter(null);
-    this.events$ = createBehaviorEmitter();
-    this.patchRegistry = new PatchRegistry();
-    this.isInitialLoadComplete = false;
-    this.importQueue = [];
-    this.config = config;
-    this.selection = ((_a = registry.getPlugin("selection")) == null ? void 0 : _a.provides()) ?? null;
-    this.history = ((_b = registry.getPlugin("history")) == null ? void 0 : _b.provides()) ?? null;
-    this.interactionManager = ((_c = registry.getPlugin("interaction-manager")) == null ? void 0 : _c.provides()) ?? null;
-    this.coreStore.onAction(SET_DOCUMENT, (_, state) => {
-      const doc = state.core.document;
-      this.isInitialLoadComplete = false;
-      if (doc) this.getAllAnnotations(doc);
-    });
-    this.registerHandlerFactories();
-    this.registerBuiltInPatches();
-  }
-  registerHandlerFactories() {
-    this.handlerFactories.set(PdfAnnotationSubtype.CIRCLE, circleHandlerFactory);
-    this.handlerFactories.set(PdfAnnotationSubtype.SQUARE, squareHandlerFactory);
-    this.handlerFactories.set(PdfAnnotationSubtype.STAMP, stampHandlerFactory);
-    this.handlerFactories.set(PdfAnnotationSubtype.POLYGON, polygonHandlerFactory);
-    this.handlerFactories.set(PdfAnnotationSubtype.POLYLINE, polylineHandlerFactory);
-    this.handlerFactories.set(PdfAnnotationSubtype.LINE, lineHandlerFactory);
-    this.handlerFactories.set(PdfAnnotationSubtype.INK, inkHandlerFactory);
-    this.handlerFactories.set(PdfAnnotationSubtype.FREETEXT, freeTextHandlerFactory);
-  }
-  registerBuiltInPatches() {
-    this.patchRegistry.register(PdfAnnotationSubtype.INK, patchInk);
-    this.patchRegistry.register(PdfAnnotationSubtype.LINE, patchLine);
-    this.patchRegistry.register(PdfAnnotationSubtype.POLYLINE, patchPolyline);
-    this.patchRegistry.register(PdfAnnotationSubtype.POLYGON, patchPolygon);
-  }
-  async initialize() {
-    var _a, _b, _c;
-    this.state.tools.forEach((tool) => this.registerInteractionForTool(tool));
-    (_a = this.history) == null ? void 0 : _a.onHistoryChange((topic) => {
-      if (topic === this.ANNOTATION_HISTORY_TOPIC && this.config.autoCommit !== false) {
-        this.commit();
-      }
-    });
-    (_b = this.interactionManager) == null ? void 0 : _b.onModeChange((s) => {
-      var _a2;
-      const newToolId = ((_a2 = this.state.tools.find((t) => (t.interaction.mode ?? t.id) === s.activeMode)) == null ? void 0 : _a2.id) ?? null;
-      if (newToolId !== this.state.activeToolId) {
-        this.dispatch(setActiveToolId(newToolId));
-      }
-    });
-    (_c = this.selection) == null ? void 0 : _c.onEndSelection(() => {
-      var _a2, _b2, _c2;
-      const activeTool = this.getActiveTool();
-      if (!activeTool || !activeTool.interaction.textSelection) return;
-      const formattedSelection = (_a2 = this.selection) == null ? void 0 : _a2.getFormattedSelection();
-      const selectionText = (_b2 = this.selection) == null ? void 0 : _b2.getSelectedText();
-      if (!formattedSelection || !selectionText) return;
-      for (const selection of formattedSelection) {
-        selectionText.wait((text) => {
-          const annotationId = uuidV4();
-          this.createAnnotation(selection.pageIndex, {
-            ...activeTool.defaults,
-            rect: selection.rect,
-            segmentRects: selection.segmentRects,
-            pageIndex: selection.pageIndex,
-            created: /* @__PURE__ */ new Date(),
-            id: annotationId,
-            custom: {
-              text: text.join("\n")
-            }
-          });
-          if (this.getToolBehavior(activeTool, "deactivateToolAfterCreate")) {
-            this.setActiveTool(null);
-          }
-          if (this.getToolBehavior(activeTool, "selectAfterCreate")) {
-            this.selectAnnotation(selection.pageIndex, annotationId);
-          }
-        }, ignore);
-      }
-      (_c2 = this.selection) == null ? void 0 : _c2.clear();
-    });
-  }
-  registerInteractionForTool(tool) {
-    var _a, _b;
-    (_a = this.interactionManager) == null ? void 0 : _a.registerMode({
-      id: tool.interaction.mode ?? tool.id,
-      scope: "page",
-      exclusive: tool.interaction.exclusive,
-      cursor: tool.interaction.cursor
-    });
-    if (tool.interaction.textSelection) {
-      (_b = this.selection) == null ? void 0 : _b.enableForMode(tool.interaction.mode ?? tool.id);
-    }
-  }
-  buildCapability() {
-    return {
-      getPageAnnotations: (options) => this.getPageAnnotations(options),
-      getSelectedAnnotation: () => getSelectedAnnotation(this.state),
-      selectAnnotation: (pageIndex, id) => this.selectAnnotation(pageIndex, id),
-      deselectAnnotation: () => this.dispatch(deselectAnnotation()),
-      getActiveTool: () => this.getActiveTool(),
-      setActiveTool: (toolId) => this.setActiveTool(toolId),
-      getTools: () => this.state.tools,
-      getTool: (toolId) => this.getTool(toolId),
-      addTool: (tool) => {
-        this.dispatch(addTool(tool));
-        this.registerInteractionForTool(tool);
-      },
-      transformAnnotation: (annotation, options) => this.transformAnnotation(annotation, options),
-      registerPatchFunction: (type, patchFn) => this.registerPatchFunction(type, patchFn),
-      findToolForAnnotation: (anno) => this.findToolForAnnotation(anno),
-      setToolDefaults: (toolId, patch) => this.dispatch(setToolDefaults(toolId, patch)),
-      getColorPresets: () => [...this.state.colorPresets],
-      addColorPreset: (color) => this.dispatch(addColorPreset(color)),
-      importAnnotations: (items) => this.importAnnotations(items),
-      createAnnotation: (pageIndex, anno, ctx) => this.createAnnotation(pageIndex, anno, ctx),
-      updateAnnotation: (pageIndex, id, patch) => this.updateAnnotation(pageIndex, id, patch),
-      deleteAnnotation: (pageIndex, id) => this.deleteAnnotation(pageIndex, id),
-      renderAnnotation: (options) => this.renderAnnotation(options),
-      onStateChange: this.state$.on,
-      onActiveToolChange: this.activeTool$.on,
-      onAnnotationEvent: this.events$.on,
-      commit: () => this.commit()
-    };
-  }
-  onStoreUpdated(prev, next) {
-    this.state$.emit(next);
-    if (prev.activeToolId !== next.activeToolId || prev.tools !== next.tools) {
-      this.activeTool$.emit(this.getActiveTool());
-    }
-  }
-  registerPatchFunction(type, patchFn) {
-    this.patchRegistry.register(type, patchFn);
-  }
-  transformAnnotation(annotation, options) {
-    const context = {
-      type: options.type,
-      changes: options.changes,
-      metadata: options.metadata
-    };
-    return this.patchRegistry.transform(annotation, context);
-  }
-  registerPageHandlers(pageIndex, scale, callbacks) {
-    var _a;
-    const page = (_a = this.coreState.core.document) == null ? void 0 : _a.pages[pageIndex];
-    if (!page) return () => {
-    };
-    if (!this.interactionManager) return () => {
-    };
-    const unregisterFns = [];
-    for (const tool of this.state.tools) {
-      if (!tool.defaults.type) continue;
-      const factory = this.handlerFactories.get(tool.defaults.type);
-      if (!factory) continue;
-      const context = {
-        pageIndex,
-        pageSize: page.size,
-        scale,
-        services: callbacks.services,
-        // Pass through services
-        onPreview: (state) => callbacks.onPreview(tool.id, state),
-        onCommit: (annotation, ctx) => {
-          this.createAnnotation(pageIndex, annotation, ctx);
-          if (this.getToolBehavior(tool, "deactivateToolAfterCreate")) {
-            this.setActiveTool(null);
-          }
-          if (this.getToolBehavior(tool, "selectAfterCreate")) {
-            this.selectAnnotation(pageIndex, annotation.id);
-          }
-        },
-        getTool: () => this.state.tools.find((t) => t.id === tool.id)
-      };
-      const unregister = this.interactionManager.registerHandlers({
-        modeId: tool.interaction.mode ?? tool.id,
-        handlers: factory.create(context),
-        pageIndex
-      });
-      unregisterFns.push(unregister);
-    }
-    return () => unregisterFns.forEach((fn) => fn());
-  }
-  getAllAnnotations(doc) {
-    const task = this.engine.getAllAnnotations(doc);
-    task.wait((annotations) => {
-      this.dispatch(setAnnotations(annotations));
-      this.isInitialLoadComplete = true;
-      if (this.importQueue.length > 0) {
-        this.processImportQueue();
+const patchPolyline = (orig, ctx) => {
+  var _a;
+  switch (ctx.type) {
+    case "vertex-edit":
+      if (ctx.changes.vertices && ctx.changes.vertices.length) {
+        return {
+          rect: lineRectWithEndings(ctx.changes.vertices, orig.strokeWidth, orig.lineEndings),
+          vertices: ctx.changes.vertices
+        };
       }
-      this.events$.emit({
-        type: "loaded",
-        total: Object.values(annotations).reduce(
-          (sum, pageAnnotations) => sum + pageAnnotations.length,
-          0
-        )
-      });
-    }, ignore);
-  }
-  getPageAnnotations(options) {
-    const { pageIndex } = options;
-    const doc = this.coreState.core.document;
-    if (!doc) {
-      return PdfTaskHelper.reject({ code: PdfErrorCode.NotFound, message: "Document not found" });
-    }
-    const page = doc.pages.find((p) => p.index === pageIndex);
-    if (!page) {
-      return PdfTaskHelper.reject({ code: PdfErrorCode.NotFound, message: "Page not found" });
-    }
-    return this.engine.getPageAnnotations(doc, page);
-  }
-  renderAnnotation({ pageIndex, annotation, options }) {
-    const coreState = this.coreState.core;
-    if (!coreState.document) {
-      return PdfTaskHelper.reject({ code: PdfErrorCode.NotFound, message: "Document not found" });
-    }
-    const page = coreState.document.pages.find((page2) => page2.index === pageIndex);
-    if (!page) {
-      return PdfTaskHelper.reject({ code: PdfErrorCode.NotFound, message: "Page not found" });
-    }
-    return this.engine.renderPageAnnotation(coreState.document, page, annotation, options);
-  }
-  importAnnotations(items) {
-    if (!this.isInitialLoadComplete) {
-      this.importQueue.push(...items);
-      return;
-    }
-    this.processImportItems(items);
-  }
-  processImportQueue() {
-    if (this.importQueue.length === 0) return;
-    const items = [...this.importQueue];
-    this.importQueue = [];
-    this.processImportItems(items);
-  }
-  processImportItems(items) {
-    for (const item of items) {
-      const { annotation, ctx } = item;
-      const pageIndex = annotation.pageIndex;
-      const id = annotation.id;
-      this.dispatch(createAnnotation(pageIndex, annotation));
-      if (ctx) this.pendingContexts.set(id, ctx);
-    }
-    if (this.config.autoCommit !== false) this.commit();
-  }
-  createAnnotation(pageIndex, annotation, ctx) {
-    const id = annotation.id;
-    const newAnnotation = {
-      ...annotation,
-      author: annotation.author ?? this.config.annotationAuthor
-    };
-    const execute = () => {
-      this.dispatch(createAnnotation(pageIndex, newAnnotation));
-      if (ctx) this.pendingContexts.set(id, ctx);
-      this.events$.emit({
-        type: "create",
-        annotation: newAnnotation,
-        pageIndex,
-        ctx,
-        committed: false
-      });
-    };
-    if (!this.history) {
-      execute();
-      if (this.config.autoCommit) this.commit();
-      return;
-    }
-    const command = {
-      execute,
-      undo: () => {
-        this.pendingContexts.delete(id);
-        this.dispatch(deselectAnnotation());
-        this.dispatch(deleteAnnotation(pageIndex, id));
-        this.events$.emit({
-          type: "delete",
-          annotation: newAnnotation,
-          pageIndex,
-          committed: false
-        });
+      return ctx.changes;
+    case "move":
+      if (ctx.changes.rect) {
+        const dx = ctx.changes.rect.origin.x - orig.rect.origin.x;
+        const dy = ctx.changes.rect.origin.y - orig.rect.origin.y;
+        const moved = orig.vertices.map((p) => ({ x: p.x + dx, y: p.y + dy }));
+        return {
+          rect: ctx.changes.rect,
+          vertices: moved
+        };
       }
-    };
-    this.history.register(command, this.ANNOTATION_HISTORY_TOPIC);
-  }
-  buildPatch(original, patch) {
-    if ("rect" in patch) return patch;
-    return this.transformAnnotation(original, {
-      type: "property-update",
-      changes: patch
-    });
-  }
-  updateAnnotation(pageIndex, id, patch) {
-    const originalObject = this.state.byUid[id].object;
-    const finalPatch = this.buildPatch(originalObject, {
-      ...patch,
-      author: patch.author ?? this.config.annotationAuthor
-    });
-    const execute = () => {
-      this.dispatch(patchAnnotation(pageIndex, id, finalPatch));
-      this.events$.emit({
-        type: "update",
-        annotation: originalObject,
-        pageIndex,
-        patch: finalPatch,
-        committed: false
-      });
-    };
-    if (!this.history) {
-      execute();
-      if (this.config.autoCommit !== false) {
-        this.commit();
+      return ctx.changes;
+    case "resize":
+      if (ctx.changes.rect) {
+        const oldRect = orig.rect;
+        const newRect = ctx.changes.rect;
+        let scaleX = newRect.size.width / oldRect.size.width;
+        let scaleY = newRect.size.height / oldRect.size.height;
+        const minSize = 10;
+        if (newRect.size.width < minSize || newRect.size.height < minSize) {
+          scaleX = Math.max(scaleX, minSize / oldRect.size.width);
+          scaleY = Math.max(scaleY, minSize / oldRect.size.height);
+          ctx.changes.rect = {
+            origin: newRect.origin,
+            size: {
+              width: oldRect.size.width * scaleX,
+              height: oldRect.size.height * scaleY
+            }
+          };
+        }
+        if ((_a = ctx.metadata) == null ? void 0 : _a.maintainAspectRatio) {
+          const minScale = Math.min(scaleX, scaleY);
+          scaleX = minScale;
+          scaleY = minScale;
+          ctx.changes.rect.size = {
+            width: oldRect.size.width * minScale,
+            height: oldRect.size.height * minScale
+          };
+        }
+        const scaledVertices = orig.vertices.map((vertex) => ({
+          x: ctx.changes.rect.origin.x + (vertex.x - oldRect.origin.x) * scaleX,
+          y: ctx.changes.rect.origin.y + (vertex.y - oldRect.origin.y) * scaleY
+        }));
+        return {
+          rect: ctx.changes.rect,
+          vertices: scaledVertices
+        };
       }
-      return;
-    }
-    const originalPatch = Object.fromEntries(
-      Object.keys(patch).map((key) => [key, originalObject[key]])
-    );
-    const command = {
-      execute,
-      undo: () => {
-        this.dispatch(patchAnnotation(pageIndex, id, originalPatch));
-        this.events$.emit({
-          type: "update",
-          annotation: originalObject,
-          pageIndex,
-          patch: originalPatch,
-          committed: false
-        });
+      return ctx.changes;
+    case "property-update":
+      if (ctx.changes.strokeWidth !== void 0 || ctx.changes.lineEndings !== void 0) {
+        const merged = { ...orig, ...ctx.changes };
+        const rect = lineRectWithEndings(merged.vertices, merged.strokeWidth, merged.lineEndings);
+        return { ...ctx.changes, rect };
       }
-    };
-    this.history.register(command, this.ANNOTATION_HISTORY_TOPIC);
+      return ctx.changes;
+    default:
+      return ctx.changes;
   }
-  deleteAnnotation(pageIndex, id) {
-    var _a;
-    const originalAnnotation = (_a = this.state.byUid[id]) == null ? void 0 : _a.object;
-    if (!originalAnnotation) return;
-    const execute = () => {
-      this.dispatch(deselectAnnotation());
-      this.dispatch(deleteAnnotation(pageIndex, id));
-      this.events$.emit({
-        type: "delete",
-        annotation: originalAnnotation,
-        pageIndex,
-        committed: false
-      });
-    };
-    if (!this.history) {
-      execute();
-      if (this.config.autoCommit !== false) this.commit();
-      return;
-    }
-    const command = {
-      execute,
-      undo: () => {
-        this.dispatch(createAnnotation(pageIndex, originalAnnotation));
-        this.events$.emit({
-          type: "create",
-          annotation: originalAnnotation,
-          pageIndex,
-          committed: false
-        });
+};
+const patchPolygon = (orig, ctx) => {
+  var _a;
+  switch (ctx.type) {
+    case "vertex-edit":
+      if (ctx.changes.vertices && ctx.changes.vertices.length) {
+        const pad = orig.strokeWidth / 2;
+        return {
+          rect: expandRect(rectFromPoints(ctx.changes.vertices), pad),
+          vertices: ctx.changes.vertices
+        };
       }
-    };
-    this.history.register(command, this.ANNOTATION_HISTORY_TOPIC);
-  }
-  selectAnnotation(pageIndex, id) {
-    this.dispatch(selectAnnotation(pageIndex, id));
-  }
-  getActiveTool() {
-    if (!this.state.activeToolId) return null;
-    return this.state.tools.find((t) => t.id === this.state.activeToolId) ?? null;
-  }
-  setActiveTool(toolId) {
-    var _a, _b;
-    if (toolId === this.state.activeToolId) return;
-    const tool = this.state.tools.find((t) => t.id === toolId);
-    if (tool) {
-      (_a = this.interactionManager) == null ? void 0 : _a.activate(tool.interaction.mode ?? tool.id);
-    } else {
-      (_b = this.interactionManager) == null ? void 0 : _b.activateDefaultMode();
-    }
-  }
-  getTool(toolId) {
-    return this.state.tools.find((t) => t.id === toolId);
-  }
-  findToolForAnnotation(annotation) {
-    let bestTool = null;
-    let bestScore = 0;
-    for (const tool of this.state.tools) {
-      const score = tool.matchScore(annotation);
-      if (score > bestScore) {
-        bestScore = score;
-        bestTool = tool;
+      return ctx.changes;
+    case "move":
+      if (ctx.changes.rect) {
+        const dx = ctx.changes.rect.origin.x - orig.rect.origin.x;
+        const dy = ctx.changes.rect.origin.y - orig.rect.origin.y;
+        const moved = orig.vertices.map((p) => ({ x: p.x + dx, y: p.y + dy }));
+        return {
+          rect: ctx.changes.rect,
+          vertices: moved
+        };
       }
-    }
-    return bestTool;
-  }
-  commit() {
-    const task = new Task();
-    if (!this.state.hasPendingChanges) return PdfTaskHelper.resolve(true);
-    const doc = this.coreState.core.document;
-    if (!doc)
-      return PdfTaskHelper.reject({ code: PdfErrorCode.NotFound, message: "Document not found" });
-    const creations = [];
-    const updates = [];
-    const deletions = [];
-    for (const [uid, ta] of Object.entries(this.state.byUid)) {
-      if (ta.commitState === "synced") continue;
-      const page = doc.pages.find((p) => p.index === ta.object.pageIndex);
-      if (!page) continue;
-      switch (ta.commitState) {
-        case "new":
-          const ctx = this.pendingContexts.get(ta.object.id);
-          const task2 = this.engine.createPageAnnotation(doc, page, ta.object, ctx);
-          task2.wait(() => {
-            this.events$.emit({
-              type: "create",
-              annotation: ta.object,
-              pageIndex: ta.object.pageIndex,
-              ctx,
-              committed: true
-            });
-            this.pendingContexts.delete(ta.object.id);
-          }, ignore);
-          creations.push(task2);
-          break;
-        case "dirty":
-          const updateTask = this.engine.updatePageAnnotation(doc, page, ta.object);
-          updateTask.wait(() => {
-            this.events$.emit({
-              type: "update",
-              annotation: ta.object,
-              pageIndex: ta.object.pageIndex,
-              patch: ta.object,
-              committed: true
-            });
-          }, ignore);
-          updates.push(updateTask);
-          break;
-        case "deleted":
-          deletions.push({ ta, uid });
-          break;
+      return ctx.changes;
+    case "resize":
+      if (ctx.changes.rect) {
+        const oldRect = orig.rect;
+        const newRect = ctx.changes.rect;
+        let scaleX = newRect.size.width / oldRect.size.width;
+        let scaleY = newRect.size.height / oldRect.size.height;
+        const minSize = 10;
+        if (newRect.size.width < minSize || newRect.size.height < minSize) {
+          scaleX = Math.max(scaleX, minSize / oldRect.size.width);
+          scaleY = Math.max(scaleY, minSize / oldRect.size.height);
+          ctx.changes.rect = {
+            origin: newRect.origin,
+            size: {
+              width: oldRect.size.width * scaleX,
+              height: oldRect.size.height * scaleY
+            }
+          };
+        }
+        if ((_a = ctx.metadata) == null ? void 0 : _a.maintainAspectRatio) {
+          const minScale = Math.min(scaleX, scaleY);
+          scaleX = minScale;
+          scaleY = minScale;
+          ctx.changes.rect.size = {
+            width: oldRect.size.width * minScale,
+            height: oldRect.size.height * minScale
+          };
+        }
+        const scaledVertices = orig.vertices.map((vertex) => ({
+          x: ctx.changes.rect.origin.x + (vertex.x - oldRect.origin.x) * scaleX,
+          y: ctx.changes.rect.origin.y + (vertex.y - oldRect.origin.y) * scaleY
+        }));
+        return {
+          rect: ctx.changes.rect,
+          vertices: scaledVertices
+        };
       }
-    }
-    const deletionTasks = [];
-    for (const { ta, uid } of deletions) {
-      const page = doc.pages.find((p) => p.index === ta.object.pageIndex);
-      if (ta.commitState === "deleted" && ta.object.id) {
-        const task2 = new Task();
-        const removeTask = this.engine.removePageAnnotation(doc, page, ta.object);
-        removeTask.wait(() => {
-          this.dispatch(purgeAnnotation(uid));
-          this.events$.emit({
-            type: "delete",
-            annotation: ta.object,
-            pageIndex: ta.object.pageIndex,
-            committed: true
-          });
-          task2.resolve(true);
-        }, task2.fail);
-        deletionTasks.push(task2);
-      } else {
-        this.dispatch(purgeAnnotation(uid));
+      return ctx.changes;
+    case "property-update":
+      if (ctx.changes.strokeWidth !== void 0) {
+        const merged = { ...orig, ...ctx.changes };
+        const pad = merged.strokeWidth / 2;
+        const rect = expandRect(rectFromPoints(merged.vertices), pad);
+        return { ...ctx.changes, rect };
       }
-    }
-    const allWriteTasks = [...creations, ...updates, ...deletionTasks];
-    Task.allSettled(allWriteTasks).wait(() => {
-      this.dispatch(commitPendingChanges());
-      task.resolve(true);
-    }, task.fail);
-    return task;
-  }
-  /**
-   * Gets the effective behavior setting for a tool, checking tool-specific config first,
-   * then falling back to plugin config.
-   */
-  getToolBehavior(tool, setting) {
-    var _a;
-    if (((_a = tool.behavior) == null ? void 0 : _a[setting]) !== void 0) {
-      return tool.behavior[setting];
-    }
-    return this.config[setting] !== false;
+      return ctx.changes;
+    default:
+      return ctx.changes;
   }
 };
-_AnnotationPlugin.id = "annotation";
-let AnnotationPlugin = _AnnotationPlugin;
-const defaultTools = [
-  // Text Markup Tools
-  {
-    id: "highlight",
-    name: "Highlight",
-    matchScore: (a) => a.type === PdfAnnotationSubtype.HIGHLIGHT ? 1 : 0,
-    interaction: {
-      exclusive: false,
-      textSelection: true,
-      isDraggable: false,
-      isResizable: false
-    },
-    defaults: {
-      type: PdfAnnotationSubtype.HIGHLIGHT,
-      color: "#FFCD45",
-      opacity: 1,
-      blendMode: PdfBlendMode.Multiply
-    }
-  },
-  {
-    id: "underline",
-    name: "Underline",
-    matchScore: (a) => a.type === PdfAnnotationSubtype.UNDERLINE ? 1 : 0,
-    interaction: {
-      exclusive: false,
-      textSelection: true,
-      isDraggable: false,
-      isResizable: false
-    },
-    defaults: {
-      type: PdfAnnotationSubtype.UNDERLINE,
-      color: "#E44234",
-      opacity: 1
-    }
-  },
-  {
-    id: "strikeout",
-    name: "Strikeout",
-    matchScore: (a) => a.type === PdfAnnotationSubtype.STRIKEOUT ? 1 : 0,
-    interaction: {
-      exclusive: false,
-      textSelection: true
-    },
-    defaults: {
-      type: PdfAnnotationSubtype.STRIKEOUT,
-      color: "#E44234",
-      opacity: 1
-    }
-  },
-  {
-    id: "squiggly",
-    name: "Squiggly",
-    matchScore: (a) => a.type === PdfAnnotationSubtype.SQUIGGLY ? 1 : 0,
-    interaction: {
-      exclusive: false,
-      textSelection: true,
-      isDraggable: false,
-      isResizable: false
-    },
-    defaults: {
-      type: PdfAnnotationSubtype.SQUIGGLY,
-      color: "#E44234",
-      opacity: 1
+const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
+  constructor(id, registry, config) {
+    var _a, _b, _c;
+    super(id, registry);
+    this.ANNOTATION_HISTORY_TOPIC = "annotations";
+    this.state$ = createBehaviorEmitter();
+    this.pendingContexts = /* @__PURE__ */ new Map();
+    this.isInitialLoadComplete = /* @__PURE__ */ new Map();
+    this.importQueue = /* @__PURE__ */ new Map();
+    this.handlerFactories = /* @__PURE__ */ new Map();
+    this.activeTool$ = createBehaviorEmitter();
+    this.events$ = createBehaviorEmitter();
+    this.toolsChange$ = createBehaviorEmitter();
+    this.patchRegistry = new PatchRegistry();
+    this.config = config;
+    this.selection = ((_a = registry.getPlugin("selection")) == null ? void 0 : _a.provides()) ?? null;
+    this.history = ((_b = registry.getPlugin("history")) == null ? void 0 : _b.provides()) ?? null;
+    this.interactionManager = ((_c = registry.getPlugin("interaction-manager")) == null ? void 0 : _c.provides()) ?? null;
+    this.registerHandlerFactories();
+    this.registerBuiltInPatches();
+  }
+  // ─────────────────────────────────────────────────────────
+  // Document Lifecycle (from BasePlugin)
+  // ─────────────────────────────────────────────────────────
+  onDocumentLoadingStarted(documentId) {
+    this.dispatch(initAnnotationState(documentId, initialDocumentState()));
+    this.pendingContexts.set(documentId, /* @__PURE__ */ new Map());
+    this.isInitialLoadComplete.set(documentId, false);
+    this.importQueue.set(documentId, []);
+    this.logger.debug(
+      "AnnotationPlugin",
+      "DocumentOpened",
+      `Initialized annotation state for document: ${documentId}`
+    );
+  }
+  onDocumentLoaded(documentId) {
+    const docState = this.getCoreDocument(documentId);
+    if (docState == null ? void 0 : docState.document) {
+      this.getAllAnnotations(documentId, docState.document);
     }
-  },
-  // Drawing Tools
-  {
-    id: "ink",
-    name: "Pen",
-    matchScore: (a) => a.type === PdfAnnotationSubtype.INK && a.intent !== "InkHighlight" ? 5 : 0,
-    interaction: {
-      exclusive: false,
-      cursor: "crosshair",
-      isDraggable: true,
-      isResizable: true,
-      lockAspectRatio: false
-    },
-    defaults: {
-      type: PdfAnnotationSubtype.INK,
-      color: "#E44234",
-      opacity: 1,
-      strokeWidth: 6
+    if (this.selection) {
+      for (const tool of this.state.tools) {
+        if (tool.interaction.textSelection) {
+          this.selection.enableForMode(tool.interaction.mode ?? tool.id);
+        }
+      }
     }
-  },
-  {
-    id: "inkHighlighter",
-    name: "Ink Highlighter",
-    matchScore: (a) => a.type === PdfAnnotationSubtype.INK && a.intent === "InkHighlight" ? 10 : 0,
-    interaction: {
-      exclusive: false,
-      cursor: "crosshair",
-      isDraggable: true,
-      isResizable: true,
-      lockAspectRatio: false
-    },
-    defaults: {
-      type: PdfAnnotationSubtype.INK,
-      intent: "InkHighlight",
-      color: "#FFCD45",
-      opacity: 1,
-      strokeWidth: 14,
-      blendMode: PdfBlendMode.Multiply
+  }
+  onDocumentClosed(documentId) {
+    this.dispatch(cleanupAnnotationState(documentId));
+    this.pendingContexts.delete(documentId);
+    this.isInitialLoadComplete.delete(documentId);
+    this.importQueue.delete(documentId);
+    this.logger.debug(
+      "AnnotationPlugin",
+      "DocumentClosed",
+      `Cleaned up annotation state for document: ${documentId}`
+    );
+  }
+  registerHandlerFactories() {
+    this.handlerFactories.set(PdfAnnotationSubtype.CIRCLE, circleHandlerFactory);
+    this.handlerFactories.set(PdfAnnotationSubtype.SQUARE, squareHandlerFactory);
+    this.handlerFactories.set(PdfAnnotationSubtype.STAMP, stampHandlerFactory);
+    this.handlerFactories.set(PdfAnnotationSubtype.POLYGON, polygonHandlerFactory);
+    this.handlerFactories.set(PdfAnnotationSubtype.POLYLINE, polylineHandlerFactory);
+    this.handlerFactories.set(PdfAnnotationSubtype.LINE, lineHandlerFactory);
+    this.handlerFactories.set(PdfAnnotationSubtype.INK, inkHandlerFactory);
+    this.handlerFactories.set(PdfAnnotationSubtype.FREETEXT, freeTextHandlerFactory);
+  }
+  registerBuiltInPatches() {
+    this.patchRegistry.register(PdfAnnotationSubtype.INK, patchInk);
+    this.patchRegistry.register(PdfAnnotationSubtype.LINE, patchLine);
+    this.patchRegistry.register(PdfAnnotationSubtype.POLYLINE, patchPolyline);
+    this.patchRegistry.register(PdfAnnotationSubtype.POLYGON, patchPolygon);
+  }
+  async initialize() {
+    var _a, _b;
+    this.state.tools.forEach((tool) => this.registerInteractionForTool(tool));
+    if (this.history) {
+      this.history.onHistoryChange((event) => {
+        if (event.topic === this.ANNOTATION_HISTORY_TOPIC && this.config.autoCommit !== false) {
+          this.commit(event.documentId);
+        }
+      });
     }
-  },
-  // Shape Tools
-  {
-    id: "circle",
-    name: "Circle",
-    matchScore: (a) => a.type === PdfAnnotationSubtype.CIRCLE ? 1 : 0,
-    interaction: {
-      exclusive: false,
-      cursor: "crosshair",
-      isDraggable: true,
-      isResizable: true,
-      lockAspectRatio: false
-    },
-    defaults: {
-      type: PdfAnnotationSubtype.CIRCLE,
-      color: "transparent",
-      opacity: 1,
-      strokeWidth: 6,
-      strokeColor: "#E44234",
-      strokeStyle: PdfAnnotationBorderStyle.SOLID
-    },
-    clickBehavior: {
-      enabled: true,
-      defaultSize: { width: 100, height: 100 }
+    (_a = this.interactionManager) == null ? void 0 : _a.onModeChange((s) => {
+      var _a2, _b2;
+      const newToolId = ((_a2 = this.state.tools.find((t) => (t.interaction.mode ?? t.id) === s.activeMode)) == null ? void 0 : _a2.id) ?? null;
+      const currentToolId = ((_b2 = this.state.documents[s.documentId]) == null ? void 0 : _b2.activeToolId) ?? null;
+      if (newToolId !== currentToolId && s.documentId) {
+        this.dispatch(setActiveToolId(s.documentId, newToolId));
+      }
+    });
+    (_b = this.selection) == null ? void 0 : _b.onEndSelection(({ documentId }) => {
+      var _a2, _b2, _c;
+      const activeTool = this.getActiveTool(documentId);
+      if (!activeTool || !activeTool.interaction.textSelection) return;
+      const formattedSelection = (_a2 = this.selection) == null ? void 0 : _a2.getFormattedSelection();
+      const selectionText = (_b2 = this.selection) == null ? void 0 : _b2.getSelectedText();
+      if (!formattedSelection || !selectionText) return;
+      for (const selection of formattedSelection) {
+        selectionText.wait((text) => {
+          const annotationId = uuidV4();
+          this.createAnnotation(
+            selection.pageIndex,
+            {
+              ...activeTool.defaults,
+              rect: selection.rect,
+              segmentRects: selection.segmentRects,
+              pageIndex: selection.pageIndex,
+              created: /* @__PURE__ */ new Date(),
+              id: annotationId,
+              custom: {
+                text: text.join("\n")
+              }
+            },
+            void 0,
+            documentId
+          );
+          if (this.getToolBehavior(activeTool, "deactivateToolAfterCreate")) {
+            this.setActiveTool(null, documentId);
+          }
+          if (this.getToolBehavior(activeTool, "selectAfterCreate")) {
+            this.selectAnnotation(selection.pageIndex, annotationId, documentId);
+          }
+        }, ignore);
+      }
+      (_c = this.selection) == null ? void 0 : _c.clear();
+    });
+  }
+  registerInteractionForTool(tool) {
+    var _a;
+    (_a = this.interactionManager) == null ? void 0 : _a.registerMode({
+      id: tool.interaction.mode ?? tool.id,
+      scope: "page",
+      exclusive: tool.interaction.exclusive,
+      cursor: tool.interaction.cursor
+    });
+  }
+  buildCapability() {
+    return {
+      // Active document operations
+      getActiveTool: () => this.getActiveTool(),
+      setActiveTool: (toolId) => this.setActiveTool(toolId),
+      getState: () => this.getDocumentState(),
+      getPageAnnotations: (options) => this.getPageAnnotations(options),
+      getSelectedAnnotation: () => this.getSelectedAnnotation(),
+      getAnnotationById: (id) => this.getAnnotationById(id),
+      selectAnnotation: (pageIndex, id) => this.selectAnnotation(pageIndex, id),
+      deselectAnnotation: () => this.deselectAnnotation(),
+      importAnnotations: (items) => this.importAnnotations(items),
+      createAnnotation: (pageIndex, anno, ctx) => this.createAnnotation(pageIndex, anno, ctx),
+      updateAnnotation: (pageIndex, id, patch) => this.updateAnnotation(pageIndex, id, patch),
+      deleteAnnotation: (pageIndex, id) => this.deleteAnnotation(pageIndex, id),
+      renderAnnotation: (options) => this.renderAnnotation(options),
+      commit: () => this.commit(),
+      // Document-scoped operations
+      forDocument: (documentId) => this.createAnnotationScope(documentId),
+      // Global operations
+      getTools: () => this.state.tools,
+      getTool: (toolId) => this.getTool(toolId),
+      addTool: (tool) => {
+        this.dispatch(addTool(tool));
+        this.registerInteractionForTool(tool);
+      },
+      findToolForAnnotation: (anno) => this.findToolForAnnotation(anno),
+      setToolDefaults: (toolId, patch) => this.dispatch(setToolDefaults(toolId, patch)),
+      getColorPresets: () => [...this.state.colorPresets],
+      addColorPreset: (color) => this.dispatch(addColorPreset(color)),
+      transformAnnotation: (annotation, options) => this.transformAnnotation(annotation, options),
+      registerPatchFunction: (type, patchFn) => this.registerPatchFunction(type, patchFn),
+      // Events
+      onStateChange: this.state$.on,
+      onActiveToolChange: this.activeTool$.on,
+      onAnnotationEvent: this.events$.on,
+      onToolsChange: this.toolsChange$.on
+    };
+  }
+  // ─────────────────────────────────────────────────────────
+  // Document Scoping
+  // ─────────────────────────────────────────────────────────
+  createAnnotationScope(documentId) {
+    return {
+      getState: () => this.getDocumentState(documentId),
+      getPageAnnotations: (options) => this.getPageAnnotations(options, documentId),
+      getSelectedAnnotation: () => this.getSelectedAnnotation(documentId),
+      getAnnotationById: (id) => this.getAnnotationById(id, documentId),
+      selectAnnotation: (pageIndex, id) => this.selectAnnotation(pageIndex, id, documentId),
+      deselectAnnotation: () => this.deselectAnnotation(documentId),
+      getActiveTool: () => this.getActiveTool(documentId),
+      setActiveTool: (toolId) => this.setActiveTool(toolId, documentId),
+      findToolForAnnotation: (anno) => this.findToolForAnnotation(anno),
+      importAnnotations: (items) => this.importAnnotations(items, documentId),
+      createAnnotation: (pageIndex, anno, ctx) => this.createAnnotation(pageIndex, anno, ctx, documentId),
+      updateAnnotation: (pageIndex, id, patch) => this.updateAnnotation(pageIndex, id, patch, documentId),
+      deleteAnnotation: (pageIndex, id) => this.deleteAnnotation(pageIndex, id, documentId),
+      renderAnnotation: (options) => this.renderAnnotation(options, documentId),
+      commit: () => this.commit(documentId),
+      onStateChange: (listener) => this.state$.on((event) => {
+        if (event.documentId === documentId) listener(event.state);
+      }),
+      onAnnotationEvent: (listener) => this.events$.on((event) => {
+        if (event.documentId === documentId) listener(event);
+      }),
+      onActiveToolChange: (listener) => this.activeTool$.on((event) => {
+        if (event.documentId === documentId) listener(event.tool);
+      })
+    };
+  }
+  onStoreUpdated(prev, next) {
+    for (const documentId in next.documents) {
+      const prevDoc = prev.documents[documentId];
+      const nextDoc = next.documents[documentId];
+      if (prevDoc !== nextDoc) {
+        this.state$.emit({
+          documentId,
+          state: nextDoc
+        });
+        if (prevDoc && prevDoc.activeToolId !== nextDoc.activeToolId) {
+          this.activeTool$.emit({
+            documentId,
+            tool: this.getActiveTool(documentId)
+          });
+        }
+      }
     }
-  },
-  {
-    id: "square",
-    name: "Square",
-    matchScore: (a) => a.type === PdfAnnotationSubtype.SQUARE ? 1 : 0,
-    interaction: {
-      exclusive: false,
-      cursor: "crosshair",
-      isDraggable: true,
-      isResizable: true,
-      lockAspectRatio: false
-    },
-    defaults: {
-      type: PdfAnnotationSubtype.SQUARE,
-      color: "transparent",
-      opacity: 1,
-      strokeWidth: 6,
-      strokeColor: "#E44234",
-      strokeStyle: PdfAnnotationBorderStyle.SOLID
-    },
-    clickBehavior: {
-      enabled: true,
-      defaultSize: { width: 100, height: 100 }
+    if (prev.tools !== next.tools) {
+      for (const documentId in next.documents) {
+        this.activeTool$.emit({
+          documentId,
+          tool: this.getActiveTool(documentId)
+        });
+      }
+      this.toolsChange$.emit({
+        tools: next.tools
+      });
     }
-  },
-  {
-    id: "line",
-    name: "Line",
-    matchScore: (a) => a.type === PdfAnnotationSubtype.LINE && a.intent !== "LineArrow" ? 5 : 0,
-    interaction: {
-      exclusive: false,
-      cursor: "crosshair",
-      isDraggable: true,
-      isResizable: false,
-      lockAspectRatio: false
-    },
-    defaults: {
-      type: PdfAnnotationSubtype.LINE,
-      color: "transparent",
-      opacity: 1,
-      strokeWidth: 6,
-      strokeColor: "#E44234"
-    },
-    clickBehavior: {
-      enabled: true,
-      defaultLength: 100,
-      defaultAngle: 0
+  }
+  registerPatchFunction(type, patchFn) {
+    this.patchRegistry.register(type, patchFn);
+  }
+  transformAnnotation(annotation, options) {
+    const context = {
+      type: options.type,
+      changes: options.changes,
+      metadata: options.metadata
+    };
+    return this.patchRegistry.transform(annotation, context);
+  }
+  registerPageHandlers(documentId, pageIndex, scale, callbacks) {
+    var _a;
+    const docState = this.getCoreDocument(documentId);
+    const page = (_a = docState == null ? void 0 : docState.document) == null ? void 0 : _a.pages[pageIndex];
+    if (!page) return () => {
+    };
+    if (!this.interactionManager) return () => {
+    };
+    const unregisterFns = [];
+    for (const tool of this.state.tools) {
+      if (!tool.defaults.type) continue;
+      const factory = this.handlerFactories.get(tool.defaults.type);
+      if (!factory) continue;
+      const context = {
+        pageIndex,
+        pageSize: page.size,
+        scale,
+        services: callbacks.services,
+        // Pass through services
+        onPreview: (state) => callbacks.onPreview(tool.id, state),
+        onCommit: (annotation, ctx) => {
+          this.createAnnotation(pageIndex, annotation, ctx, documentId);
+          if (this.getToolBehavior(tool, "deactivateToolAfterCreate")) {
+            this.setActiveTool(null, documentId);
+          }
+          if (this.getToolBehavior(tool, "selectAfterCreate")) {
+            this.selectAnnotation(pageIndex, annotation.id, documentId);
+          }
+        },
+        getTool: () => this.state.tools.find((t) => t.id === tool.id)
+      };
+      const unregister = this.interactionManager.registerHandlers({
+        documentId,
+        modeId: tool.interaction.mode ?? tool.id,
+        handlers: factory.create(context),
+        pageIndex
+      });
+      unregisterFns.push(unregister);
     }
-  },
-  {
-    id: "lineArrow",
-    name: "Arrow",
-    matchScore: (a) => a.type === PdfAnnotationSubtype.LINE && a.intent === "LineArrow" ? 10 : 0,
-    interaction: {
-      exclusive: false,
-      cursor: "crosshair",
-      isDraggable: true,
-      isResizable: false,
-      lockAspectRatio: false
-    },
-    defaults: {
-      type: PdfAnnotationSubtype.LINE,
-      intent: "LineArrow",
-      color: "transparent",
-      opacity: 1,
-      strokeWidth: 6,
-      strokeColor: "#E44234",
-      lineEndings: {
-        start: PdfAnnotationLineEnding.None,
-        end: PdfAnnotationLineEnding.OpenArrow
+    return () => unregisterFns.forEach((fn) => fn());
+  }
+  // ─────────────────────────────────────────────────────────
+  // Helper Methods
+  // ─────────────────────────────────────────────────────────
+  getDocumentState(documentId) {
+    const id = documentId ?? this.getActiveDocumentId();
+    const docState = this.state.documents[id];
+    if (!docState) {
+      throw new Error(`Annotation state not found for document: ${id}`);
+    }
+    return docState;
+  }
+  getAllAnnotations(documentId, doc) {
+    const task = this.engine.getAllAnnotations(doc);
+    task.wait((annotations) => {
+      this.dispatch(setAnnotations(documentId, annotations));
+      this.isInitialLoadComplete.set(documentId, true);
+      const queue = this.importQueue.get(documentId);
+      if (queue && queue.length > 0) {
+        this.processImportQueue(documentId);
       }
-    },
-    clickBehavior: {
-      enabled: true,
-      defaultLength: 100,
-      defaultAngle: 0
+      this.events$.emit({
+        type: "loaded",
+        documentId,
+        total: Object.values(annotations).reduce(
+          (sum, pageAnnotations) => sum + pageAnnotations.length,
+          0
+        )
+      });
+    }, ignore);
+  }
+  getPageAnnotations(options, documentId) {
+    const { pageIndex } = options;
+    const id = documentId ?? this.getActiveDocumentId();
+    const docState = this.getCoreDocument(id);
+    const doc = docState == null ? void 0 : docState.document;
+    if (!doc) {
+      return PdfTaskHelper.reject({ code: PdfErrorCode.NotFound, message: "Document not found" });
     }
-  },
-  {
-    id: "polyline",
-    name: "Polyline",
-    matchScore: (a) => a.type === PdfAnnotationSubtype.POLYLINE ? 1 : 0,
-    interaction: {
-      exclusive: false,
-      cursor: "crosshair",
-      isDraggable: true,
-      isResizable: false,
-      lockAspectRatio: false
-    },
-    defaults: {
-      type: PdfAnnotationSubtype.POLYLINE,
-      color: "transparent",
-      opacity: 1,
-      strokeWidth: 6,
-      strokeColor: "#E44234"
+    const page = doc.pages.find((p) => p.index === pageIndex);
+    if (!page) {
+      return PdfTaskHelper.reject({ code: PdfErrorCode.NotFound, message: "Page not found" });
     }
-  },
-  {
-    id: "polygon",
-    name: "Polygon",
-    matchScore: (a) => a.type === PdfAnnotationSubtype.POLYGON ? 1 : 0,
-    interaction: {
-      exclusive: false,
-      cursor: "crosshair",
-      isDraggable: true,
-      isResizable: false,
-      lockAspectRatio: false
-    },
-    defaults: {
-      type: PdfAnnotationSubtype.POLYGON,
-      color: "transparent",
-      opacity: 1,
-      strokeWidth: 6,
-      strokeColor: "#E44234"
+    return this.engine.getPageAnnotations(doc, page);
+  }
+  getSelectedAnnotation(documentId) {
+    return getSelectedAnnotation(this.getDocumentState(documentId));
+  }
+  getAnnotationById(id, documentId) {
+    const docState = this.getDocumentState(documentId);
+    return getAnnotationByUid(docState, id);
+  }
+  renderAnnotation({ pageIndex, annotation, options }, documentId) {
+    const id = documentId ?? this.getActiveDocumentId();
+    const docState = this.getCoreDocument(id);
+    const doc = docState == null ? void 0 : docState.document;
+    if (!doc) {
+      return PdfTaskHelper.reject({ code: PdfErrorCode.NotFound, message: "Document not found" });
     }
-  },
-  // Text & Stamp
-  {
-    id: "freeText",
-    name: "Free Text",
-    matchScore: (a) => a.type === PdfAnnotationSubtype.FREETEXT ? 1 : 0,
-    interaction: {
-      exclusive: false,
-      cursor: "crosshair",
-      isDraggable: true,
-      isResizable: true,
-      lockAspectRatio: false
-    },
-    defaults: {
-      type: PdfAnnotationSubtype.FREETEXT,
-      contents: "Insert text",
-      fontSize: 14,
-      fontColor: "#E44234",
-      fontFamily: PdfStandardFont.Helvetica,
-      textAlign: PdfTextAlignment.Left,
-      verticalAlign: PdfVerticalAlignment.Top,
-      backgroundColor: "transparent",
-      opacity: 1
-    },
-    clickBehavior: {
-      enabled: true,
-      defaultSize: { width: 100, height: 20 },
-      defaultContent: "Insert text"
+    const page = doc.pages.find((page2) => page2.index === pageIndex);
+    if (!page) {
+      return PdfTaskHelper.reject({ code: PdfErrorCode.NotFound, message: "Page not found" });
     }
-  },
-  {
-    id: "stamp",
-    name: "Image",
-    matchScore: (a) => a.type === PdfAnnotationSubtype.STAMP ? 1 : 0,
-    interaction: {
-      exclusive: false,
-      cursor: "copy",
-      isDraggable: true,
-      isResizable: true,
-      lockAspectRatio: true
-    },
-    defaults: {
-      type: PdfAnnotationSubtype.STAMP
-      // No imageSrc by default, which tells the UI to open a file picker
+    return this.engine.renderPageAnnotation(doc, page, annotation, options);
+  }
+  importAnnotations(items, documentId) {
+    const id = documentId ?? this.getActiveDocumentId();
+    if (!this.isInitialLoadComplete.get(id)) {
+      const queue = this.importQueue.get(id) || [];
+      queue.push(...items);
+      this.importQueue.set(id, queue);
+      return;
+    }
+    this.processImportItems(id, items);
+  }
+  processImportQueue(documentId) {
+    const queue = this.importQueue.get(documentId);
+    if (!queue || queue.length === 0) return;
+    const items = [...queue];
+    this.importQueue.set(documentId, []);
+    this.processImportItems(documentId, items);
+  }
+  processImportItems(documentId, items) {
+    const contexts = this.pendingContexts.get(documentId);
+    if (!contexts) return;
+    for (const item of items) {
+      const { annotation, ctx } = item;
+      const pageIndex = annotation.pageIndex;
+      const id = annotation.id;
+      this.dispatch(createAnnotation(documentId, pageIndex, annotation));
+      if (ctx) contexts.set(id, ctx);
+    }
+    if (this.config.autoCommit !== false) this.commit(documentId);
+  }
+  createAnnotation(pageIndex, annotation, ctx, documentId) {
+    const id = annotation.id;
+    const docId = documentId ?? this.getActiveDocumentId();
+    const contexts = this.pendingContexts.get(docId);
+    if (!contexts) return;
+    const newAnnotation = {
+      ...annotation,
+      author: annotation.author ?? this.config.annotationAuthor
+    };
+    const execute = () => {
+      this.dispatch(createAnnotation(docId, pageIndex, newAnnotation));
+      if (ctx) contexts.set(id, ctx);
+      this.events$.emit({
+        type: "create",
+        documentId: docId,
+        annotation: newAnnotation,
+        pageIndex,
+        ctx,
+        committed: false
+      });
+    };
+    if (!this.history) {
+      execute();
+      if (this.config.autoCommit) this.commit(docId);
+      return;
     }
+    const command = {
+      execute,
+      undo: () => {
+        contexts.delete(id);
+        this.dispatch(deselectAnnotation(docId));
+        this.dispatch(deleteAnnotation(docId, pageIndex, id));
+        this.events$.emit({
+          type: "delete",
+          documentId: docId,
+          annotation: newAnnotation,
+          pageIndex,
+          committed: false
+        });
+      }
+    };
+    const historyScope = this.history.forDocument(docId);
+    historyScope.register(command, this.ANNOTATION_HISTORY_TOPIC);
   }
-];
-const DEFAULT_COLORS = [
-  "#E44234",
-  "#FF8D00",
-  "#FFCD45",
-  "#5CC96E",
-  "#25D2D1",
-  "#597CE2",
-  "#C544CE",
-  "#7D2E25",
-  "#000000",
-  "#FFFFFF"
-];
-const patchAnno = (state, uid, patch) => {
-  const prev = state.byUid[uid];
-  if (!prev) return state;
-  return {
-    ...state,
-    byUid: {
-      ...state.byUid,
-      [uid]: {
-        ...prev,
-        commitState: prev.commitState === "synced" ? "dirty" : prev.commitState,
-        object: { ...prev.object, ...patch }
+  buildPatch(original, patch) {
+    if ("rect" in patch) return patch;
+    return this.transformAnnotation(original, {
+      type: "property-update",
+      changes: patch
+    });
+  }
+  updateAnnotation(pageIndex, id, patch, documentId) {
+    const docId = documentId ?? this.getActiveDocumentId();
+    const docState = this.getDocumentState(docId);
+    const originalObject = docState.byUid[id].object;
+    const finalPatch = this.buildPatch(originalObject, {
+      ...patch,
+      author: patch.author ?? this.config.annotationAuthor
+    });
+    const execute = () => {
+      this.dispatch(patchAnnotation(docId, pageIndex, id, finalPatch));
+      this.events$.emit({
+        type: "update",
+        documentId: docId,
+        annotation: originalObject,
+        pageIndex,
+        patch: finalPatch,
+        committed: false
+      });
+    };
+    if (!this.history) {
+      execute();
+      if (this.config.autoCommit !== false) {
+        this.commit(docId);
       }
-    },
-    hasPendingChanges: true
-  };
-};
-const initialState = (cfg) => {
-  const toolMap = /* @__PURE__ */ new Map();
-  defaultTools.forEach((t) => toolMap.set(t.id, t));
-  (cfg.tools || []).forEach((t) => toolMap.set(t.id, t));
-  return {
-    pages: {},
-    byUid: {},
-    selectedUid: null,
-    activeToolId: null,
-    // `Array.from(toolMap.values())` now correctly returns `AnnotationTool[]`, which matches the state's type.
-    tools: Array.from(toolMap.values()),
-    colorPresets: cfg.colorPresets ?? DEFAULT_COLORS,
-    hasPendingChanges: false
-  };
-};
-const reducer = (state, action) => {
-  switch (action.type) {
-    case SET_ANNOTATIONS: {
-      const newPages = { ...state.pages };
-      const newByUid = { ...state.byUid };
-      for (const [pgStr, list] of Object.entries(action.payload)) {
-        const pageIndex = Number(pgStr);
-        const oldUidsOnPage = state.pages[pageIndex] || [];
-        for (const uid of oldUidsOnPage) {
-          delete newByUid[uid];
-        }
-        const newUidsOnPage = list.map((a) => {
-          const uid = a.id;
-          newByUid[uid] = { commitState: "synced", object: a };
-          return uid;
+      return;
+    }
+    const originalPatch = Object.fromEntries(
+      Object.keys(patch).map((key) => [key, originalObject[key]])
+    );
+    const command = {
+      execute,
+      undo: () => {
+        this.dispatch(patchAnnotation(docId, pageIndex, id, originalPatch));
+        this.events$.emit({
+          type: "update",
+          documentId: docId,
+          annotation: originalObject,
+          pageIndex,
+          patch: originalPatch,
+          committed: false
         });
-        newPages[pageIndex] = newUidsOnPage;
       }
-      return { ...state, pages: newPages, byUid: newByUid };
-    }
-    case SET_ACTIVE_TOOL_ID:
-      return { ...state, activeToolId: action.payload };
-    case ADD_TOOL: {
-      const toolMap = new Map(state.tools.map((t) => [t.id, t]));
-      toolMap.set(action.payload.id, action.payload);
-      return { ...state, tools: Array.from(toolMap.values()) };
+    };
+    const historyScope = this.history.forDocument(docId);
+    historyScope.register(command, this.ANNOTATION_HISTORY_TOPIC);
+  }
+  deleteAnnotation(pageIndex, id, documentId) {
+    var _a;
+    const docId = documentId ?? this.getActiveDocumentId();
+    const docState = this.getDocumentState(docId);
+    const originalAnnotation = (_a = docState.byUid[id]) == null ? void 0 : _a.object;
+    if (!originalAnnotation) return;
+    const execute = () => {
+      this.dispatch(deselectAnnotation(docId));
+      this.dispatch(deleteAnnotation(docId, pageIndex, id));
+      this.events$.emit({
+        type: "delete",
+        documentId: docId,
+        annotation: originalAnnotation,
+        pageIndex,
+        committed: false
+      });
+    };
+    if (!this.history) {
+      execute();
+      if (this.config.autoCommit !== false) this.commit(docId);
+      return;
     }
-    case SET_TOOL_DEFAULTS: {
-      const { toolId, patch } = action.payload;
-      return {
-        ...state,
-        tools: state.tools.map((tool) => {
-          if (tool.id === toolId) {
-            return { ...tool, defaults: { ...tool.defaults, ...patch } };
-          }
-          return tool;
-        })
-      };
+    const command = {
+      execute,
+      undo: () => {
+        this.dispatch(createAnnotation(docId, pageIndex, originalAnnotation));
+        this.events$.emit({
+          type: "create",
+          documentId: docId,
+          annotation: originalAnnotation,
+          pageIndex,
+          committed: false
+        });
+      }
+    };
+    const historyScope = this.history.forDocument(docId);
+    historyScope.register(command, this.ANNOTATION_HISTORY_TOPIC);
+  }
+  selectAnnotation(pageIndex, id, documentId) {
+    const docId = documentId ?? this.getActiveDocumentId();
+    this.dispatch(selectAnnotation(docId, pageIndex, id));
+  }
+  deselectAnnotation(documentId) {
+    const docId = documentId ?? this.getActiveDocumentId();
+    this.dispatch(deselectAnnotation(docId));
+  }
+  getActiveTool(documentId) {
+    const docState = this.getDocumentState(documentId);
+    if (!docState.activeToolId) return null;
+    return this.state.tools.find((t) => t.id === docState.activeToolId) ?? null;
+  }
+  setActiveTool(toolId, documentId) {
+    var _a, _b;
+    const docId = documentId ?? this.getActiveDocumentId();
+    const docState = this.getDocumentState(docId);
+    if (toolId === docState.activeToolId) return;
+    this.dispatch(setActiveToolId(docId, toolId));
+    const tool = this.state.tools.find((t) => t.id === toolId);
+    if (tool) {
+      (_a = this.interactionManager) == null ? void 0 : _a.forDocument(docId).activate(tool.interaction.mode ?? tool.id);
+    } else {
+      (_b = this.interactionManager) == null ? void 0 : _b.forDocument(docId).activateDefaultMode();
     }
-    case SELECT_ANNOTATION:
-      return { ...state, selectedUid: action.payload.id };
-    case DESELECT_ANNOTATION:
-      return { ...state, selectedUid: null };
-    case ADD_COLOR_PRESET:
-      return state.colorPresets.includes(action.payload) ? state : { ...state, colorPresets: [...state.colorPresets, action.payload] };
-    case CREATE_ANNOTATION: {
-      const { pageIndex, annotation } = action.payload;
-      const uid = annotation.id;
-      return {
-        ...state,
-        pages: { ...state.pages, [pageIndex]: [...state.pages[pageIndex] ?? [], uid] },
-        byUid: { ...state.byUid, [uid]: { commitState: "new", object: annotation } },
-        hasPendingChanges: true
-      };
+  }
+  getTool(toolId) {
+    return this.state.tools.find((t) => t.id === toolId);
+  }
+  findToolForAnnotation(annotation) {
+    let bestTool = null;
+    let bestScore = 0;
+    for (const tool of this.state.tools) {
+      const score = tool.matchScore(annotation);
+      if (score > bestScore) {
+        bestScore = score;
+        bestTool = tool;
+      }
     }
-    case DELETE_ANNOTATION: {
-      const { pageIndex, id: uid } = action.payload;
-      if (!state.byUid[uid]) return state;
-      return {
-        ...state,
-        pages: {
-          ...state.pages,
-          [pageIndex]: (state.pages[pageIndex] ?? []).filter((u) => u !== uid)
-        },
-        byUid: {
-          ...state.byUid,
-          [uid]: { ...state.byUid[uid], commitState: "deleted" }
-        },
-        hasPendingChanges: true
-      };
+    return bestTool;
+  }
+  commit(documentId) {
+    const task = new Task();
+    const docId = documentId ?? this.getActiveDocumentId();
+    const docState = this.getDocumentState(docId);
+    if (!docState.hasPendingChanges) return PdfTaskHelper.resolve(true);
+    const coreDocState = this.getCoreDocument(docId);
+    const doc = coreDocState == null ? void 0 : coreDocState.document;
+    if (!doc)
+      return PdfTaskHelper.reject({ code: PdfErrorCode.NotFound, message: "Document not found" });
+    const contexts = this.pendingContexts.get(docId);
+    if (!contexts) return PdfTaskHelper.resolve(true);
+    const creations = [];
+    const updates = [];
+    const deletions = [];
+    for (const [uid, ta] of Object.entries(docState.byUid)) {
+      if (ta.commitState === "synced") continue;
+      const page = doc.pages.find((p) => p.index === ta.object.pageIndex);
+      if (!page) continue;
+      switch (ta.commitState) {
+        case "new":
+          const ctx = contexts.get(ta.object.id);
+          const task2 = this.engine.createPageAnnotation(doc, page, ta.object, ctx);
+          task2.wait(() => {
+            this.events$.emit({
+              type: "create",
+              documentId: docId,
+              annotation: ta.object,
+              pageIndex: ta.object.pageIndex,
+              ctx,
+              committed: true
+            });
+            contexts.delete(ta.object.id);
+          }, ignore);
+          creations.push(task2);
+          break;
+        case "dirty":
+          const updateTask = this.engine.updatePageAnnotation(doc, page, ta.object);
+          updateTask.wait(() => {
+            this.events$.emit({
+              type: "update",
+              documentId: docId,
+              annotation: ta.object,
+              pageIndex: ta.object.pageIndex,
+              patch: ta.object,
+              committed: true
+            });
+          }, ignore);
+          updates.push(updateTask);
+          break;
+        case "deleted":
+          deletions.push({ ta, uid });
+          break;
+      }
     }
-    case PATCH_ANNOTATION:
-      return patchAnno(state, action.payload.id, action.payload.patch);
-    case COMMIT_PENDING_CHANGES: {
-      const cleaned = {};
-      for (const [uid, ta] of Object.entries(state.byUid)) {
-        cleaned[uid] = {
-          ...ta,
-          commitState: ta.commitState === "dirty" || ta.commitState === "new" ? "synced" : ta.commitState
-        };
+    const deletionTasks = [];
+    for (const { ta, uid } of deletions) {
+      const page = doc.pages.find((p) => p.index === ta.object.pageIndex);
+      if (ta.commitState === "deleted" && ta.object.id) {
+        const task2 = new Task();
+        const removeTask = this.engine.removePageAnnotation(doc, page, ta.object);
+        removeTask.wait(() => {
+          this.dispatch(purgeAnnotation(docId, uid));
+          this.events$.emit({
+            type: "delete",
+            documentId: docId,
+            annotation: ta.object,
+            pageIndex: ta.object.pageIndex,
+            committed: true
+          });
+          task2.resolve(true);
+        }, task2.fail);
+        deletionTasks.push(task2);
+      } else {
+        this.dispatch(purgeAnnotation(docId, uid));
       }
-      return { ...state, byUid: cleaned, hasPendingChanges: false };
     }
-    case PURGE_ANNOTATION: {
-      const { uid } = action.payload;
-      const { [uid]: _gone, ...rest } = state.byUid;
-      return { ...state, byUid: rest };
+    const allWriteTasks = [...creations, ...updates, ...deletionTasks];
+    Task.allSettled(allWriteTasks).wait(() => {
+      this.dispatch(commitPendingChanges(docId));
+      task.resolve(true);
+    }, task.fail);
+    return task;
+  }
+  /**
+   * Gets the effective behavior setting for a tool, checking tool-specific config first,
+   * then falling back to plugin config.
+   */
+  getToolBehavior(tool, setting) {
+    var _a;
+    if (((_a = tool.behavior) == null ? void 0 : _a[setting]) !== void 0) {
+      return tool.behavior[setting];
     }
-    default:
-      return state;
+    return this.config[setting] !== false;
   }
 };
+_AnnotationPlugin.id = "annotation";
+let AnnotationPlugin = _AnnotationPlugin;
 function createToolPredicate(id) {
   return (tool) => {
     return (tool == null ? void 0 : tool.id) === id;
@@ -2597,6 +2911,7 @@ export {
   AnnotationPlugin,
   AnnotationPluginPackage,
   createToolPredicate,
+  getAnnotationByUid,
   getAnnotations,
   getAnnotationsByPageIndex,
   getSelectedAnnotation,
@@ -2604,6 +2919,7 @@ export {
   getSidebarAnnotationsWithReplies,
   getSidebarAnnotationsWithRepliesGroupedByPage,
   getToolDefaultsById,
+  initialDocumentState,
   initialState,
   isAnnotationSelected,
   isCircle,