@embedpdf/plugin-annotation 2.2.0 → 2.4.0

package/dist/index.js

@@ -1,5 +1,5 @@
 import { clamp, BasePlugin, createBehaviorEmitter } from "@embedpdf/core";
-import { PdfAnnotationSubtype, PdfBlendMode, PdfAnnotationBorderStyle, PdfAnnotationLineEnding, PdfVerticalAlignment, PdfTextAlignment, PdfStandardFont, expandRect, rectFromPoints, uuidV4, rotateAndTranslatePoint, PdfAnnotationIcon, PdfPermissionFlag, ignore, PdfTaskHelper, PdfErrorCode, Task } from "@embedpdf/models";
+import { PdfAnnotationSubtype, PdfAnnotationReplyType, PdfBlendMode, PdfAnnotationBorderStyle, PdfAnnotationLineEnding, PdfVerticalAlignment, PdfTextAlignment, PdfStandardFont, expandRect, rectFromPoints, uuidV4, rotateAndTranslatePoint, PdfAnnotationIcon, PdfPermissionFlag, ignore, PdfTaskHelper, PdfErrorCode, Task, TaskStage } from "@embedpdf/models";
 const ANNOTATION_PLUGIN_ID = "annotation";
 const manifest = {
   id: ANNOTATION_PLUGIN_ID,
@@ -21,6 +21,9 @@ 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_TO_SELECTION = "ANNOTATION/ADD_TO_SELECTION";
+const REMOVE_FROM_SELECTION = "ANNOTATION/REMOVE_FROM_SELECTION";
+const SET_SELECTION = "ANNOTATION/SET_SELECTION";
 const SET_ACTIVE_TOOL_ID = "ANNOTATION/SET_ACTIVE_TOOL_ID";
 const CREATE_ANNOTATION = "ANNOTATION/CREATE_ANNOTATION";
 const PATCH_ANNOTATION = "ANNOTATION/PATCH_ANNOTATION";
@@ -48,6 +51,18 @@ const deselectAnnotation = (documentId) => ({
   type: DESELECT_ANNOTATION,
   payload: { documentId }
 });
+const addToSelection = (documentId, pageIndex, id) => ({
+  type: ADD_TO_SELECTION,
+  payload: { documentId, pageIndex, id }
+});
+const removeFromSelection = (documentId, id) => ({
+  type: REMOVE_FROM_SELECTION,
+  payload: { documentId, id }
+});
+const setSelection = (documentId, ids) => ({
+  type: SET_SELECTION,
+  payload: { documentId, ids }
+});
 const setActiveToolId = (documentId, toolId) => ({
   type: SET_ACTIVE_TOOL_ID,
   payload: { documentId, toolId }
@@ -64,13 +79,13 @@ const deleteAnnotation = (documentId, pageIndex, id) => ({
   type: DELETE_ANNOTATION,
   payload: { documentId, pageIndex, id }
 });
-const commitPendingChanges = (documentId) => ({
+const commitPendingChanges = (documentId, committedUids) => ({
   type: COMMIT_PENDING_CHANGES,
-  payload: { documentId }
+  payload: { documentId, committedUids }
 });
-const purgeAnnotation = (documentId, uid) => ({
+const purgeAnnotation = (documentId, pageIndex, uid) => ({
   type: PURGE_ANNOTATION,
-  payload: { documentId, uid }
+  payload: { documentId, pageIndex, uid }
 });
 const addColorPreset = (c) => ({
   type: ADD_COLOR_PRESET,
@@ -84,6 +99,9 @@ const addTool = (tool) => ({
   type: ADD_TOOL,
   payload: tool
 });
+function rectsIntersect(a, b) {
+  return !(a.origin.x + a.size.width < b.origin.x || b.origin.x + b.size.width < a.origin.x || a.origin.y + a.size.height < b.origin.y || b.origin.y + b.size.height < a.origin.y);
+}
 function isInk(a) {
   return a.object.type === PdfAnnotationSubtype.INK;
 }
@@ -126,8 +144,14 @@ function isStamp(a) {
 function isText(a) {
   return a.object.type === PdfAnnotationSubtype.TEXT;
 }
+function isLink(a) {
+  return a.object.type === PdfAnnotationSubtype.LINK;
+}
+function isRedact(a) {
+  return a.object.type === PdfAnnotationSubtype.REDACT;
+}
 function isSidebarAnnotation(a) {
-  return isTextMarkup(a) || isInk(a) || isSquare(a) || isCircle(a) || isPolygon(a) || isLine(a) || isPolyline(a) || isFreeText(a) || isStamp(a);
+  return isTextMarkup(a) || isInk(a) || isSquare(a) || isCircle(a) || isPolygon(a) || isLine(a) || isPolyline(a) || isFreeText(a) || isStamp(a) || isRedact(a);
 }
 const getAnnotationsByPageIndex = (s, page) => (s.pages[page] ?? []).map((uid) => s.byUid[uid]);
 const getAnnotations = (s) => {
@@ -135,17 +159,25 @@ const getAnnotations = (s) => {
   for (const p of Object.keys(s.pages).map(Number)) out[p] = getAnnotationsByPageIndex(s, p);
   return out;
 };
-const getSelectedAnnotation = (s) => s.selectedUid ? s.byUid[s.selectedUid] : null;
+const getSelectedAnnotation = (s) => s.selectedUids.length > 0 ? s.byUid[s.selectedUids[0]] ?? null : null;
+const getSelectedAnnotations = (s) => s.selectedUids.map((uid) => s.byUid[uid]).filter((ta) => ta !== void 0);
+const getSelectedAnnotationIds = (s) => s.selectedUids;
 const getAnnotationByUid = (s, uid) => s.byUid[uid] ?? null;
 const getSelectedAnnotationByPageIndex = (s, pageIndex) => {
-  if (!s.selectedUid) return null;
   const pageUids = s.pages[pageIndex] ?? [];
-  if (pageUids.includes(s.selectedUid)) {
-    return s.byUid[s.selectedUid];
+  for (const uid of s.selectedUids) {
+    if (pageUids.includes(uid)) {
+      return s.byUid[uid] ?? null;
+    }
   }
   return null;
 };
-const isAnnotationSelected = (s, id) => s.selectedUid === id;
+const getSelectedAnnotationsByPageIndex = (s, pageIndex) => {
+  const pageUids = new Set(s.pages[pageIndex] ?? []);
+  return s.selectedUids.filter((uid) => pageUids.has(uid)).map((uid) => s.byUid[uid]).filter((ta) => ta !== void 0);
+};
+const isAnnotationSelected = (s, id) => s.selectedUids.includes(id);
+const hasMultipleSelected = (s) => s.selectedUids.length > 1;
 function getToolDefaultsById(state, toolId) {
   const tool = state.tools.find((t) => t.id === toolId);
   return tool == null ? void 0 : tool.defaults;
@@ -190,6 +222,101 @@ const getSidebarAnnotationsWithReplies = (s) => {
   }
   return out;
 };
+const getIRTChildIds = (s, parentId) => {
+  const children = [];
+  for (const uidList of Object.values(s.pages)) {
+    for (const uid of uidList) {
+      const ta = s.byUid[uid];
+      if (ta && "inReplyToId" in ta.object && ta.object.inReplyToId === parentId) {
+        children.push({ id: ta.object.id, pageIndex: ta.object.pageIndex });
+      }
+    }
+  }
+  return children;
+};
+const hasIRTChildren = (s, parentId) => {
+  for (const uidList of Object.values(s.pages)) {
+    for (const uid of uidList) {
+      const ta = s.byUid[uid];
+      if (ta && "inReplyToId" in ta.object && ta.object.inReplyToId === parentId) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+const getIRTChildrenByType = (s, parentId, types) => {
+  const children = [];
+  for (const uidList of Object.values(s.pages)) {
+    for (const uid of uidList) {
+      const ta = s.byUid[uid];
+      if (ta && "inReplyToId" in ta.object && ta.object.inReplyToId === parentId && types.includes(ta.object.type)) {
+        children.push(ta);
+      }
+    }
+  }
+  return children;
+};
+const getAttachedLinks = (s, parentId) => getIRTChildrenByType(s, parentId, [PdfAnnotationSubtype.LINK]);
+const hasAttachedLinks = (s, parentId) => getAttachedLinks(s, parentId).length > 0;
+const getGroupLeaderId = (s, annotationId) => {
+  const ta = s.byUid[annotationId];
+  if (!ta) return void 0;
+  if (ta.object.inReplyToId && ta.object.replyType === PdfAnnotationReplyType.Group) {
+    return ta.object.inReplyToId;
+  }
+  return annotationId;
+};
+const getGroupMembers = (s, annotationId) => {
+  const leaderId = getGroupLeaderId(s, annotationId);
+  if (!leaderId) return [];
+  const members = [];
+  const leader = s.byUid[leaderId];
+  if (leader && leader.object.type !== PdfAnnotationSubtype.LINK) {
+    members.push(leader);
+  }
+  for (const uidList of Object.values(s.pages)) {
+    for (const uid of uidList) {
+      const ta = s.byUid[uid];
+      if (ta && ta.object.inReplyToId === leaderId && ta.object.replyType === PdfAnnotationReplyType.Group && ta.object.type !== PdfAnnotationSubtype.LINK) {
+        members.push(ta);
+      }
+    }
+  }
+  return members;
+};
+const isInGroup = (s, annotationId) => {
+  const ta = s.byUid[annotationId];
+  if (!ta) return false;
+  if (ta.object.type === PdfAnnotationSubtype.LINK) {
+    return false;
+  }
+  if (ta.object.inReplyToId && ta.object.replyType === PdfAnnotationReplyType.Group) {
+    return true;
+  }
+  for (const uidList of Object.values(s.pages)) {
+    for (const uid of uidList) {
+      const other = s.byUid[uid];
+      if (other && other.object.inReplyToId === annotationId && other.object.replyType === PdfAnnotationReplyType.Group && other.object.type !== PdfAnnotationSubtype.LINK) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+const getSelectionGroupingAction = (s) => {
+  const selected = getSelectedAnnotations(s);
+  if (selected.length === 0) return "disabled";
+  const firstId = selected[0].object.id;
+  if (isInGroup(s, firstId)) {
+    const members = getGroupMembers(s, firstId);
+    const memberIds = new Set(members.map((m) => m.object.id));
+    if (selected.every((ta) => memberIds.has(ta.object.id))) {
+      return "ungroup";
+    }
+  }
+  return selected.length >= 2 ? "group" : "disabled";
+};
 const defaultTools = [
   // Text Markup Tools
   {
@@ -200,11 +327,16 @@ const defaultTools = [
       exclusive: false,
       textSelection: true,
       isDraggable: false,
-      isResizable: false
+      isResizable: false,
+      // Text markup annotations are anchored to text and should not move/resize in groups
+      isGroupDraggable: false,
+      isGroupResizable: false
     },
     defaults: {
       type: PdfAnnotationSubtype.HIGHLIGHT,
+      strokeColor: "#FFCD45",
       color: "#FFCD45",
+      // deprecated alias
       opacity: 1,
       blendMode: PdfBlendMode.Multiply
     }
@@ -217,11 +349,15 @@ const defaultTools = [
       exclusive: false,
       textSelection: true,
       isDraggable: false,
-      isResizable: false
+      isResizable: false,
+      isGroupDraggable: false,
+      isGroupResizable: false
     },
     defaults: {
       type: PdfAnnotationSubtype.UNDERLINE,
+      strokeColor: "#E44234",
       color: "#E44234",
+      // deprecated alias
       opacity: 1
     }
   },
@@ -231,11 +367,17 @@ const defaultTools = [
     matchScore: (a) => a.type === PdfAnnotationSubtype.STRIKEOUT ? 1 : 0,
     interaction: {
       exclusive: false,
-      textSelection: true
+      textSelection: true,
+      isDraggable: false,
+      isResizable: false,
+      isGroupDraggable: false,
+      isGroupResizable: false
     },
     defaults: {
       type: PdfAnnotationSubtype.STRIKEOUT,
+      strokeColor: "#E44234",
       color: "#E44234",
+      // deprecated alias
       opacity: 1
     }
   },
@@ -247,11 +389,15 @@ const defaultTools = [
       exclusive: false,
       textSelection: true,
       isDraggable: false,
-      isResizable: false
+      isResizable: false,
+      isGroupDraggable: false,
+      isGroupResizable: false
     },
     defaults: {
       type: PdfAnnotationSubtype.SQUIGGLY,
+      strokeColor: "#E44234",
       color: "#E44234",
+      // deprecated alias
       opacity: 1
     }
   },
@@ -269,7 +415,9 @@ const defaultTools = [
     },
     defaults: {
       type: PdfAnnotationSubtype.INK,
+      strokeColor: "#E44234",
       color: "#E44234",
+      // deprecated alias
       opacity: 1,
       strokeWidth: 6
     }
@@ -288,7 +436,9 @@ const defaultTools = [
     defaults: {
       type: PdfAnnotationSubtype.INK,
       intent: "InkHighlight",
+      strokeColor: "#FFCD45",
       color: "#FFCD45",
+      // deprecated alias
       opacity: 1,
       strokeWidth: 14,
       blendMode: PdfBlendMode.Multiply
@@ -352,7 +502,10 @@ const defaultTools = [
       cursor: "crosshair",
       isDraggable: true,
       isResizable: false,
-      lockAspectRatio: false
+      // Uses vertex editing when selected individually
+      lockAspectRatio: false,
+      isGroupResizable: true
+      // Scales proportionally in a group
     },
     defaults: {
       type: PdfAnnotationSubtype.LINE,
@@ -376,7 +529,10 @@ const defaultTools = [
       cursor: "crosshair",
       isDraggable: true,
       isResizable: false,
-      lockAspectRatio: false
+      // Uses vertex editing when selected individually
+      lockAspectRatio: false,
+      isGroupResizable: true
+      // Scales proportionally in a group
     },
     defaults: {
       type: PdfAnnotationSubtype.LINE,
@@ -405,7 +561,10 @@ const defaultTools = [
       cursor: "crosshair",
       isDraggable: true,
       isResizable: false,
-      lockAspectRatio: false
+      // Uses vertex editing when selected individually
+      lockAspectRatio: false,
+      isGroupResizable: true
+      // Scales proportionally in a group
     },
     defaults: {
       type: PdfAnnotationSubtype.POLYLINE,
@@ -424,7 +583,10 @@ const defaultTools = [
       cursor: "crosshair",
       isDraggable: true,
       isResizable: false,
-      lockAspectRatio: false
+      // Uses vertex editing when selected individually
+      lockAspectRatio: false,
+      isGroupResizable: true
+      // Scales proportionally in a group
     },
     defaults: {
       type: PdfAnnotationSubtype.POLYGON,
@@ -454,7 +616,10 @@ const defaultTools = [
       fontFamily: PdfStandardFont.Helvetica,
       textAlign: PdfTextAlignment.Left,
       verticalAlign: PdfVerticalAlignment.Top,
+      color: "transparent",
+      // fill color (matches shape convention)
       backgroundColor: "transparent",
+      // deprecated alias
       opacity: 1
     },
     clickBehavior: {
@@ -492,9 +657,11 @@ const DEFAULT_COLORS = [
   "#000000",
   "#FFFFFF"
 ];
+const computeSelectedUid = (selectedUids) => selectedUids.length === 1 ? selectedUids[0] : null;
 const initialDocumentState = () => ({
   pages: {},
   byUid: {},
+  selectedUids: [],
   selectedUid: null,
   activeToolId: null,
   hasPendingChanges: false
@@ -595,7 +762,7 @@ const reducer = (state, action) => {
         ...state,
         documents: {
           ...state.documents,
-          [documentId]: { ...docState, selectedUid: id }
+          [documentId]: { ...docState, selectedUids: [id], selectedUid: id }
         }
       };
     }
@@ -607,7 +774,58 @@ const reducer = (state, action) => {
         ...state,
         documents: {
           ...state.documents,
-          [documentId]: { ...docState, selectedUid: null }
+          [documentId]: { ...docState, selectedUids: [], selectedUid: null }
+        }
+      };
+    }
+    case ADD_TO_SELECTION: {
+      const { documentId, id } = action.payload;
+      const docState = state.documents[documentId];
+      if (!docState) return state;
+      if (docState.selectedUids.includes(id)) return state;
+      const newSelectedUids = [...docState.selectedUids, id];
+      return {
+        ...state,
+        documents: {
+          ...state.documents,
+          [documentId]: {
+            ...docState,
+            selectedUids: newSelectedUids,
+            selectedUid: computeSelectedUid(newSelectedUids)
+          }
+        }
+      };
+    }
+    case REMOVE_FROM_SELECTION: {
+      const { documentId, id } = action.payload;
+      const docState = state.documents[documentId];
+      if (!docState) return state;
+      const newSelectedUids = docState.selectedUids.filter((uid) => uid !== id);
+      return {
+        ...state,
+        documents: {
+          ...state.documents,
+          [documentId]: {
+            ...docState,
+            selectedUids: newSelectedUids,
+            selectedUid: computeSelectedUid(newSelectedUids)
+          }
+        }
+      };
+    }
+    case SET_SELECTION: {
+      const { documentId, ids } = action.payload;
+      const docState = state.documents[documentId];
+      if (!docState) return state;
+      return {
+        ...state,
+        documents: {
+          ...state.documents,
+          [documentId]: {
+            ...docState,
+            selectedUids: ids,
+            selectedUid: computeSelectedUid(ids)
+          }
         }
       };
     }
@@ -683,34 +901,50 @@ const reducer = (state, action) => {
       };
     }
     case COMMIT_PENDING_CHANGES: {
-      const { documentId } = action.payload;
+      const { documentId, committedUids } = action.payload;
       const docState = state.documents[documentId];
       if (!docState) return state;
+      const committedSet = new Set(committedUids);
       const cleaned = {};
+      let stillHasPending = false;
       for (const [uid, ta] of Object.entries(docState.byUid)) {
-        cleaned[uid] = {
-          ...ta,
-          commitState: ta.commitState === "dirty" || ta.commitState === "new" ? "synced" : ta.commitState
-        };
+        if (committedSet.has(uid)) {
+          cleaned[uid] = {
+            ...ta,
+            commitState: ta.commitState === "dirty" || ta.commitState === "new" ? "synced" : ta.commitState
+          };
+        } else {
+          cleaned[uid] = ta;
+          if (ta.commitState === "new" || ta.commitState === "dirty" || ta.commitState === "deleted") {
+            stillHasPending = true;
+          }
+        }
       }
       return {
         ...state,
         documents: {
           ...state.documents,
-          [documentId]: { ...docState, byUid: cleaned, hasPendingChanges: false }
+          [documentId]: { ...docState, byUid: cleaned, hasPendingChanges: stillHasPending }
         }
       };
     }
     case PURGE_ANNOTATION: {
-      const { documentId, uid } = action.payload;
+      const { documentId, pageIndex, uid } = action.payload;
       const docState = state.documents[documentId];
-      if (!docState) return state;
+      if (!docState || !docState.byUid[uid]) return state;
       const { [uid]: _gone, ...rest } = docState.byUid;
       return {
         ...state,
         documents: {
           ...state.documents,
-          [documentId]: { ...docState, byUid: rest }
+          [documentId]: {
+            ...docState,
+            pages: {
+              ...docState.pages,
+              [pageIndex]: (docState.pages[pageIndex] ?? []).filter((u) => u !== uid)
+            },
+            byUid: rest
+          }
         }
       };
     }
@@ -763,7 +997,7 @@ const inkHandlerFactory = {
       return {
         ...tool.defaults,
         strokeWidth: tool.defaults.strokeWidth ?? 1,
-        color: tool.defaults.color ?? "#000000",
+        strokeColor: tool.defaults.strokeColor ?? tool.defaults.color ?? "#000000",
         opacity: tool.defaults.opacity ?? 1,
         flags: tool.defaults.flags ?? ["print"]
       };
@@ -899,7 +1133,7 @@ const freeTextHandlerFactory = {
         opacity: tool.defaults.opacity ?? 1,
         fontSize: tool.defaults.fontSize ?? 12,
         fontFamily: tool.defaults.fontFamily ?? PdfStandardFont.Helvetica,
-        backgroundColor: tool.defaults.backgroundColor ?? "transparent",
+        color: tool.defaults.color ?? tool.defaults.backgroundColor ?? "transparent",
         textAlign: tool.defaults.textAlign ?? PdfTextAlignment.Left,
         verticalAlign: tool.defaults.verticalAlign ?? PdfVerticalAlignment.Top,
         contents: tool.defaults.contents ?? "Insert text here",
@@ -1435,7 +1669,10 @@ const polylineHandlerFactory = {
       };
     };
     return {
-      onClick: (pos) => {
+      onClick: (pos, evt) => {
+        if (evt.metaKey || evt.ctrlKey) {
+          return;
+        }
         const clampedPos = clampToPage(pos);
         const vertices = getVertices();
         const lastVertex = vertices[vertices.length - 1];
@@ -1537,7 +1774,10 @@ const polygonHandlerFactory = {
       };
     };
     return {
-      onClick: (pos) => {
+      onClick: (pos, evt) => {
+        if (evt.metaKey || evt.ctrlKey) {
+          return;
+        }
         const clampedPos = clampToPage(pos);
         if (isInsideStartHandle(clampedPos) && getVertices().length >= 3) {
           commitPolygon();
@@ -2234,11 +2474,16 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
     this.pendingContexts = /* @__PURE__ */ new Map();
     this.isInitialLoadComplete = /* @__PURE__ */ new Map();
     this.importQueue = /* @__PURE__ */ new Map();
+    this.commitInProgress = /* @__PURE__ */ new Map();
     this.handlerFactories = /* @__PURE__ */ new Map();
     this.activeTool$ = createBehaviorEmitter();
     this.events$ = createBehaviorEmitter();
     this.toolsChange$ = createBehaviorEmitter();
     this.patchRegistry = new PatchRegistry();
+    this.unifiedDragStates = /* @__PURE__ */ new Map();
+    this.unifiedDrag$ = createBehaviorEmitter();
+    this.unifiedResizeStates = /* @__PURE__ */ new Map();
+    this.unifiedResize$ = createBehaviorEmitter();
     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;
@@ -2268,7 +2513,7 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
     if (this.selection) {
       for (const tool of this.state.tools) {
         if (tool.interaction.textSelection) {
-          this.selection.enableForMode(tool.interaction.mode ?? tool.id);
+          this.selection.enableForMode(tool.interaction.mode ?? tool.id, { showRects: false });
         }
       }
     }
@@ -2301,7 +2546,7 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
     this.patchRegistry.register(PdfAnnotationSubtype.POLYGON, patchPolygon);
   }
   async initialize() {
-    var _a, _b;
+    var _a, _b, _c;
     this.state.tools.forEach((tool) => this.registerInteractionForTool(tool));
     if (this.history) {
       this.history.onHistoryChange((event) => {
@@ -2318,8 +2563,28 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
         this.dispatch(setActiveToolId(s.documentId, newToolId));
       }
     });
-    (_b = this.selection) == null ? void 0 : _b.onEndSelection(({ documentId }) => {
-      var _a2, _b2, _c;
+    (_b = this.selection) == null ? void 0 : _b.onMarqueeEnd(({ documentId, pageIndex, rect }) => {
+      const docState = this.state.documents[documentId];
+      if (!docState) return;
+      const pageAnnotations = (docState.pages[pageIndex] ?? []).map((uid) => docState.byUid[uid]).filter((ta) => ta !== void 0).filter((ta) => !isLink(ta));
+      const selectedIds = pageAnnotations.filter((ta) => rectsIntersect(rect, ta.object.rect)).map((ta) => ta.object.id);
+      if (selectedIds.length > 0) {
+        const expandedIds = /* @__PURE__ */ new Set();
+        for (const id of selectedIds) {
+          if (this.isInGroupMethod(id, documentId)) {
+            const members = this.getGroupMembersMethod(id, documentId);
+            for (const member of members) {
+              expandedIds.add(member.object.id);
+            }
+          } else {
+            expandedIds.add(id);
+          }
+        }
+        this.setSelectionMethod([...expandedIds], documentId);
+      }
+    });
+    (_c = this.selection) == null ? void 0 : _c.onEndSelection(({ documentId }) => {
+      var _a2, _b2, _c2;
       if (!this.checkPermission(documentId, PdfPermissionFlag.ModifyAnnotations)) {
         return;
       }
@@ -2355,7 +2620,7 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
           }
         }, ignore);
       }
-      (_c = this.selection) == null ? void 0 : _c.clear();
+      (_c2 = this.selection) == null ? void 0 : _c2.clear();
     });
   }
   registerInteractionForTool(tool) {
@@ -2375,15 +2640,33 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
       getState: () => this.getDocumentState(),
       getPageAnnotations: (options) => this.getPageAnnotations(options),
       getSelectedAnnotation: () => this.getSelectedAnnotation(),
+      getSelectedAnnotations: () => this.getSelectedAnnotationsMethod(),
+      getSelectedAnnotationIds: () => this.getSelectedAnnotationIdsMethod(),
       getAnnotationById: (id) => this.getAnnotationById(id),
       selectAnnotation: (pageIndex, id) => this.selectAnnotation(pageIndex, id),
+      toggleSelection: (pageIndex, id) => this.toggleSelectionMethod(pageIndex, id),
+      addToSelection: (pageIndex, id) => this.addToSelectionMethod(pageIndex, id),
+      removeFromSelection: (id) => this.removeFromSelectionMethod(id),
+      setSelection: (ids) => this.setSelectionMethod(ids),
       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),
+      updateAnnotations: (patches) => this.updateAnnotationsMethod(patches),
       deleteAnnotation: (pageIndex, id) => this.deleteAnnotation(pageIndex, id),
+      deleteAnnotations: (annotations, documentId) => this.deleteAnnotationsMethod(annotations, documentId),
+      purgeAnnotation: (pageIndex, id, documentId) => this.purgeAnnotationMethod(pageIndex, id, documentId),
       renderAnnotation: (options) => this.renderAnnotation(options),
       commit: () => this.commit(),
+      // Attached links (IRT link children)
+      getAttachedLinks: (id, documentId) => this.getAttachedLinksMethod(id, documentId),
+      hasAttachedLinks: (id, documentId) => this.hasAttachedLinksMethod(id, documentId),
+      deleteAttachedLinks: (id, documentId) => this.deleteAttachedLinksMethod(id, documentId),
+      // Annotation grouping (RT = Group)
+      groupAnnotations: (documentId) => this.groupAnnotationsMethod(documentId),
+      ungroupAnnotations: (id, documentId) => this.ungroupAnnotationsMethod(id, documentId),
+      getGroupMembers: (id, documentId) => this.getGroupMembersMethod(id, documentId),
+      isInGroup: (id, documentId) => this.isInGroupMethod(id, documentId),
       // Document-scoped operations
       forDocument: (documentId) => this.createAnnotationScope(documentId),
       // Global operations
@@ -2414,8 +2697,14 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
       getState: () => this.getDocumentState(documentId),
       getPageAnnotations: (options) => this.getPageAnnotations(options, documentId),
       getSelectedAnnotation: () => this.getSelectedAnnotation(documentId),
+      getSelectedAnnotations: () => this.getSelectedAnnotationsMethod(documentId),
+      getSelectedAnnotationIds: () => this.getSelectedAnnotationIdsMethod(documentId),
       getAnnotationById: (id) => this.getAnnotationById(id, documentId),
       selectAnnotation: (pageIndex, id) => this.selectAnnotation(pageIndex, id, documentId),
+      toggleSelection: (pageIndex, id) => this.toggleSelectionMethod(pageIndex, id, documentId),
+      addToSelection: (pageIndex, id) => this.addToSelectionMethod(pageIndex, id, documentId),
+      removeFromSelection: (id) => this.removeFromSelectionMethod(id, documentId),
+      setSelection: (ids) => this.setSelectionMethod(ids, documentId),
       deselectAnnotation: () => this.deselectAnnotation(documentId),
       getActiveTool: () => this.getActiveTool(documentId),
       setActiveTool: (toolId) => this.setActiveTool(toolId, documentId),
@@ -2423,9 +2712,20 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
       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),
+      updateAnnotations: (patches) => this.updateAnnotationsMethod(patches, documentId),
       deleteAnnotation: (pageIndex, id) => this.deleteAnnotation(pageIndex, id, documentId),
+      deleteAnnotations: (annotations) => this.deleteAnnotationsMethod(annotations, documentId),
+      purgeAnnotation: (pageIndex, id) => this.purgeAnnotationMethod(pageIndex, id, documentId),
       renderAnnotation: (options) => this.renderAnnotation(options, documentId),
       commit: () => this.commit(documentId),
+      getAttachedLinks: (id) => this.getAttachedLinksMethod(id, documentId),
+      hasAttachedLinks: (id) => this.hasAttachedLinksMethod(id, documentId),
+      deleteAttachedLinks: (id) => this.deleteAttachedLinksMethod(id, documentId),
+      groupAnnotations: () => this.groupAnnotationsMethod(documentId),
+      ungroupAnnotations: (id) => this.ungroupAnnotationsMethod(id, documentId),
+      getGroupMembers: (id) => this.getGroupMembersMethod(id, documentId),
+      isInGroup: (id) => this.isInGroupMethod(id, documentId),
+      getGroupingAction: () => this.getGroupingActionMethod(documentId),
       onStateChange: (listener) => this.state$.on((event) => {
         if (event.documentId === documentId) listener(event.state);
       }),
@@ -2658,7 +2958,8 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
           pageIndex,
           committed: false
         });
-      }
+      },
+      metadata: { annotationIds: [id] }
     };
     const historyScope = this.history.forDocument(docId);
     historyScope.register(command, this.ANNOTATION_HISTORY_TOPIC);
@@ -2719,7 +3020,8 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
           patch: originalPatch,
           committed: false
         });
-      }
+      },
+      metadata: { annotationIds: [id] }
     };
     const historyScope = this.history.forDocument(docId);
     historyScope.register(command, this.ANNOTATION_HISTORY_TOPIC);
@@ -2738,7 +3040,26 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
     const docState = this.getDocumentState(docId);
     const originalAnnotation = (_a = docState.byUid[id]) == null ? void 0 : _a.object;
     if (!originalAnnotation) return;
+    const irtChildren = getIRTChildIds(docState, id);
+    const childAnnotations = irtChildren.map((child) => {
+      var _a2;
+      return (_a2 = docState.byUid[child.id]) == null ? void 0 : _a2.object;
+    }).filter((obj) => obj !== void 0);
     const execute = () => {
+      var _a2;
+      for (const child of irtChildren) {
+        const childObj = (_a2 = docState.byUid[child.id]) == null ? void 0 : _a2.object;
+        if (childObj) {
+          this.dispatch(deleteAnnotation(docId, child.pageIndex, child.id));
+          this.events$.emit({
+            type: "delete",
+            documentId: docId,
+            annotation: childObj,
+            pageIndex: child.pageIndex,
+            committed: false
+          });
+        }
+      }
       this.dispatch(deselectAnnotation(docId));
       this.dispatch(deleteAnnotation(docId, pageIndex, id));
       this.events$.emit({
@@ -2765,19 +3086,709 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
           pageIndex,
           committed: false
         });
-      }
+        for (const childObj of childAnnotations) {
+          this.dispatch(createAnnotation(docId, childObj.pageIndex, childObj));
+          this.events$.emit({
+            type: "create",
+            documentId: docId,
+            annotation: childObj,
+            pageIndex: childObj.pageIndex,
+            committed: false
+          });
+        }
+      },
+      metadata: { annotationIds: [id, ...irtChildren.map((c) => c.id)] }
     };
     const historyScope = this.history.forDocument(docId);
     historyScope.register(command, this.ANNOTATION_HISTORY_TOPIC);
   }
+  deleteAnnotationsMethod(annotations, documentId) {
+    for (const { pageIndex, id } of annotations) {
+      this.deleteAnnotation(pageIndex, id, documentId);
+    }
+  }
+  purgeAnnotationMethod(pageIndex, id, documentId) {
+    const docId = documentId ?? this.getActiveDocumentId();
+    this.dispatch(purgeAnnotation(docId, pageIndex, id));
+  }
   selectAnnotation(pageIndex, id, documentId) {
     const docId = documentId ?? this.getActiveDocumentId();
-    this.dispatch(selectAnnotation(docId, pageIndex, id));
+    if (this.isInGroupMethod(id, docId)) {
+      const members = this.getGroupMembersMethod(id, docId);
+      const memberIds = members.map((m) => m.object.id);
+      this.dispatch(setSelection(docId, memberIds));
+    } else {
+      this.dispatch(selectAnnotation(docId, pageIndex, id));
+    }
   }
   deselectAnnotation(documentId) {
     const docId = documentId ?? this.getActiveDocumentId();
     this.dispatch(deselectAnnotation(docId));
   }
+  // ─────────────────────────────────────────────────────────
+  // Multi-Select Methods
+  // ─────────────────────────────────────────────────────────
+  getSelectedAnnotationsMethod(documentId) {
+    return getSelectedAnnotations(this.getDocumentState(documentId));
+  }
+  getSelectedAnnotationIdsMethod(documentId) {
+    return getSelectedAnnotationIds(this.getDocumentState(documentId));
+  }
+  toggleSelectionMethod(pageIndex, id, documentId) {
+    const docId = documentId ?? this.getActiveDocumentId();
+    const docState = this.getDocumentState(docId);
+    if (docState.selectedUids.includes(id)) {
+      this.dispatch(removeFromSelection(docId, id));
+    } else {
+      if (this.isInGroupMethod(id, docId)) {
+        const members = this.getGroupMembersMethod(id, docId);
+        for (const member of members) {
+          if (!docState.selectedUids.includes(member.object.id)) {
+            this.dispatch(addToSelection(docId, member.object.pageIndex, member.object.id));
+          }
+        }
+      } else {
+        this.dispatch(addToSelection(docId, pageIndex, id));
+      }
+    }
+  }
+  addToSelectionMethod(pageIndex, id, documentId) {
+    const docId = documentId ?? this.getActiveDocumentId();
+    this.dispatch(addToSelection(docId, pageIndex, id));
+  }
+  removeFromSelectionMethod(id, documentId) {
+    const docId = documentId ?? this.getActiveDocumentId();
+    this.dispatch(removeFromSelection(docId, id));
+  }
+  setSelectionMethod(ids, documentId) {
+    const docId = documentId ?? this.getActiveDocumentId();
+    this.dispatch(setSelection(docId, ids));
+  }
+  // ─────────────────────────────────────────────────────────
+  // Attached Links Methods
+  // ─────────────────────────────────────────────────────────
+  getAttachedLinksMethod(annotationId, documentId) {
+    return getAttachedLinks(this.getDocumentState(documentId), annotationId);
+  }
+  hasAttachedLinksMethod(annotationId, documentId) {
+    return this.getAttachedLinksMethod(annotationId, documentId).length > 0;
+  }
+  deleteAttachedLinksMethod(annotationId, documentId) {
+    const links = this.getAttachedLinksMethod(annotationId, documentId);
+    for (const link of links) {
+      this.deleteAnnotation(link.object.pageIndex, link.object.id, documentId);
+    }
+  }
+  // ─────────────────────────────────────────────────────────
+  // Annotation Grouping Methods
+  // ─────────────────────────────────────────────────────────
+  /**
+   * Group the currently selected annotations.
+   * The first selected annotation becomes the group leader.
+   * All other selected annotations get their IRT set to the leader's ID with RT = Group.
+   */
+  groupAnnotationsMethod(documentId) {
+    const docId = documentId ?? this.getActiveDocumentId();
+    if (!this.checkPermission(docId, PdfPermissionFlag.ModifyAnnotations)) {
+      this.logger.debug(
+        "AnnotationPlugin",
+        "GroupAnnotations",
+        `Cannot group annotations: document ${docId} lacks ModifyAnnotations permission`
+      );
+      return;
+    }
+    const selected = this.getSelectedAnnotationsMethod(docId);
+    if (selected.length < 2) {
+      this.logger.debug(
+        "AnnotationPlugin",
+        "GroupAnnotations",
+        "Need at least 2 annotations to group"
+      );
+      return;
+    }
+    const leader = selected[0];
+    const members = selected.slice(1);
+    const patches = members.map((ta) => ({
+      pageIndex: ta.object.pageIndex,
+      id: ta.object.id,
+      patch: {
+        inReplyToId: leader.object.id,
+        replyType: PdfAnnotationReplyType.Group
+      }
+    }));
+    this.updateAnnotationsMethod(patches, docId);
+  }
+  /**
+   * Ungroup all annotations in the group containing the specified annotation.
+   * Clears IRT and RT from all group members (the leader doesn't have them).
+   */
+  ungroupAnnotationsMethod(annotationId, documentId) {
+    const docId = documentId ?? this.getActiveDocumentId();
+    if (!this.checkPermission(docId, PdfPermissionFlag.ModifyAnnotations)) {
+      this.logger.debug(
+        "AnnotationPlugin",
+        "UngroupAnnotations",
+        `Cannot ungroup annotations: document ${docId} lacks ModifyAnnotations permission`
+      );
+      return;
+    }
+    const members = this.getGroupMembersMethod(annotationId, docId);
+    const patches = members.filter((ta) => ta.object.inReplyToId && ta.object.replyType === PdfAnnotationReplyType.Group).map((ta) => ({
+      pageIndex: ta.object.pageIndex,
+      id: ta.object.id,
+      patch: {
+        inReplyToId: void 0,
+        replyType: void 0
+      }
+    }));
+    if (patches.length > 0) {
+      this.updateAnnotationsMethod(patches, docId);
+    }
+  }
+  /**
+   * Get all annotations in the same group as the specified annotation.
+   */
+  getGroupMembersMethod(annotationId, documentId) {
+    return getGroupMembers(this.getDocumentState(documentId), annotationId);
+  }
+  /**
+   * Check if an annotation is part of a group.
+   */
+  isInGroupMethod(annotationId, documentId) {
+    return isInGroup(this.getDocumentState(documentId), annotationId);
+  }
+  /**
+   * Get the available grouping action for the current selection.
+   */
+  getGroupingActionMethod(documentId) {
+    return getSelectionGroupingAction(this.getDocumentState(documentId));
+  }
+  // ─────────────────────────────────────────────────────────
+  // Multi-Drag Coordination (Internal API for framework components)
+  // ─────────────────────────────────────────────────────────
+  /**
+   * Compute combined constraints from all selected annotations.
+   * This finds the "weakest link" in each direction - the annotation with the least
+   * room to move determines the group's limit.
+   */
+  computeCombinedConstraints(annotations) {
+    let maxUp = Infinity;
+    let maxDown = Infinity;
+    let maxLeft = Infinity;
+    let maxRight = Infinity;
+    for (const anno of annotations) {
+      const upLimit = anno.rect.origin.y;
+      const downLimit = anno.pageSize.height - (anno.rect.origin.y + anno.rect.size.height);
+      const leftLimit = anno.rect.origin.x;
+      const rightLimit = anno.pageSize.width - (anno.rect.origin.x + anno.rect.size.width);
+      maxUp = Math.min(maxUp, upLimit);
+      maxDown = Math.min(maxDown, downLimit);
+      maxLeft = Math.min(maxLeft, leftLimit);
+      maxRight = Math.min(maxRight, rightLimit);
+    }
+    if (!isFinite(maxUp)) maxUp = 0;
+    if (!isFinite(maxDown)) maxDown = 0;
+    if (!isFinite(maxLeft)) maxLeft = 0;
+    if (!isFinite(maxRight)) maxRight = 0;
+    return { maxUp, maxDown, maxLeft, maxRight };
+  }
+  /**
+   * Clamp a delta to the combined constraints.
+   * Negative y = moving up, positive y = moving down
+   * Negative x = moving left, positive x = moving right
+   */
+  clampDelta(rawDelta, constraints) {
+    return {
+      x: Math.max(-constraints.maxLeft, Math.min(constraints.maxRight, rawDelta.x)),
+      y: Math.max(-constraints.maxUp, Math.min(constraints.maxDown, rawDelta.y))
+    };
+  }
+  // ─────────────────────────────────────────────────────────
+  // Unified Drag API (Plugin owns all logic - framework just calls these)
+  // ─────────────────────────────────────────────────────────
+  /**
+   * Start a unified drag operation.
+   * The plugin automatically expands the selection to include attached links.
+   * Framework components should call this instead of building their own logic.
+   *
+   * @param documentId - The document ID
+   * @param options - Drag options (annotationIds and pageSize)
+   */
+  startDrag(documentId, options) {
+    const { annotationIds, pageSize } = options;
+    const attachedLinkIds = [];
+    for (const id of annotationIds) {
+      const links = this.getAttachedLinksMethod(id, documentId);
+      for (const link of links) {
+        if (!attachedLinkIds.includes(link.object.id)) {
+          attachedLinkIds.push(link.object.id);
+        }
+      }
+    }
+    const allParticipantIds = [...annotationIds, ...attachedLinkIds];
+    const originalRects = /* @__PURE__ */ new Map();
+    const constraints = [];
+    for (const id of allParticipantIds) {
+      const ta = this.getAnnotationById(id, documentId);
+      if (ta) {
+        originalRects.set(id, { ...ta.object.rect });
+        constraints.push({
+          id,
+          rect: ta.object.rect,
+          pageIndex: ta.object.pageIndex,
+          pageSize
+        });
+      }
+    }
+    const combinedConstraints = this.computeCombinedConstraints(constraints);
+    const state = {
+      documentId,
+      isDragging: true,
+      primaryIds: annotationIds,
+      attachedLinkIds,
+      allParticipantIds,
+      originalRects,
+      delta: { x: 0, y: 0 },
+      combinedConstraints
+    };
+    this.unifiedDragStates.set(documentId, state);
+    this.unifiedDrag$.emit({ documentId, type: "start", state, previewPatches: {} });
+  }
+  /**
+   * Compute preview patches for all drag participants.
+   * Uses transformAnnotation to properly handle vertices, inkList, etc.
+   */
+  computeDragPreviewPatches(state, documentId) {
+    const previewPatches = {};
+    for (const id of state.allParticipantIds) {
+      const ta = this.getAnnotationById(id, documentId);
+      if (!ta) continue;
+      const originalRect = state.originalRects.get(id);
+      if (!originalRect) continue;
+      const newRect = {
+        ...originalRect,
+        origin: {
+          x: originalRect.origin.x + state.delta.x,
+          y: originalRect.origin.y + state.delta.y
+        }
+      };
+      previewPatches[id] = this.transformAnnotation(ta.object, {
+        type: "move",
+        changes: { rect: newRect }
+      });
+    }
+    return previewPatches;
+  }
+  /**
+   * Update the drag delta during a unified drag operation.
+   * Returns the clamped delta synchronously for the caller's preview.
+   *
+   * @param documentId - The document ID
+   * @param rawDelta - The unconstrained delta from the drag gesture
+   * @returns The clamped delta
+   */
+  updateDrag(documentId, rawDelta) {
+    const state = this.unifiedDragStates.get(documentId);
+    if (!(state == null ? void 0 : state.isDragging)) {
+      return { x: 0, y: 0 };
+    }
+    const clampedDelta = this.clampDelta(rawDelta, state.combinedConstraints);
+    const newState = {
+      ...state,
+      delta: clampedDelta
+    };
+    this.unifiedDragStates.set(documentId, newState);
+    const previewPatches = this.computeDragPreviewPatches(newState, documentId);
+    this.unifiedDrag$.emit({ documentId, type: "update", state: newState, previewPatches });
+    return clampedDelta;
+  }
+  /**
+   * Commit the drag - plugin builds and applies ALL patches.
+   * This is the key method that centralizes patch building in the plugin.
+   *
+   * @param documentId - The document ID
+   */
+  commitDrag(documentId) {
+    const state = this.unifiedDragStates.get(documentId);
+    if (!state) return;
+    const finalDelta = state.delta;
+    if (finalDelta.x !== 0 || finalDelta.y !== 0) {
+      const patches = [];
+      for (const id of state.allParticipantIds) {
+        const ta = this.getAnnotationById(id, documentId);
+        if (!ta) continue;
+        const originalRect = state.originalRects.get(id) ?? ta.object.rect;
+        const newRect = {
+          ...originalRect,
+          origin: {
+            x: originalRect.origin.x + finalDelta.x,
+            y: originalRect.origin.y + finalDelta.y
+          }
+        };
+        const patch = this.transformAnnotation(ta.object, {
+          type: "move",
+          changes: { rect: newRect }
+        });
+        patches.push({ pageIndex: ta.object.pageIndex, id, patch });
+      }
+      if (patches.length > 0) {
+        this.updateAnnotationsMethod(patches, documentId);
+      }
+    }
+    const endPatches = this.computeDragPreviewPatches(state, documentId);
+    this.unifiedDrag$.emit({
+      documentId,
+      type: "end",
+      state: { ...state, isDragging: false },
+      previewPatches: endPatches
+    });
+    this.unifiedDragStates.delete(documentId);
+  }
+  /**
+   * Cancel the drag without committing.
+   *
+   * @param documentId - The document ID
+   */
+  cancelDrag(documentId) {
+    const state = this.unifiedDragStates.get(documentId);
+    if (!state) return;
+    this.unifiedDrag$.emit({
+      documentId,
+      type: "cancel",
+      state: { ...state, isDragging: false, delta: { x: 0, y: 0 } },
+      previewPatches: {}
+    });
+    this.unifiedDragStates.delete(documentId);
+  }
+  /**
+   * Get the current unified drag state for a document.
+   */
+  getDragState(documentId) {
+    return this.unifiedDragStates.get(documentId) ?? null;
+  }
+  /**
+   * Subscribe to unified drag state changes.
+   * Framework components use this for preview updates.
+   */
+  get onDragChange() {
+    return this.unifiedDrag$.on;
+  }
+  // ─────────────────────────────────────────────────────────
+  // Unified Resize API (Plugin owns all logic - framework just calls these)
+  // ─────────────────────────────────────────────────────────
+  /**
+   * Compute the union bounding box of multiple rects.
+   */
+  computeUnifiedGroupBoundingBox(rects) {
+    if (rects.length === 0) {
+      return { origin: { x: 0, y: 0 }, size: { width: 0, height: 0 } };
+    }
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    for (const rect of rects) {
+      minX = Math.min(minX, rect.origin.x);
+      minY = Math.min(minY, rect.origin.y);
+      maxX = Math.max(maxX, rect.origin.x + rect.size.width);
+      maxY = Math.max(maxY, rect.origin.y + rect.size.height);
+    }
+    return {
+      origin: { x: minX, y: minY },
+      size: { width: maxX - minX, height: maxY - minY }
+    };
+  }
+  /**
+   * Compute relative positions for annotations within a group bounding box.
+   */
+  computeUnifiedRelativePositions(annotations, groupBox) {
+    return annotations.map((anno) => ({
+      id: anno.id,
+      originalRect: anno.rect,
+      pageIndex: anno.pageIndex,
+      isAttachedLink: anno.isAttachedLink,
+      parentId: anno.parentId,
+      relativeX: groupBox.size.width > 0 ? (anno.rect.origin.x - groupBox.origin.x) / groupBox.size.width : 0,
+      relativeY: groupBox.size.height > 0 ? (anno.rect.origin.y - groupBox.origin.y) / groupBox.size.height : 0,
+      relativeWidth: groupBox.size.width > 0 ? anno.rect.size.width / groupBox.size.width : 1,
+      relativeHeight: groupBox.size.height > 0 ? anno.rect.size.height / groupBox.size.height : 1
+    }));
+  }
+  /**
+   * Compute new rects for all annotations based on the new group bounding box.
+   */
+  computeUnifiedResizedRects(participatingAnnotations, newGroupBox, minSize = 10) {
+    const result = /* @__PURE__ */ new Map();
+    for (const anno of participatingAnnotations) {
+      const newWidth = Math.max(minSize, anno.relativeWidth * newGroupBox.size.width);
+      const newHeight = Math.max(minSize, anno.relativeHeight * newGroupBox.size.height);
+      result.set(anno.id, {
+        origin: {
+          x: newGroupBox.origin.x + anno.relativeX * newGroupBox.size.width,
+          y: newGroupBox.origin.y + anno.relativeY * newGroupBox.size.height
+        },
+        size: {
+          width: newWidth,
+          height: newHeight
+        }
+      });
+    }
+    return result;
+  }
+  /**
+   * Compute preview patches for all resize participants.
+   * Uses transformAnnotation to properly handle vertices, inkList, etc.
+   */
+  computeResizePreviewPatches(computedRects, documentId) {
+    const previewPatches = {};
+    for (const [id, newRect] of computedRects) {
+      const ta = this.getAnnotationById(id, documentId);
+      if (!ta) continue;
+      previewPatches[id] = this.transformAnnotation(ta.object, {
+        type: "resize",
+        changes: { rect: newRect }
+      });
+    }
+    return previewPatches;
+  }
+  /**
+   * Start a unified resize operation.
+   * The plugin automatically expands the selection to include attached links.
+   *
+   * @param documentId - The document ID
+   * @param options - Resize options
+   */
+  startResize(documentId, options) {
+    const { annotationIds, pageSize, resizeHandle } = options;
+    const attachedLinkIds = [];
+    const annotationsWithLinks = [];
+    for (const id of annotationIds) {
+      const ta = this.getAnnotationById(id, documentId);
+      if (ta) {
+        annotationsWithLinks.push({
+          id,
+          rect: ta.object.rect,
+          pageIndex: ta.object.pageIndex,
+          isAttachedLink: false
+        });
+        const links = this.getAttachedLinksMethod(id, documentId);
+        for (const link of links) {
+          if (!attachedLinkIds.includes(link.object.id)) {
+            attachedLinkIds.push(link.object.id);
+            annotationsWithLinks.push({
+              id: link.object.id,
+              rect: link.object.rect,
+              pageIndex: link.object.pageIndex,
+              isAttachedLink: true,
+              parentId: id
+            });
+          }
+        }
+      }
+    }
+    const allParticipantIds = [...annotationIds, ...attachedLinkIds];
+    const rects = annotationsWithLinks.map((a) => a.rect);
+    const groupBox = this.computeUnifiedGroupBoundingBox(rects);
+    const participatingAnnotations = this.computeUnifiedRelativePositions(
+      annotationsWithLinks,
+      groupBox
+    );
+    const computedRects = this.computeUnifiedResizedRects(participatingAnnotations, groupBox);
+    const state = {
+      documentId,
+      isResizing: true,
+      primaryIds: annotationIds,
+      attachedLinkIds,
+      allParticipantIds,
+      originalGroupBox: groupBox,
+      currentGroupBox: groupBox,
+      participatingAnnotations,
+      resizeHandle,
+      computedRects
+    };
+    this.unifiedResizeStates.set(documentId, state);
+    const startPatches = this.computeResizePreviewPatches(computedRects, documentId);
+    this.unifiedResize$.emit({
+      documentId,
+      type: "start",
+      state,
+      computedRects: Object.fromEntries(computedRects),
+      previewPatches: startPatches
+    });
+  }
+  /**
+   * Update the resize with a new group bounding box.
+   * Returns the computed rects synchronously for immediate preview use.
+   *
+   * @param documentId - The document ID
+   * @param newGroupBox - The new group bounding box
+   * @returns Record of annotation ID to new rect
+   */
+  updateResize(documentId, newGroupBox) {
+    const state = this.unifiedResizeStates.get(documentId);
+    if (!(state == null ? void 0 : state.isResizing)) {
+      return {};
+    }
+    const computedRects = this.computeUnifiedResizedRects(
+      state.participatingAnnotations,
+      newGroupBox
+    );
+    const newState = {
+      ...state,
+      currentGroupBox: newGroupBox,
+      computedRects
+    };
+    this.unifiedResizeStates.set(documentId, newState);
+    const computedRectsObj = Object.fromEntries(computedRects);
+    const previewPatches = this.computeResizePreviewPatches(computedRects, documentId);
+    this.unifiedResize$.emit({
+      documentId,
+      type: "update",
+      state: newState,
+      computedRects: computedRectsObj,
+      previewPatches
+    });
+    return computedRectsObj;
+  }
+  /**
+   * Commit the resize - plugin builds and applies ALL patches.
+   *
+   * @param documentId - The document ID
+   */
+  commitResize(documentId) {
+    const state = this.unifiedResizeStates.get(documentId);
+    if (!state) return;
+    const computedRects = this.computeUnifiedResizedRects(
+      state.participatingAnnotations,
+      state.currentGroupBox
+    );
+    const patches = [];
+    for (const [id, newRect] of computedRects) {
+      const ta = this.getAnnotationById(id, documentId);
+      if (!ta) continue;
+      const patch = this.transformAnnotation(ta.object, {
+        type: "resize",
+        changes: { rect: newRect }
+      });
+      patches.push({ pageIndex: ta.object.pageIndex, id, patch });
+    }
+    if (patches.length > 0) {
+      this.updateAnnotationsMethod(patches, documentId);
+    }
+    const endPatches = this.computeResizePreviewPatches(computedRects, documentId);
+    this.unifiedResize$.emit({
+      documentId,
+      type: "end",
+      state: { ...state, isResizing: false },
+      computedRects: Object.fromEntries(computedRects),
+      previewPatches: endPatches
+    });
+    this.unifiedResizeStates.delete(documentId);
+  }
+  /**
+   * Cancel the resize without committing.
+   *
+   * @param documentId - The document ID
+   */
+  cancelResize(documentId) {
+    const state = this.unifiedResizeStates.get(documentId);
+    if (!state) return;
+    const originalRects = this.computeUnifiedResizedRects(
+      state.participatingAnnotations,
+      state.originalGroupBox
+    );
+    this.unifiedResize$.emit({
+      documentId,
+      type: "cancel",
+      state: { ...state, isResizing: false, currentGroupBox: state.originalGroupBox },
+      computedRects: Object.fromEntries(originalRects),
+      previewPatches: {}
+    });
+    this.unifiedResizeStates.delete(documentId);
+  }
+  /**
+   * Get the current unified resize state for a document.
+   */
+  getResizeState(documentId) {
+    return this.unifiedResizeStates.get(documentId) ?? null;
+  }
+  /**
+   * Subscribe to unified resize state changes.
+   * Framework components use this for preview updates.
+   */
+  get onResizeChange() {
+    return this.unifiedResize$.on;
+  }
+  updateAnnotationsMethod(patches, documentId) {
+    const docId = documentId ?? this.getActiveDocumentId();
+    if (!this.checkPermission(docId, PdfPermissionFlag.ModifyAnnotations)) {
+      this.logger.debug(
+        "AnnotationPlugin",
+        "UpdateAnnotations",
+        `Cannot update annotations: document ${docId} lacks ModifyAnnotations permission`
+      );
+      return;
+    }
+    const docState = this.getDocumentState(docId);
+    const patchData = patches.map(({ pageIndex, id, patch }) => {
+      var _a;
+      const originalObject = (_a = docState.byUid[id]) == null ? void 0 : _a.object;
+      if (!originalObject) return null;
+      const finalPatch = this.buildPatch(originalObject, {
+        ...patch,
+        author: patch.author ?? this.config.annotationAuthor
+      });
+      return { pageIndex, id, patch: finalPatch, originalObject };
+    }).filter((p) => p !== null);
+    if (patchData.length === 0) return;
+    const execute = () => {
+      for (const { pageIndex, id, patch, originalObject } of patchData) {
+        this.dispatch(patchAnnotation(docId, pageIndex, id, patch));
+        this.events$.emit({
+          type: "update",
+          documentId: docId,
+          annotation: originalObject,
+          pageIndex,
+          patch,
+          committed: false
+        });
+      }
+    };
+    if (!this.history) {
+      execute();
+      if (this.config.autoCommit !== false) {
+        this.commit(docId);
+      }
+      return;
+    }
+    const undoData = patchData.map(({ pageIndex, id, patch, originalObject }) => ({
+      pageIndex,
+      id,
+      originalPatch: Object.fromEntries(
+        Object.keys(patch).map((key) => [key, originalObject[key]])
+      ),
+      originalObject
+    }));
+    const command = {
+      execute,
+      undo: () => {
+        for (const { pageIndex, id, originalPatch, originalObject } of undoData) {
+          this.dispatch(patchAnnotation(docId, pageIndex, id, originalPatch));
+          this.events$.emit({
+            type: "update",
+            documentId: docId,
+            annotation: originalObject,
+            pageIndex,
+            patch: originalPatch,
+            committed: false
+          });
+        }
+      },
+      metadata: { annotationIds: patchData.map((p) => p.id) }
+    };
+    const historyScope = this.history.forDocument(docId);
+    historyScope.register(command, this.ANNOTATION_HISTORY_TOPIC);
+  }
   getActiveTool(documentId) {
     const docState = this.getDocumentState(documentId);
     if (!docState.activeToolId) return null;
@@ -2819,87 +3830,185 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
     }
     return bestTool;
   }
-  commit(documentId) {
-    const task = new Task();
-    const docId = documentId ?? this.getActiveDocumentId();
+  /**
+   * Collects all pending annotation changes for a document into a batch.
+   * This separates the "what to commit" from "how to commit" for cleaner code.
+   */
+  collectPendingChanges(docId, doc) {
     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 = [];
+    const batch = {
+      creations: [],
+      updates: [],
+      deletions: [],
+      committedUids: [],
+      isEmpty: true
+    };
     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;
+      batch.committedUids.push(uid);
+      batch.isEmpty = false;
       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);
+          batch.creations.push({
+            uid,
+            ta,
+            ctx: contexts == null ? void 0 : contexts.get(ta.object.id)
+          });
           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);
+          batch.updates.push({ uid, ta });
           break;
         case "deleted":
-          deletions.push({ ta, uid });
+          batch.deletions.push({ uid, ta });
           break;
       }
     }
-    const deletionTasks = [];
-    for (const { ta, uid } of deletions) {
+    return batch;
+  }
+  /**
+   * Executes a batch of pending changes by creating engine tasks.
+   * Returns a task that resolves when all operations complete.
+   */
+  executeCommitBatch(docId, doc, batch) {
+    const task = new Task();
+    const contexts = this.pendingContexts.get(docId);
+    const pendingOps = [];
+    for (const { uid, ta, ctx } of batch.creations) {
       const page = doc.pages.find((p) => p.index === ta.object.pageIndex);
-      if (ta.commitState === "deleted" && ta.object.id) {
-        const task2 = new Task();
+      if (!page) continue;
+      const createTask = this.engine.createPageAnnotation(doc, page, ta.object, ctx);
+      pendingOps.push({ type: "create", task: createTask, ta, uid, ctx });
+    }
+    for (const { uid, ta } of batch.updates) {
+      const page = doc.pages.find((p) => p.index === ta.object.pageIndex);
+      if (!page) continue;
+      const updateTask = this.engine.updatePageAnnotation(doc, page, ta.object);
+      pendingOps.push({ type: "update", task: updateTask, ta, uid });
+    }
+    for (const { uid, ta } of batch.deletions) {
+      const page = doc.pages.find((p) => p.index === ta.object.pageIndex);
+      if (!page) continue;
+      if (ta.object.id) {
+        const deleteTask = new Task();
         const removeTask = this.engine.removePageAnnotation(doc, page, ta.object);
-        removeTask.wait(() => {
-          this.dispatch(purgeAnnotation(docId, uid));
+        removeTask.wait(() => deleteTask.resolve(true), deleteTask.fail);
+        pendingOps.push({ type: "delete", task: deleteTask, ta, uid });
+      } else {
+        this.dispatch(purgeAnnotation(docId, ta.object.pageIndex, uid));
+      }
+    }
+    const allTasks = pendingOps.map((op) => op.task);
+    Task.allSettled(allTasks).wait(
+      () => {
+        this.emitCommitEvents(docId, pendingOps, contexts);
+        this.dispatch(commitPendingChanges(docId, batch.committedUids));
+        task.resolve(true);
+      },
+      (error) => task.fail(error)
+    );
+    return task;
+  }
+  /**
+   * Emits commit events for all completed operations.
+   * Centralizes event emission for cleaner separation of concerns.
+   */
+  emitCommitEvents(docId, operations, contexts) {
+    for (const op of operations) {
+      if (op.task.state.stage !== TaskStage.Resolved) continue;
+      switch (op.type) {
+        case "create":
+          this.events$.emit({
+            type: "create",
+            documentId: docId,
+            annotation: op.ta.object,
+            pageIndex: op.ta.object.pageIndex,
+            ctx: op.ctx,
+            committed: true
+          });
+          contexts == null ? void 0 : contexts.delete(op.ta.object.id);
+          break;
+        case "update":
+          this.events$.emit({
+            type: "update",
+            documentId: docId,
+            annotation: op.ta.object,
+            pageIndex: op.ta.object.pageIndex,
+            patch: op.ta.object,
+            committed: true
+          });
+          break;
+        case "delete":
+          this.dispatch(purgeAnnotation(docId, op.ta.object.pageIndex, op.uid));
           this.events$.emit({
             type: "delete",
             documentId: docId,
-            annotation: ta.object,
-            pageIndex: ta.object.pageIndex,
+            annotation: op.ta.object,
+            pageIndex: op.ta.object.pageIndex,
             committed: true
           });
-          task2.resolve(true);
-        }, task2.fail);
-        deletionTasks.push(task2);
-      } else {
-        this.dispatch(purgeAnnotation(docId, uid));
+          break;
       }
     }
-    const allWriteTasks = [...creations, ...updates, ...deletionTasks];
-    Task.allSettled(allWriteTasks).wait(() => {
-      this.dispatch(commitPendingChanges(docId));
-      task.resolve(true);
-    }, task.fail);
+  }
+  /**
+   * Attempts to acquire the commit lock for a document.
+   * Returns true if acquired, false if a commit is already in progress.
+   */
+  acquireCommitLock(docId) {
+    if (this.commitInProgress.get(docId)) {
+      return false;
+    }
+    this.commitInProgress.set(docId, true);
+    return true;
+  }
+  /**
+   * Releases the commit lock for a document.
+   */
+  releaseCommitLock(docId) {
+    this.commitInProgress.set(docId, false);
+  }
+  commit(documentId) {
+    const docId = documentId ?? this.getActiveDocumentId();
+    const docState = this.getDocumentState(docId);
+    if (!docState.hasPendingChanges) {
+      return PdfTaskHelper.resolve(true);
+    }
+    if (!this.acquireCommitLock(docId)) {
+      return PdfTaskHelper.resolve(true);
+    }
+    const coreDocState = this.getCoreDocument(docId);
+    const doc = coreDocState == null ? void 0 : coreDocState.document;
+    if (!doc) {
+      this.releaseCommitLock(docId);
+      return PdfTaskHelper.reject({ code: PdfErrorCode.NotFound, message: "Document not found" });
+    }
+    const batch = this.collectPendingChanges(docId, doc);
+    if (batch.isEmpty) {
+      this.releaseCommitLock(docId);
+      return PdfTaskHelper.resolve(true);
+    }
+    const task = new Task();
+    this.executeCommitBatch(docId, doc, batch).wait(
+      () => {
+        this.releaseCommitLock(docId);
+        const updatedDocState = this.getDocumentState(docId);
+        if (updatedDocState.hasPendingChanges) {
+          this.commit(docId).wait(
+            (result) => task.resolve(result),
+            (error) => task.fail(error)
+          );
+        } else {
+          task.resolve(true);
+        }
+      },
+      (error) => {
+        this.releaseCommitLock(docId);
+        task.fail(error);
+      }
+    );
     return task;
   }
   /**
@@ -2916,6 +4025,11 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
 };
 _AnnotationPlugin.id = "annotation";
 let AnnotationPlugin = _AnnotationPlugin;
+function resolveInteractionProp(prop, annotation, defaultValue) {
+  if (prop === void 0) return defaultValue;
+  if (typeof prop === "function") return prop(annotation);
+  return prop;
+}
 function createToolPredicate(id) {
   return (tool) => {
     return (tool == null ? void 0 : tool.id) === id;
@@ -2948,11 +4062,23 @@ export {
   getAnnotationByUid,
   getAnnotations,
   getAnnotationsByPageIndex,
+  getAttachedLinks,
+  getGroupLeaderId,
+  getGroupMembers,
+  getIRTChildIds,
+  getIRTChildrenByType,
   getSelectedAnnotation,
   getSelectedAnnotationByPageIndex,
+  getSelectedAnnotationIds,
+  getSelectedAnnotations,
+  getSelectedAnnotationsByPageIndex,
+  getSelectionGroupingAction,
   getSidebarAnnotationsWithReplies,
   getSidebarAnnotationsWithRepliesGroupedByPage,
   getToolDefaultsById,
+  hasAttachedLinks,
+  hasIRTChildren,
+  hasMultipleSelected,
   initialDocumentState,
   initialState,
   isAnnotationSelected,
@@ -2962,15 +4088,18 @@ export {
   isFreeTextTool,
   isHighlight,
   isHighlightTool,
+  isInGroup,
   isInk,
   isInkHighlighterTool,
   isInkTool,
   isLine,
   isLineTool,
+  isLink,
   isPolygon,
   isPolygonTool,
   isPolyline,
   isPolylineTool,
+  isRedact,
   isSidebarAnnotation,
   isSquare,
   isSquareTool,
@@ -2985,6 +4114,8 @@ export {
   isUnderline,
   isUnderlineTool,
   manifest,
-  index as patching
+  index as patching,
+  rectsIntersect,
+  resolveInteractionProp
 };
 //# sourceMappingURL=index.js.map