@harbour-enterprises/superdoc 1.8.0-next.3 → 1.8.0-next.4

package/dist/superdoc.umd.js

@@ -38710,7 +38710,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     static getStoredSuperdocVersion(docx) {
       return SuperConverter.getStoredCustomProperty(docx, "SuperdocVersion");
     }
-    static setStoredSuperdocVersion(docx = this.convertedXml, version2 = "1.8.0-next.3") {
+    static setStoredSuperdocVersion(docx = this.convertedXml, version2 = "1.8.0-next.4") {
       return SuperConverter.setStoredCustomProperty(docx, "SuperdocVersion", version2, false);
     }
     /**
@@ -65052,7 +65052,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       return false;
     }
   };
-  const summaryVersion = "1.8.0-next.3";
+  const summaryVersion = "1.8.0-next.4";
   const nodeKeys = ["group", "content", "marks", "inline", "atom", "defining", "code", "tableRole", "summary"];
   const markKeys = ["group", "inclusive", "excludes", "spanning", "code"];
   function mapAttributes(attrs) {
@@ -67710,7 +67710,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
      * Process collaboration migrations
      */
     processCollaborationMigrations() {
-      console.debug("[checkVersionMigrations] Current editor version", "1.8.0-next.3");
+      console.debug("[checkVersionMigrations] Current editor version", "1.8.0-next.4");
       if (!this.options.ydoc) return;
       const metaMap = this.options.ydoc.getMap("meta");
       let docVersion = metaMap.get("version");
@@ -77754,24 +77754,6 @@ ${o}
       }
       elem.setAttribute("role", "link");
       elem.setAttribute("tabindex", "0");
-      elem.addEventListener("click", (event) => {
-        event.preventDefault();
-        event.stopPropagation();
-        const linkClickEvent = new CustomEvent("superdoc-link-click", {
-          bubbles: true,
-          composed: true,
-          detail: {
-            href: linkData.href,
-            target: linkData.target,
-            rel: linkData.rel,
-            tooltip: linkData.tooltip,
-            element: elem,
-            clientX: event.clientX,
-            clientY: event.clientY
-          }
-        });
-        elem.dispatchEvent(linkClickEvent);
-      });
     }
     /**
      * Render a single run as an HTML element (span or anchor).
@@ -89110,255 +89092,6 @@ ${o}
     /** P3: Heavy debounce for full document layout */
     [Priority.P3]: 150
   });
-  const DEFAULT_MIME_TYPE$1 = "application/x-field-annotation";
-  const LEGACY_MIME_TYPE = "fieldAnnotation";
-  function parseIntSafe$1(value) {
-    if (!value) return void 0;
-    const parsed = parseInt(value, 10);
-    return Number.isFinite(parsed) ? parsed : void 0;
-  }
-  function extractFieldAnnotationData(element2) {
-    const dataset = element2.dataset;
-    const attributes = {};
-    for (const key2 in dataset) {
-      const value = dataset[key2];
-      if (value !== void 0) {
-        attributes[key2] = value;
-      }
-    }
-    return {
-      fieldId: dataset.fieldId,
-      fieldType: dataset.fieldType,
-      variant: dataset.variant ?? dataset.type,
-      displayLabel: dataset.displayLabel,
-      pmStart: parseIntSafe$1(dataset.pmStart),
-      pmEnd: parseIntSafe$1(dataset.pmEnd),
-      attributes
-    };
-  }
-  class DragHandler {
-    /**
-     * Creates a new DragHandler instance.
-     *
-     * @param container - The DOM container element (typically .superdoc-layout)
-     * @param config - Configuration options and callbacks
-     */
-    constructor(container, config2 = {}) {
-      this.container = container;
-      this.config = config2;
-      this.mimeType = config2.mimeType ?? DEFAULT_MIME_TYPE$1;
-      this.boundHandlers = {
-        dragstart: this.handleDragStart.bind(this),
-        dragover: this.handleDragOver.bind(this),
-        drop: this.handleDrop.bind(this),
-        dragend: this.handleDragEnd.bind(this),
-        dragleave: this.handleDragLeave.bind(this)
-      };
-      this.windowDragoverHandler = this.handleWindowDragOver.bind(this);
-      this.windowDropHandler = this.handleWindowDrop.bind(this);
-      this.attachListeners();
-    }
-    /**
-     * Attaches event listeners to the container and window.
-     */
-    attachListeners() {
-      this.container.addEventListener("dragstart", this.boundHandlers.dragstart);
-      this.container.addEventListener("dragover", this.boundHandlers.dragover);
-      this.container.addEventListener("drop", this.boundHandlers.drop);
-      this.container.addEventListener("dragend", this.boundHandlers.dragend);
-      this.container.addEventListener("dragleave", this.boundHandlers.dragleave);
-      window.addEventListener("dragover", this.windowDragoverHandler, false);
-      window.addEventListener("drop", this.windowDropHandler, false);
-    }
-    /**
-     * Removes event listeners from the container and window.
-     */
-    removeListeners() {
-      this.container.removeEventListener("dragstart", this.boundHandlers.dragstart);
-      this.container.removeEventListener("dragover", this.boundHandlers.dragover);
-      this.container.removeEventListener("drop", this.boundHandlers.drop);
-      this.container.removeEventListener("dragend", this.boundHandlers.dragend);
-      this.container.removeEventListener("dragleave", this.boundHandlers.dragleave);
-      window.removeEventListener("dragover", this.windowDragoverHandler, false);
-      window.removeEventListener("drop", this.windowDropHandler, false);
-    }
-    /**
-     * Handles dragover at window level to allow drops on overlay elements.
-     * This ensures preventDefault is called even when dragging over selection
-     * highlights or other UI elements that sit on top of the layout content.
-     */
-    handleWindowDragOver(event) {
-      if (this.hasFieldAnnotationData(event)) {
-        event.preventDefault();
-        if (event.dataTransfer) {
-          event.dataTransfer.dropEffect = "move";
-        }
-        const target = event.target;
-        if (!this.container.contains(target)) {
-          this.config.onDragOver?.({
-            event,
-            clientX: event.clientX,
-            clientY: event.clientY,
-            hasFieldAnnotation: true
-          });
-        }
-      }
-    }
-    /**
-     * Handles drop at window level to catch drops on overlay elements.
-     * If the drop target is outside the container, we process it here.
-     */
-    handleWindowDrop(event) {
-      if (this.hasFieldAnnotationData(event)) {
-        const target = event.target;
-        if (!this.container.contains(target)) {
-          this.handleDrop(event);
-        }
-      }
-    }
-    /**
-     * Handles the dragstart event.
-     * Sets up dataTransfer with field annotation data and drag image.
-     */
-    handleDragStart(event) {
-      const target = event.target;
-      if (!target?.dataset?.draggable || target.dataset.draggable !== "true") {
-        return;
-      }
-      const data = extractFieldAnnotationData(target);
-      if (event.dataTransfer) {
-        const jsonData = JSON.stringify({
-          attributes: data.attributes,
-          sourceField: data
-        });
-        event.dataTransfer.setData(this.mimeType, jsonData);
-        event.dataTransfer.setData(LEGACY_MIME_TYPE, jsonData);
-        event.dataTransfer.setData("text/plain", data.displayLabel ?? "Field Annotation");
-        event.dataTransfer.setDragImage(target, 0, 0);
-        event.dataTransfer.effectAllowed = "move";
-      }
-      this.config.onDragStart?.({
-        event,
-        element: target,
-        data
-      });
-    }
-    /**
-     * Handles the dragover event.
-     * Provides visual feedback and determines if drop is allowed.
-     */
-    handleDragOver(event) {
-      const hasFieldAnnotation = this.hasFieldAnnotationData(event);
-      if (hasFieldAnnotation) {
-        event.preventDefault();
-        if (event.dataTransfer) {
-          event.dataTransfer.dropEffect = "move";
-        }
-        this.container.classList.add("drag-over");
-      }
-      this.config.onDragOver?.({
-        event,
-        clientX: event.clientX,
-        clientY: event.clientY,
-        hasFieldAnnotation
-      });
-    }
-    /**
-     * Handles the dragleave event.
-     * Removes visual feedback when drag leaves the container.
-     */
-    handleDragLeave(event) {
-      const relatedTarget = event.relatedTarget;
-      if (!relatedTarget || !this.container.contains(relatedTarget)) {
-        this.container.classList.remove("drag-over");
-      }
-    }
-    /**
-     * Handles the drop event.
-     * Maps drop coordinates to ProseMirror position and emits drop event.
-     */
-    handleDrop(event) {
-      this.container.classList.remove("drag-over");
-      if (!this.hasFieldAnnotationData(event)) {
-        return;
-      }
-      event.preventDefault();
-      const data = this.extractDragData(event);
-      if (!data) {
-        return;
-      }
-      const pmPosition = clickToPositionDom(this.container, event.clientX, event.clientY);
-      this.config.onDrop?.({
-        event,
-        data,
-        pmPosition,
-        clientX: event.clientX,
-        clientY: event.clientY
-      });
-    }
-    /**
-     * Handles the dragend event.
-     * Cleans up drag state.
-     */
-    handleDragEnd(event) {
-      this.container.classList.remove("drag-over");
-      this.config.onDragEnd?.(event);
-    }
-    /**
-     * Checks if a drag event contains field annotation data.
-     */
-    hasFieldAnnotationData(event) {
-      if (!event.dataTransfer) {
-        return false;
-      }
-      const types2 = event.dataTransfer.types;
-      return types2.includes(this.mimeType) || types2.includes(LEGACY_MIME_TYPE);
-    }
-    /**
-     * Extracts field annotation data from a drag event's dataTransfer.
-     */
-    extractDragData(event) {
-      if (!event.dataTransfer) {
-        return null;
-      }
-      let jsonData = event.dataTransfer.getData(this.mimeType);
-      if (!jsonData) {
-        jsonData = event.dataTransfer.getData(LEGACY_MIME_TYPE);
-      }
-      if (!jsonData) {
-        return null;
-      }
-      try {
-        const parsed = JSON.parse(jsonData);
-        return parsed.sourceField ?? parsed.attributes ?? parsed;
-      } catch {
-        return null;
-      }
-    }
-    /**
-     * Updates the configuration options.
-     *
-     * @param config - New configuration options to merge
-     */
-    updateConfig(config2) {
-      this.config = { ...this.config, ...config2 };
-      if (config2.mimeType) {
-        this.mimeType = config2.mimeType;
-      }
-    }
-    /**
-     * Destroys the drag handler and removes all event listeners.
-     * Call this when the layout engine is unmounted or the container is removed.
-     */
-    destroy() {
-      this.removeListeners();
-      this.container.classList.remove("drag-over");
-    }
-  }
-  function createDragHandler(container, config2 = {}) {
-    const handler2 = new DragHandler(container, config2);
-    return () => handler2.destroy();
-  }
   const isAtomicFragment = (fragment) => {
     return fragment.kind === "drawing" || fragment.kind === "image";
   };
@@ -90922,229 +90655,1425 @@ ${o}
       this.#isSetup = false;
     }
   }
-  const createDefaultScheduler = () => {
-    if (typeof window !== "undefined" && typeof window.requestAnimationFrame === "function") {
-      return {
-        requestAnimationFrame: (cb) => window.requestAnimationFrame(cb),
-        cancelAnimationFrame: (handle2) => window.cancelAnimationFrame(handle2)
-      };
+  const WORD_CHARACTER_REGEX = /[\p{L}\p{N}'\u2018\u2019_~-]/u;
+  function isWordCharacter(char) {
+    if (!char) {
+      return false;
     }
-    const anyGlobal = globalThis;
-    if (typeof anyGlobal.requestAnimationFrame === "function" && typeof anyGlobal.cancelAnimationFrame === "function") {
-      return {
-        requestAnimationFrame: (cb) => anyGlobal.requestAnimationFrame(cb),
-        cancelAnimationFrame: (handle2) => anyGlobal.cancelAnimationFrame(handle2)
-      };
+    return WORD_CHARACTER_REGEX.test(char);
+  }
+  function calculateExtendedSelection(blocks2, anchor, head, mode) {
+    if (mode === "word") {
+      const anchorBounds = findWordBoundaries(blocks2, anchor);
+      const headBounds = findWordBoundaries(blocks2, head);
+      if (anchorBounds && headBounds) {
+        if (head >= anchor) {
+          return { selAnchor: anchorBounds.from, selHead: headBounds.to };
+        } else {
+          return { selAnchor: anchorBounds.to, selHead: headBounds.from };
+        }
+      }
+    } else if (mode === "para") {
+      const anchorBounds = findParagraphBoundaries(blocks2, anchor);
+      const headBounds = findParagraphBoundaries(blocks2, head);
+      if (anchorBounds && headBounds) {
+        if (head >= anchor) {
+          return { selAnchor: anchorBounds.from, selHead: headBounds.to };
+        } else {
+          return { selAnchor: anchorBounds.to, selHead: headBounds.from };
+        }
+      }
     }
+    return { selAnchor: anchor, selHead: head };
+  }
+  function registerPointerClick(event, previous2, options) {
+    const time2 = event.timeStamp ?? performance.now();
+    const timeDelta = time2 - previous2.lastClickTime;
+    const withinTime = timeDelta <= options.timeThresholdMs;
+    const distanceX = Math.abs(event.clientX - previous2.lastClickPosition.x);
+    const distanceY = Math.abs(event.clientY - previous2.lastClickPosition.y);
+    const withinDistance = distanceX <= options.distanceThresholdPx && distanceY <= options.distanceThresholdPx;
+    const clickCount = withinTime && withinDistance ? Math.min(previous2.clickCount + 1, options.maxClickCount) : 1;
     return {
-      requestAnimationFrame: (cb) => {
-        const handle2 = anyGlobal.setTimeout?.(() => cb(Date.now()), 0);
-        return handle2;
-      },
-      cancelAnimationFrame: (handle2) => {
-        anyGlobal.clearTimeout?.(handle2);
-      }
+      clickCount,
+      lastClickTime: time2,
+      lastClickPosition: { x: event.clientX, y: event.clientY }
     };
-  };
-  class SelectionSyncCoordinator extends EventEmitter$1 {
-    #docEpoch = 0;
-    #layoutEpoch = 0;
-    #layoutUpdating = false;
-    #pending = false;
-    #scheduled = false;
-    #rafHandle = null;
-    #scheduler;
-    /**
-     * Creates a new SelectionSyncCoordinator.
-     *
-     * @param options - Configuration options
-     * @param options.scheduler - Custom scheduler for animation frames (useful for testing), defaults to platform scheduler
-     */
-    constructor(options) {
-      super();
-      this.#scheduler = options?.scheduler ?? createDefaultScheduler();
+  }
+  function getFirstTextPosition(doc2) {
+    if (!doc2 || !doc2.content) {
+      return 1;
     }
-    /**
-     * Gets the current document epoch.
-     *
-     * @returns The document epoch (increments on each document-changing transaction)
-     */
-    getDocEpoch() {
-      return this.#docEpoch;
+    let validPos = 1;
+    doc2.nodesBetween(0, doc2.content.size, (node2, pos) => {
+      if (node2.isTextblock) {
+        validPos = pos + 1;
+        return false;
+      }
+      return true;
+    });
+    return validPos;
+  }
+  function computeWordSelectionRangeAt(state, pos) {
+    if (!state?.doc) {
+      return null;
     }
-    /**
-     * Gets the current layout epoch.
-     *
-     * @returns The epoch of the document version currently painted in the DOM
-     */
-    getLayoutEpoch() {
-      return this.#layoutEpoch;
+    if (pos < 0 || pos > state.doc.content.size) {
+      return null;
     }
-    /**
-     * Checks if a layout update is currently in progress.
-     *
-     * @returns True if between onLayoutStart() and onLayoutComplete(), false otherwise
-     */
-    isLayoutUpdating() {
-      return this.#layoutUpdating;
+    const textblockPos = findNearestTextblockResolvedPos(state.doc, pos);
+    if (!textblockPos) {
+      return null;
     }
-    /**
-     * Updates the document epoch and triggers conditional rendering.
-     *
-     * @param epoch - The new document epoch (must be finite and non-negative)
-     *
-     * @remarks
-     * When the document epoch changes:
-     * 1. Any scheduled render is cancelled (layout will be out of sync)
-     * 2. If layout has already caught up, rendering is rescheduled
-     *
-     * Calling with the same epoch as the current value is a no-op.
-     * Invalid epoch values are silently ignored.
-     */
-    setDocEpoch(epoch) {
-      if (!Number.isFinite(epoch) || epoch < 0) return;
-      if (epoch === this.#docEpoch) return;
-      this.#docEpoch = epoch;
-      this.#cancelScheduledRender();
-      this.#maybeSchedule();
+    const parentStart = textblockPos.start();
+    const parentEnd = textblockPos.end();
+    const sampleEnd = Math.min(pos + 1, parentEnd);
+    const charAtPos = state.doc.textBetween(pos, sampleEnd, "\0", "\0");
+    if (!isWordCharacter(charAtPos)) {
+      return null;
     }
-    /**
-     * Notifies the coordinator that layout computation has started.
-     *
-     * @remarks
-     * Marks the layout as updating and cancels any scheduled renders, since the DOM
-     * is about to change and current position data will be stale.
-     *
-     * Safe to call multiple times (e.g., if layouts overlap) - subsequent calls are ignored
-     * until onLayoutComplete() is called.
-     */
-    onLayoutStart() {
-      if (this.#layoutUpdating) return;
-      this.#layoutUpdating = true;
-      this.#cancelScheduledRender();
+    let startPos = pos;
+    while (startPos > parentStart) {
+      const prevChar = state.doc.textBetween(startPos - 1, startPos, "\0", "\0");
+      if (!isWordCharacter(prevChar)) {
+        break;
+      }
+      startPos -= 1;
     }
-    /**
-     * Notifies the coordinator that layout painting has completed.
-     *
-     * @param layoutEpoch - The document epoch that was just painted to the DOM
-     *
-     * @remarks
-     * Marks the layout as no longer updating, records the new layout epoch, and attempts
-     * to schedule rendering if conditions are now safe.
-     *
-     * If the layoutEpoch is invalid (not a finite non-negative number), it is ignored and
-     * the previous layoutEpoch value is retained.
-     *
-     * This method is the primary trigger for selection rendering - if there's a pending
-     * render request and layoutEpoch >= docEpoch, a render event will be scheduled.
-     */
-    onLayoutComplete(layoutEpoch) {
-      this.#layoutUpdating = false;
-      if (Number.isFinite(layoutEpoch) && layoutEpoch >= 0) {
-        this.#layoutEpoch = layoutEpoch;
+    let endPos = pos;
+    while (endPos < parentEnd) {
+      const nextChar = state.doc.textBetween(endPos, endPos + 1, "\0", "\0");
+      if (!isWordCharacter(nextChar)) {
+        break;
       }
-      this.#maybeSchedule();
+      endPos += 1;
     }
-    /**
-     * Notifies the coordinator that layout was aborted without completing.
-     *
-     * @remarks
-     * Marks the layout as no longer updating (without updating layoutEpoch) and attempts
-     * to schedule rendering if conditions are safe.
-     *
-     * Use this when layout computation is cancelled or fails partway through.
-     */
-    onLayoutAbort() {
-      this.#layoutUpdating = false;
-      this.#maybeSchedule();
+    if (startPos === endPos) {
+      return null;
     }
-    /**
-     * Requests that selection rendering occur when conditions become safe.
-     *
-     * @param options - Rendering options
-     * @param options.immediate - If true, attempts to render immediately (synchronously) if safe, defaults to false
-     *
-     * @remarks
-     * Marks a render as pending and schedules it to occur on the next animation frame if
-     * conditions are safe (layout not updating, layoutEpoch >= docEpoch).
-     *
-     * If options.immediate is true, also attempts a synchronous render before scheduling.
-     * Use immediate rendering sparingly, as it can cause multiple renders per frame.
-     *
-     * Multiple calls are coalesced - only one render will occur per animation frame.
-     */
-    requestRender(options) {
-      this.#pending = true;
-      if (options?.immediate) {
-        this.flushNow();
+    return { from: startPos, to: endPos };
+  }
+  function computeParagraphSelectionRangeAt(state, pos) {
+    if (!state?.doc) {
+      return null;
+    }
+    const textblockPos = findNearestTextblockResolvedPos(state.doc, pos);
+    if (!textblockPos) {
+      return null;
+    }
+    return { from: textblockPos.start(), to: textblockPos.end() };
+  }
+  function findNearestTextblockResolvedPos(doc2, pos) {
+    const $pos = doc2.resolve(pos);
+    let textblockPos = $pos;
+    while (textblockPos.depth > 0) {
+      if (textblockPos.parent?.isTextblock) {
+        break;
       }
-      this.#maybeSchedule();
+      if (!textblockPos.parent || textblockPos.depth === 0) {
+        break;
+      }
+      const beforePos = textblockPos.before();
+      if (beforePos < 0 || beforePos > doc2.content.size) {
+        return null;
+      }
+      textblockPos = doc2.resolve(beforePos);
     }
-    /**
-     * Attempts to render selection immediately (synchronously) if conditions are safe.
-     *
-     * @remarks
-     * If there's a pending render request and conditions are safe (layout not updating,
-     * layoutEpoch >= docEpoch), this method:
-     * 1. Cancels any scheduled asynchronous render
-     * 2. Clears the pending flag
-     * 3. Emits the 'render' event synchronously
-     *
-     * If no render is pending or conditions are not safe, this is a no-op.
-     *
-     * Use this for immediate selection updates in response to user actions (e.g., click
-     * handlers) where waiting for the next animation frame would cause noticeable lag.
-     */
-    flushNow() {
-      if (!this.#pending) return;
-      if (!this.#isSafeToRender()) return;
-      this.#cancelScheduledRender();
-      this.#pending = false;
-      this.emit("render", { docEpoch: this.#docEpoch, layoutEpoch: this.#layoutEpoch });
+    if (!textblockPos.parent?.isTextblock) {
+      return null;
     }
-    /**
-     * Permanently tears down the coordinator, cancelling pending renders and removing all listeners.
-     *
-     * @remarks
-     * After calling destroy(), this instance should not be used again. All scheduled renders
-     * are cancelled and all event listeners are removed.
-     *
-     * Safe to call multiple times.
-     */
-    destroy() {
-      this.#cancelScheduledRender();
-      this.removeAllListeners();
+    return textblockPos;
+  }
+  function getCellPosFromTableHit(tableHit, doc2, blocks2) {
+    if (!tableHit || !tableHit.block || typeof tableHit.block.id !== "string") {
+      console.warn("[getCellPosFromTableHit] Invalid tableHit input:", tableHit);
+      return null;
     }
-    #isSafeToRender() {
-      return !this.#layoutUpdating && this.#layoutEpoch >= this.#docEpoch;
+    if (typeof tableHit.cellRowIndex !== "number" || typeof tableHit.cellColIndex !== "number" || tableHit.cellRowIndex < 0 || tableHit.cellColIndex < 0) {
+      console.warn("[getCellPosFromTableHit] Invalid cell indices:", {
+        row: tableHit.cellRowIndex,
+        col: tableHit.cellColIndex
+      });
+      return null;
     }
-    #maybeSchedule() {
-      if (!this.#pending) return;
-      if (!this.#isSafeToRender()) return;
-      if (this.#scheduled) return;
-      this.#scheduled = true;
-      this.#rafHandle = this.#scheduler.requestAnimationFrame(() => {
-        this.#scheduled = false;
-        this.#rafHandle = null;
-        if (!this.#pending) return;
-        if (!this.#isSafeToRender()) return;
-        this.#pending = false;
-        this.emit("render", { docEpoch: this.#docEpoch, layoutEpoch: this.#layoutEpoch });
+    if (!doc2) return null;
+    const tableBlocks = blocks2.filter((b2) => b2.kind === "table");
+    const targetTableIndex = tableBlocks.findIndex((b2) => b2.id === tableHit.block.id);
+    if (targetTableIndex === -1) return null;
+    let tablePos = null;
+    let currentTableIndex = 0;
+    try {
+      doc2.descendants((node2, pos) => {
+        if (node2.type.name === "table") {
+          if (currentTableIndex === targetTableIndex) {
+            tablePos = pos;
+            return false;
+          }
+          currentTableIndex++;
+        }
+        return true;
       });
+    } catch (error) {
+      console.error("[getCellPosFromTableHit] Error during document traversal:", error);
+      return null;
     }
-    #cancelScheduledRender() {
-      if (this.#rafHandle != null) {
-        try {
-          this.#scheduler.cancelAnimationFrame(this.#rafHandle);
-        } finally {
-          this.#rafHandle = null;
+    if (tablePos === null) return null;
+    const tableNode = doc2.nodeAt(tablePos);
+    if (!tableNode || tableNode.type.name !== "table") return null;
+    const targetRowIndex = tableHit.cellRowIndex;
+    const targetColIndex = tableHit.cellColIndex;
+    if (targetRowIndex >= tableNode.childCount) {
+      console.warn("[getCellPosFromTableHit] Target row index out of bounds:", {
+        targetRowIndex,
+        tableChildCount: tableNode.childCount
+      });
+      return null;
+    }
+    let currentPos = tablePos + 1;
+    for (let r2 = 0; r2 < tableNode.childCount && r2 <= targetRowIndex; r2++) {
+      const row2 = tableNode.child(r2);
+      if (r2 === targetRowIndex) {
+        currentPos += 1;
+        let logicalCol = 0;
+        for (let cellIndex = 0; cellIndex < row2.childCount; cellIndex++) {
+          const cell2 = row2.child(cellIndex);
+          const rawColspan = cell2.attrs?.colspan;
+          const colspan = typeof rawColspan === "number" && Number.isFinite(rawColspan) && rawColspan > 0 ? rawColspan : 1;
+          if (targetColIndex >= logicalCol && targetColIndex < logicalCol + colspan) {
+            return currentPos;
+          }
+          currentPos += cell2.nodeSize;
+          logicalCol += colspan;
         }
+        console.warn("[getCellPosFromTableHit] Target column not found in row:", {
+          targetColIndex,
+          logicalColReached: logicalCol,
+          rowCellCount: row2.childCount
+        });
+        return null;
+      } else {
+        currentPos += row2.nodeSize;
       }
-      this.#scheduled = false;
     }
+    return null;
   }
-  const uiSurfaces = /* @__PURE__ */ new WeakSet();
-  function isInRegisteredSurface(event) {
+  function getTablePosFromHit(tableHit, doc2, blocks2) {
+    if (!doc2) return null;
+    const tableBlocks = blocks2.filter((b2) => b2.kind === "table");
+    const targetTableIndex = tableBlocks.findIndex((b2) => b2.id === tableHit.block.id);
+    if (targetTableIndex === -1) return null;
+    let tablePos = null;
+    let currentTableIndex = 0;
+    doc2.descendants((node2, pos) => {
+      if (node2.type.name === "table") {
+        if (currentTableIndex === targetTableIndex) {
+          tablePos = pos;
+          return false;
+        }
+        currentTableIndex++;
+      }
+      return true;
+    });
+    return tablePos;
+  }
+  function shouldUseCellSelection(currentTableHit, cellAnchor, cellDragMode) {
+    if (!cellAnchor) return false;
+    if (!currentTableHit) return cellDragMode === "active";
+    if (currentTableHit.block.id !== cellAnchor.tableBlockId) {
+      return cellDragMode === "active";
+    }
+    const sameCell = currentTableHit.cellRowIndex === cellAnchor.cellRowIndex && currentTableHit.cellColIndex === cellAnchor.cellColIndex;
+    if (!sameCell) {
+      return true;
+    }
+    return cellDragMode === "active";
+  }
+  function hitTestTable(layout, blocks2, measures, normalizedX, normalizedY, configuredPageHeight, pageGapFallback, geometryHelper) {
+    if (!layout) {
+      return null;
+    }
+    let pageY = 0;
+    let pageHit = null;
+    if (geometryHelper) {
+      const idx = geometryHelper.getPageIndexAtY(normalizedY) ?? geometryHelper.getNearestPageIndex(normalizedY);
+      if (idx != null && layout.pages[idx]) {
+        pageHit = { pageIndex: idx, page: layout.pages[idx] };
+        pageY = geometryHelper.getPageTop(idx);
+      }
+    }
+    if (!pageHit) {
+      const gap = layout.pageGap ?? pageGapFallback;
+      for (let i2 = 0; i2 < layout.pages.length; i2++) {
+        const page = layout.pages[i2];
+        const pageHeight = page.size?.h ?? configuredPageHeight;
+        if (normalizedY >= pageY && normalizedY < pageY + pageHeight) {
+          pageHit = { pageIndex: i2, page };
+          break;
+        }
+        pageY += pageHeight + gap;
+      }
+    }
+    if (!pageHit) {
+      return null;
+    }
+    const pageRelativeY = normalizedY - pageY;
+    const point2 = { x: normalizedX, y: pageRelativeY };
+    return hitTestTableFragment(pageHit, blocks2, measures, point2);
+  }
+  const MULTI_CLICK_TIME_THRESHOLD_MS = 400;
+  const MULTI_CLICK_DISTANCE_THRESHOLD_PX = 5;
+  class EditorInputManager {
+    // Dependencies
+    #deps = null;
+    #callbacks = {};
+    // Drag selection state
+    #isDragging = false;
+    #dragAnchor = null;
+    #dragAnchorPageIndex = null;
+    #dragExtensionMode = "char";
+    #dragLastPointer = null;
+    #dragLastRawHit = null;
+    #dragUsedPageNotMountedFallback = false;
+    // Click tracking for multi-click detection
+    #clickCount = 0;
+    #lastClickTime = 0;
+    #lastClickPosition = null;
+    // Cell selection state
+    #cellAnchor = null;
+    #cellDragMode = "none";
+    // Margin click state
+    #pendingMarginClick = null;
+    // Image selection state
+    #lastSelectedImageBlockId = null;
+    // Focus suppression (for draggable annotations)
+    #suppressFocusInFromDraggable = false;
+    // Debug state
+    #debugLastPointer = null;
+    #debugLastHit = null;
+    // Bound handlers for event listener cleanup
+    #boundHandlePointerDown = null;
+    #boundHandlePointerMove = null;
+    #boundHandlePointerUp = null;
+    #boundHandlePointerLeave = null;
+    #boundHandleDoubleClick = null;
+    #boundHandleClick = null;
+    #boundHandleKeyDown = null;
+    #boundHandleFocusIn = null;
+    // ==========================================================================
+    // Constructor
+    // ==========================================================================
+    constructor() {
+    }
+    // ==========================================================================
+    // Setup Methods
+    // ==========================================================================
+    /**
+     * Set dependencies from PresentationEditor.
+     */
+    setDependencies(deps) {
+      this.#deps = deps;
+    }
+    /**
+     * Set callbacks for events.
+     */
+    setCallbacks(callbacks2) {
+      this.#callbacks = callbacks2;
+    }
+    /**
+     * Bind event listeners to DOM elements.
+     */
+    bind() {
+      if (!this.#deps) return;
+      const viewportHost = this.#deps.getViewportHost();
+      const visibleHost = this.#deps.getVisibleHost();
+      viewportHost.ownerDocument ?? document;
+      this.#boundHandlePointerDown = this.#handlePointerDown.bind(this);
+      this.#boundHandlePointerMove = this.#handlePointerMove.bind(this);
+      this.#boundHandlePointerUp = this.#handlePointerUp.bind(this);
+      this.#boundHandlePointerLeave = this.#handlePointerLeave.bind(this);
+      this.#boundHandleDoubleClick = this.#handleDoubleClick.bind(this);
+      this.#boundHandleClick = this.#handleClick.bind(this);
+      this.#boundHandleKeyDown = this.#handleKeyDown.bind(this);
+      this.#boundHandleFocusIn = this.#handleFocusIn.bind(this);
+      viewportHost.addEventListener("pointerdown", this.#boundHandlePointerDown);
+      viewportHost.addEventListener("pointermove", this.#boundHandlePointerMove);
+      viewportHost.addEventListener("pointerup", this.#boundHandlePointerUp);
+      viewportHost.addEventListener("pointerleave", this.#boundHandlePointerLeave);
+      viewportHost.addEventListener("dblclick", this.#boundHandleDoubleClick);
+      viewportHost.addEventListener("click", this.#boundHandleClick);
+      const container = viewportHost.closest(".presentation-editor");
+      if (container) {
+        container.addEventListener("keydown", this.#boundHandleKeyDown);
+      }
+      visibleHost.addEventListener("focusin", this.#boundHandleFocusIn);
+    }
+    /**
+     * Unbind event listeners.
+     */
+    unbind() {
+      if (!this.#deps) return;
+      const viewportHost = this.#deps.getViewportHost();
+      const visibleHost = this.#deps.getVisibleHost();
+      if (this.#boundHandlePointerDown) {
+        viewportHost.removeEventListener("pointerdown", this.#boundHandlePointerDown);
+      }
+      if (this.#boundHandlePointerMove) {
+        viewportHost.removeEventListener("pointermove", this.#boundHandlePointerMove);
+      }
+      if (this.#boundHandlePointerUp) {
+        viewportHost.removeEventListener("pointerup", this.#boundHandlePointerUp);
+      }
+      if (this.#boundHandlePointerLeave) {
+        viewportHost.removeEventListener("pointerleave", this.#boundHandlePointerLeave);
+      }
+      if (this.#boundHandleDoubleClick) {
+        viewportHost.removeEventListener("dblclick", this.#boundHandleDoubleClick);
+      }
+      if (this.#boundHandleClick) {
+        viewportHost.removeEventListener("click", this.#boundHandleClick);
+      }
+      if (this.#boundHandleKeyDown) {
+        const container = viewportHost.closest(".presentation-editor");
+        if (container) {
+          container.removeEventListener("keydown", this.#boundHandleKeyDown);
+        }
+      }
+      if (this.#boundHandleFocusIn) {
+        visibleHost.removeEventListener("focusin", this.#boundHandleFocusIn);
+      }
+      this.#boundHandlePointerDown = null;
+      this.#boundHandlePointerMove = null;
+      this.#boundHandlePointerUp = null;
+      this.#boundHandlePointerLeave = null;
+      this.#boundHandleDoubleClick = null;
+      this.#boundHandleClick = null;
+      this.#boundHandleKeyDown = null;
+      this.#boundHandleFocusIn = null;
+    }
+    /**
+     * Destroy the manager and clean up.
+     */
+    destroy() {
+      this.unbind();
+      this.#deps = null;
+      this.#callbacks = {};
+      this.#clearDragState();
+      this.#clearCellAnchor();
+    }
+    // ==========================================================================
+    // Public Getters
+    // ==========================================================================
+    /** Whether currently dragging */
+    get isDragging() {
+      return this.#isDragging;
+    }
+    /** Current drag anchor position */
+    get dragAnchor() {
+      return this.#dragAnchor;
+    }
+    /** Cell anchor state for table selection */
+    get cellAnchor() {
+      return this.#cellAnchor;
+    }
+    /** Debug last pointer position */
+    get debugLastPointer() {
+      return this.#debugLastPointer;
+    }
+    /** Debug last hit */
+    get debugLastHit() {
+      return this.#debugLastHit;
+    }
+    /** Last selected image block ID */
+    get lastSelectedImageBlockId() {
+      return this.#lastSelectedImageBlockId;
+    }
+    /** Drag anchor page index */
+    get dragAnchorPageIndex() {
+      return this.#dragAnchorPageIndex;
+    }
+    /** Get the page index from the last raw hit during drag */
+    get dragLastHitPageIndex() {
+      return this.#dragLastRawHit?.pageIndex ?? null;
+    }
+    /** Get the last raw hit during drag (for finalization) */
+    get dragLastRawHit() {
+      return this.#dragLastRawHit;
+    }
+    // ==========================================================================
+    // Public Methods
+    // ==========================================================================
+    /**
+     * Clear cell anchor (used when document changes).
+     */
+    clearCellAnchor() {
+      this.#clearCellAnchor();
+    }
+    /**
+     * Set suppress focus in flag (for draggable annotations).
+     */
+    setSuppressFocusInFromDraggable(value) {
+      this.#suppressFocusInFromDraggable = value;
+    }
+    // ==========================================================================
+    // Private Helper Methods
+    // ==========================================================================
+    #clearDragState() {
+      this.#isDragging = false;
+      this.#dragAnchor = null;
+      this.#dragAnchorPageIndex = null;
+      this.#dragExtensionMode = "char";
+      this.#dragLastPointer = null;
+      this.#dragLastRawHit = null;
+      this.#dragUsedPageNotMountedFallback = false;
+    }
+    #clearCellAnchor() {
+      this.#cellAnchor = null;
+      this.#cellDragMode = "none";
+    }
+    #registerPointerClick(event) {
+      const nextState = registerPointerClick(
+        event,
+        {
+          clickCount: this.#clickCount,
+          lastClickTime: this.#lastClickTime,
+          lastClickPosition: this.#lastClickPosition ?? { x: 0, y: 0 }
+        },
+        {
+          timeThresholdMs: MULTI_CLICK_TIME_THRESHOLD_MS,
+          distanceThresholdPx: MULTI_CLICK_DISTANCE_THRESHOLD_PX,
+          maxClickCount: 3
+        }
+      );
+      this.#clickCount = nextState.clickCount;
+      this.#lastClickTime = nextState.lastClickTime;
+      this.#lastClickPosition = nextState.lastClickPosition;
+      return nextState.clickCount;
+    }
+    #getFirstTextPosition() {
+      const editor = this.#deps?.getEditor();
+      return getFirstTextPosition(editor?.state?.doc ?? null);
+    }
+    #calculateExtendedSelection(anchor, head, mode) {
+      const layoutState = this.#deps?.getLayoutState();
+      return calculateExtendedSelection(layoutState?.blocks ?? [], anchor, head, mode);
+    }
+    #shouldUseCellSelection(currentTableHit) {
+      return shouldUseCellSelection(currentTableHit, this.#cellAnchor, this.#cellDragMode);
+    }
+    #getCellPosFromTableHit(tableHit) {
+      const editor = this.#deps?.getEditor();
+      const layoutState = this.#deps?.getLayoutState();
+      return getCellPosFromTableHit(tableHit, editor?.state?.doc ?? null, layoutState?.blocks ?? []);
+    }
+    #getTablePosFromHit(tableHit) {
+      const editor = this.#deps?.getEditor();
+      const layoutState = this.#deps?.getLayoutState();
+      return getTablePosFromHit(tableHit, editor?.state?.doc ?? null, layoutState?.blocks ?? []);
+    }
+    #setCellAnchor(tableHit, tablePos) {
+      const cellPos = this.#getCellPosFromTableHit(tableHit);
+      if (cellPos === null) return;
+      this.#cellAnchor = {
+        tablePos,
+        cellPos,
+        cellRowIndex: tableHit.cellRowIndex,
+        cellColIndex: tableHit.cellColIndex,
+        tableBlockId: tableHit.block.id
+      };
+      this.#cellDragMode = "pending";
+    }
+    #hitTestTable(x2, y2) {
+      return this.#callbacks.hitTestTable?.(x2, y2) ?? null;
+    }
+    // ==========================================================================
+    // Event Handlers
+    // ==========================================================================
+    /**
+     * Handle click events - specifically for link navigation prevention.
+     *
+     * Link handling is split between pointerdown and click:
+     * - pointerdown: dispatches superdoc-link-click event (for popover/UI response)
+     * - click: prevents default navigation (preventDefault only works on click, not pointerdown)
+     *
+     * This also handles keyboard activation (Enter/Space) which triggers click but not pointerdown.
+     */
+    #handleClick(event) {
+      const target = event.target;
+      const linkEl = target?.closest?.("a.superdoc-link");
+      if (linkEl) {
+        event.preventDefault();
+        if (!event.pointerId && event.detail === 0) {
+          this.#handleLinkClick(event, linkEl);
+        }
+      }
+    }
+    #handlePointerDown(event) {
+      if (!this.#deps) return;
+      if (event.button !== 0) return;
+      if (event.ctrlKey && navigator.platform.includes("Mac")) return;
+      this.#pendingMarginClick = null;
+      const target = event.target;
+      if (target?.closest?.(".superdoc-ruler-handle") != null) return;
+      const linkEl = target?.closest?.("a.superdoc-link");
+      if (linkEl) {
+        this.#handleLinkClick(event, linkEl);
+        return;
+      }
+      const annotationEl = target?.closest?.(".annotation[data-pm-start]");
+      const isDraggableAnnotation = target?.closest?.('[data-draggable="true"]') != null;
+      this.#suppressFocusInFromDraggable = isDraggableAnnotation;
+      if (annotationEl) {
+        this.#handleAnnotationClick(event, annotationEl);
+        return;
+      }
+      const layoutState = this.#deps.getLayoutState();
+      if (!layoutState.layout) {
+        this.#handleClickWithoutLayout(event, isDraggableAnnotation);
+        return;
+      }
+      const normalizedPoint = this.#callbacks.normalizeClientPoint?.(event.clientX, event.clientY);
+      if (!normalizedPoint) return;
+      const { x: x2, y: y2 } = normalizedPoint;
+      this.#debugLastPointer = { clientX: event.clientX, clientY: event.clientY, x: x2, y: y2 };
+      const sessionMode = this.#deps.getHeaderFooterSession()?.session?.mode ?? "body";
+      if (sessionMode !== "body") {
+        if (this.#handleClickInHeaderFooterMode(event, x2, y2)) return;
+      }
+      const headerFooterRegion = this.#callbacks.hitTestHeaderFooterRegion?.(x2, y2);
+      if (headerFooterRegion) return;
+      const viewportHost = this.#deps.getViewportHost();
+      const pageGeometryHelper = this.#deps.getPageGeometryHelper();
+      const rawHit = clickToPosition(
+        layoutState.layout,
+        layoutState.blocks,
+        layoutState.measures,
+        { x: x2, y: y2 },
+        viewportHost,
+        event.clientX,
+        event.clientY,
+        pageGeometryHelper ?? void 0
+      );
+      const editor = this.#deps.getEditor();
+      const doc2 = editor.state?.doc;
+      const epochMapper = this.#deps.getEpochMapper();
+      const mapped = rawHit && doc2 ? epochMapper.mapPosFromLayoutToCurrentDetailed(rawHit.pos, rawHit.layoutEpoch, 1) : null;
+      if (mapped && !mapped.ok) {
+        debugLog("warn", "pointerdown mapping failed", mapped);
+      }
+      const hit = rawHit && doc2 && mapped?.ok ? { ...rawHit, pos: Math.max(0, Math.min(mapped.pos, doc2.content.size)), layoutEpoch: mapped.toEpoch } : null;
+      this.#debugLastHit = hit ? { source: "dom", pos: rawHit?.pos ?? null, layoutEpoch: rawHit?.layoutEpoch ?? null, mappedPos: hit.pos } : { source: "none", pos: rawHit?.pos ?? null, layoutEpoch: rawHit?.layoutEpoch ?? null, mappedPos: null };
+      this.#callbacks.updateSelectionDebugHud?.();
+      if (!isDraggableAnnotation) {
+        event.preventDefault();
+      }
+      if (!rawHit) {
+        this.#focusEditorAtFirstPosition();
+        return;
+      }
+      if (!hit || !doc2) {
+        this.#callbacks.setPendingDocChange?.();
+        this.#callbacks.scheduleRerender?.();
+        return;
+      }
+      const fragmentHit = getFragmentAtPosition(layoutState.layout, layoutState.blocks, layoutState.measures, rawHit.pos);
+      const targetImg = event.target?.closest?.("img");
+      if (this.#handleInlineImageClick(event, targetImg, rawHit, doc2, epochMapper)) return;
+      if (this.#handleFragmentClick(event, fragmentHit, hit, doc2)) return;
+      if (this.#lastSelectedImageBlockId) {
+        this.#callbacks.emit?.("imageDeselected", { blockId: this.#lastSelectedImageBlockId });
+        this.#lastSelectedImageBlockId = null;
+      }
+      if (event.shiftKey && editor.state.selection.$anchor) {
+        this.#handleShiftClick(event, hit.pos);
+        return;
+      }
+      const clickDepth = this.#registerPointerClick(event);
+      if (clickDepth === 1) {
+        this.#dragAnchor = hit.pos;
+        this.#dragAnchorPageIndex = hit.pageIndex;
+        this.#pendingMarginClick = this.#callbacks.computePendingMarginClick?.(event.pointerId, x2, y2) ?? null;
+        const tableHit = this.#hitTestTable(x2, y2);
+        if (tableHit) {
+          const tablePos = this.#getTablePosFromHit(tableHit);
+          if (tablePos !== null) {
+            this.#setCellAnchor(tableHit, tablePos);
+          }
+        } else {
+          this.#clearCellAnchor();
+        }
+      } else {
+        this.#pendingMarginClick = null;
+      }
+      this.#dragLastPointer = { clientX: event.clientX, clientY: event.clientY, x: x2, y: y2 };
+      this.#dragLastRawHit = hit;
+      this.#dragUsedPageNotMountedFallback = false;
+      this.#isDragging = true;
+      if (clickDepth >= 3) {
+        this.#dragExtensionMode = "para";
+      } else if (clickDepth === 2) {
+        this.#dragExtensionMode = "word";
+      } else {
+        this.#dragExtensionMode = "char";
+      }
+      if (typeof viewportHost.setPointerCapture === "function") {
+        viewportHost.setPointerCapture(event.pointerId);
+      }
+      let handledByDepth = false;
+      const sessionModeForDepth = this.#deps.getHeaderFooterSession()?.session?.mode ?? "body";
+      if (sessionModeForDepth === "body") {
+        const selectionPos = clickDepth >= 2 && this.#dragAnchor !== null ? this.#dragAnchor : hit.pos;
+        if (clickDepth >= 3) {
+          handledByDepth = this.#callbacks.selectParagraphAt?.(selectionPos) ?? false;
+        } else if (clickDepth === 2) {
+          handledByDepth = this.#callbacks.selectWordAt?.(selectionPos) ?? false;
+        }
+      }
+      if (!handledByDepth) {
+        try {
+          let nextSelection = TextSelection$1.create(doc2, hit.pos);
+          if (!nextSelection.$from.parent.inlineContent) {
+            nextSelection = Selection.near(doc2.resolve(hit.pos), 1);
+          }
+          const tr = editor.state.tr.setSelection(nextSelection);
+          editor.view?.dispatch(tr);
+        } catch {
+        }
+      }
+      this.#callbacks.scheduleSelectionUpdate?.();
+      this.#focusEditor();
+    }
+    #handlePointerMove(event) {
+      if (!this.#deps) return;
+      const layoutState = this.#deps.getLayoutState();
+      if (!layoutState.layout) return;
+      const normalized = this.#callbacks.normalizeClientPoint?.(event.clientX, event.clientY);
+      if (!normalized) return;
+      if (this.#isDragging && this.#dragAnchor !== null && event.buttons & 1) {
+        this.#handleDragSelection(event, normalized);
+        return;
+      }
+      this.#handleHover(normalized);
+    }
+    #handlePointerUp(event) {
+      if (!this.#deps) return;
+      this.#suppressFocusInFromDraggable = false;
+      if (!this.#isDragging) return;
+      const viewportHost = this.#deps.getViewportHost();
+      if (typeof viewportHost.hasPointerCapture === "function" && typeof viewportHost.releasePointerCapture === "function" && viewportHost.hasPointerCapture(event.pointerId)) {
+        viewportHost.releasePointerCapture(event.pointerId);
+      }
+      const pendingMarginClick = this.#pendingMarginClick;
+      this.#pendingMarginClick = null;
+      const dragAnchor = this.#dragAnchor;
+      const dragMode = this.#dragExtensionMode;
+      const dragUsedFallback = this.#dragUsedPageNotMountedFallback;
+      const dragPointer = this.#dragLastPointer;
+      this.#isDragging = false;
+      if (this.#cellDragMode !== "none") {
+        this.#cellDragMode = "none";
+      }
+      if (!pendingMarginClick || pendingMarginClick.pointerId !== event.pointerId) {
+        this.#callbacks.updateSelectionVirtualizationPins?.({ includeDragBuffer: false });
+        if (dragUsedFallback && dragAnchor != null) {
+          const pointer = dragPointer ?? { clientX: event.clientX, clientY: event.clientY };
+          this.#callbacks.finalizeDragSelectionWithDom?.(pointer, dragAnchor, dragMode);
+        }
+        this.#callbacks.scheduleA11ySelectionAnnouncement?.({ immediate: true });
+        this.#dragLastPointer = null;
+        this.#dragLastRawHit = null;
+        this.#dragUsedPageNotMountedFallback = false;
+        return;
+      }
+      this.#handleMarginClickEnd(event, pendingMarginClick);
+    }
+    #handlePointerLeave() {
+      this.#callbacks.clearHoverRegion?.();
+    }
+    #handleDoubleClick(event) {
+      if (!this.#deps) return;
+      if (event.button !== 0) return;
+      const layoutState = this.#deps.getLayoutState();
+      if (!layoutState.layout) return;
+      const viewportHost = this.#deps.getViewportHost();
+      const visibleHost = this.#deps.getVisibleHost();
+      const zoom = this.#deps.getZoom();
+      const rect = viewportHost.getBoundingClientRect();
+      const scrollLeft = visibleHost.scrollLeft ?? 0;
+      const scrollTop = visibleHost.scrollTop ?? 0;
+      const x2 = (event.clientX - rect.left + scrollLeft) / zoom;
+      const y2 = (event.clientY - rect.top + scrollTop) / zoom;
+      const region = this.#callbacks.hitTestHeaderFooterRegion?.(x2, y2);
+      if (region) {
+        event.preventDefault();
+        event.stopPropagation();
+        const descriptor = this.#callbacks.resolveDescriptorForRegion?.(region);
+        const hfManager = this.#deps.getHeaderFooterSession()?.manager;
+        if (!descriptor && hfManager) {
+          this.#callbacks.createDefaultHeaderFooter?.(region);
+          hfManager.refresh();
+        }
+        this.#callbacks.activateHeaderFooterRegion?.(region);
+      } else if ((this.#deps.getHeaderFooterSession()?.session?.mode ?? "body") !== "body") {
+        this.#callbacks.exitHeaderFooterMode?.();
+      }
+    }
+    #handleKeyDown(event) {
+      if (!this.#deps) return;
+      const sessionMode = this.#deps.getHeaderFooterSession()?.session?.mode ?? "body";
+      if (event.key === "Escape" && sessionMode !== "body") {
+        event.preventDefault();
+        this.#callbacks.exitHeaderFooterMode?.();
+        return;
+      }
+      if (event.ctrlKey && event.altKey && !event.shiftKey) {
+        if (event.code === "KeyH") {
+          event.preventDefault();
+          this.#focusHeaderFooterShortcut("header");
+        } else if (event.code === "KeyF") {
+          event.preventDefault();
+          this.#focusHeaderFooterShortcut("footer");
+        }
+      }
+    }
+    #handleFocusIn(event) {
+      if (!this.#deps) return;
+      if (this.#suppressFocusInFromDraggable) {
+        this.#suppressFocusInFromDraggable = false;
+        return;
+      }
+      try {
+        this.#deps.getActiveEditor().view?.focus();
+      } catch {
+      }
+    }
+    // ==========================================================================
+    // Handler Helpers
+    // ==========================================================================
+    #handleLinkClick(event, linkEl) {
+      const href = linkEl.getAttribute("href") ?? "";
+      const isAnchorLink = href.startsWith("#") && href.length > 1;
+      const isTocLink = linkEl.closest(".superdoc-toc-entry") !== null;
+      if (isAnchorLink && isTocLink) {
+        event.preventDefault();
+        event.stopPropagation();
+        this.#callbacks.goToAnchor?.(href);
+        return;
+      }
+      event.preventDefault();
+      event.stopPropagation();
+      const linkClickEvent = new CustomEvent("superdoc-link-click", {
+        bubbles: true,
+        composed: true,
+        detail: {
+          href,
+          target: linkEl.getAttribute("target"),
+          rel: linkEl.getAttribute("rel"),
+          tooltip: linkEl.getAttribute("title"),
+          element: linkEl,
+          clientX: event.clientX,
+          clientY: event.clientY
+        }
+      });
+      linkEl.dispatchEvent(linkClickEvent);
+    }
+    #handleAnnotationClick(event, annotationEl) {
+      const editor = this.#deps?.getEditor();
+      if (!editor?.isEditable) return;
+      const resolved = this.#callbacks.resolveFieldAnnotationSelectionFromElement?.(annotationEl);
+      if (resolved) {
+        try {
+          const tr = editor.state.tr.setSelection(NodeSelection.create(editor.state.doc, resolved.pos));
+          editor.view?.dispatch(tr);
+        } catch {
+        }
+        editor.emit("fieldAnnotationClicked", {
+          editor,
+          node: resolved.node,
+          nodePos: resolved.pos,
+          event,
+          currentTarget: annotationEl
+        });
+      }
+    }
+    #handleClickWithoutLayout(event, isDraggableAnnotation) {
+      if (!isDraggableAnnotation) {
+        event.preventDefault();
+      }
+      if (document.activeElement instanceof HTMLElement) {
+        document.activeElement.blur();
+      }
+      this.#focusEditorAtFirstPosition();
+    }
+    #handleClickInHeaderFooterMode(event, x2, y2) {
+      const session = this.#deps?.getHeaderFooterSession();
+      const activeEditorHost = session?.overlayManager?.getActiveEditorHost?.();
+      const clickedInsideEditorHost = activeEditorHost && (activeEditorHost.contains(event.target) || activeEditorHost === event.target);
+      if (clickedInsideEditorHost) {
+        return true;
+      }
+      const headerFooterRegion = this.#callbacks.hitTestHeaderFooterRegion?.(x2, y2);
+      if (!headerFooterRegion) {
+        this.#callbacks.exitHeaderFooterMode?.();
+        return false;
+      }
+      return true;
+    }
+    #handleInlineImageClick(event, targetImg, rawHit, doc2, epochMapper) {
+      if (!targetImg) return false;
+      const imgPmStart = targetImg.dataset?.pmStart ? Number(targetImg.dataset.pmStart) : null;
+      if (Number.isNaN(imgPmStart) || imgPmStart == null) return false;
+      const imgLayoutEpochRaw = targetImg.dataset?.layoutEpoch;
+      const imgLayoutEpoch = imgLayoutEpochRaw != null ? Number(imgLayoutEpochRaw) : NaN;
+      const rawLayoutEpoch = Number.isFinite(rawHit.layoutEpoch) ? rawHit.layoutEpoch : NaN;
+      const effectiveEpoch = Number.isFinite(imgLayoutEpoch) && Number.isFinite(rawLayoutEpoch) ? Math.max(imgLayoutEpoch, rawLayoutEpoch) : Number.isFinite(imgLayoutEpoch) ? imgLayoutEpoch : rawHit.layoutEpoch;
+      const mappedImg = epochMapper.mapPosFromLayoutToCurrentDetailed(imgPmStart, effectiveEpoch, 1);
+      if (!mappedImg.ok) {
+        debugLog("warn", "inline image mapping failed", mappedImg);
+        this.#callbacks.setPendingDocChange?.();
+        this.#callbacks.scheduleRerender?.();
+        return true;
+      }
+      const clampedImgPos = Math.max(0, Math.min(mappedImg.pos, doc2.content.size));
+      if (clampedImgPos < 0 || clampedImgPos >= doc2.content.size) return true;
+      const newSelectionId = `inline-${clampedImgPos}`;
+      if (this.#lastSelectedImageBlockId && this.#lastSelectedImageBlockId !== newSelectionId) {
+        this.#callbacks.emit?.("imageDeselected", { blockId: this.#lastSelectedImageBlockId });
+      }
+      const editor = this.#deps?.getEditor();
+      try {
+        const tr = editor.state.tr.setSelection(NodeSelection.create(doc2, clampedImgPos));
+        editor.view?.dispatch(tr);
+        const selector = `.superdoc-inline-image[data-pm-start="${imgPmStart}"]`;
+        const viewportHost = this.#deps?.getViewportHost();
+        const targetElement = viewportHost?.querySelector(selector);
+        this.#callbacks.emit?.("imageSelected", {
+          element: targetElement ?? targetImg,
+          blockId: null,
+          pmStart: clampedImgPos
+        });
+        this.#lastSelectedImageBlockId = newSelectionId;
+      } catch (error) {
+      }
+      this.#callbacks.focusEditorAfterImageSelection?.();
+      return true;
+    }
+    #handleFragmentClick(event, fragmentHit, hit, doc2) {
+      if (!fragmentHit) return false;
+      if (fragmentHit.fragment.kind !== "image" && fragmentHit.fragment.kind !== "drawing") return false;
+      const editor = this.#deps?.getEditor();
+      try {
+        const tr = editor.state.tr.setSelection(NodeSelection.create(doc2, hit.pos));
+        editor.view?.dispatch(tr);
+        if (this.#lastSelectedImageBlockId && this.#lastSelectedImageBlockId !== fragmentHit.fragment.blockId) {
+          this.#callbacks.emit?.("imageDeselected", { blockId: this.#lastSelectedImageBlockId });
+        }
+        if (fragmentHit.fragment.kind === "image") {
+          const viewportHost = this.#deps?.getViewportHost();
+          const targetElement = viewportHost?.querySelector(
+            `.superdoc-image-fragment[data-pm-start="${fragmentHit.fragment.pmStart}"]`
+          );
+          if (targetElement) {
+            this.#callbacks.emit?.("imageSelected", {
+              element: targetElement,
+              blockId: fragmentHit.fragment.blockId,
+              pmStart: fragmentHit.fragment.pmStart
+            });
+            this.#lastSelectedImageBlockId = fragmentHit.fragment.blockId;
+          }
+        }
+      } catch (error) {
+      }
+      this.#callbacks.focusEditorAfterImageSelection?.();
+      return true;
+    }
+    #handleShiftClick(event, headPos) {
+      const editor = this.#deps?.getEditor();
+      if (!editor) return;
+      const anchor = editor.state.selection.anchor;
+      const { selAnchor, selHead } = this.#calculateExtendedSelection(anchor, headPos, this.#dragExtensionMode);
+      try {
+        const tr = editor.state.tr.setSelection(TextSelection$1.create(editor.state.doc, selAnchor, selHead));
+        editor.view?.dispatch(tr);
+        this.#callbacks.scheduleSelectionUpdate?.();
+      } catch (error) {
+        console.warn("[SELECTION] Failed to extend selection on shift+click:", error);
+      }
+      this.#focusEditor();
+    }
+    #handleDragSelection(event, normalized) {
+      if (!this.#deps) return;
+      this.#pendingMarginClick = null;
+      this.#dragLastPointer;
+      this.#dragLastPointer = { clientX: event.clientX, clientY: event.clientY, x: normalized.x, y: normalized.y };
+      const layoutState = this.#deps.getLayoutState();
+      const viewportHost = this.#deps.getViewportHost();
+      const pageGeometryHelper = this.#deps.getPageGeometryHelper();
+      const rawHit = clickToPosition(
+        layoutState.layout,
+        layoutState.blocks,
+        layoutState.measures,
+        { x: normalized.x, y: normalized.y },
+        viewportHost,
+        event.clientX,
+        event.clientY,
+        pageGeometryHelper ?? void 0
+      );
+      if (!rawHit) return;
+      const editor = this.#deps.getEditor();
+      const doc2 = editor.state?.doc;
+      if (!doc2) return;
+      this.#dragLastRawHit = rawHit;
+      const pageMounted = this.#deps.getPageElement(rawHit.pageIndex) != null;
+      if (!pageMounted && this.#deps.isSelectionAwareVirtualizationEnabled()) {
+        this.#dragUsedPageNotMountedFallback = true;
+      }
+      this.#callbacks.updateSelectionVirtualizationPins?.({ includeDragBuffer: true, extraPages: [rawHit.pageIndex] });
+      const epochMapper = this.#deps.getEpochMapper();
+      const mappedHead = epochMapper.mapPosFromLayoutToCurrentDetailed(rawHit.pos, rawHit.layoutEpoch, 1);
+      if (!mappedHead.ok) {
+        debugLog("warn", "drag mapping failed", mappedHead);
+        return;
+      }
+      const hit = {
+        ...rawHit,
+        pos: Math.max(0, Math.min(mappedHead.pos, doc2.content.size)),
+        layoutEpoch: mappedHead.toEpoch
+      };
+      this.#debugLastHit = {
+        source: pageMounted ? "dom" : "geometry",
+        pos: rawHit.pos,
+        layoutEpoch: rawHit.layoutEpoch,
+        mappedPos: hit.pos
+      };
+      this.#callbacks.updateSelectionDebugHud?.();
+      const currentTableHit = this.#hitTestTable(normalized.x, normalized.y);
+      const shouldUseCellSel = this.#shouldUseCellSelection(currentTableHit);
+      if (shouldUseCellSel && this.#cellAnchor) {
+        this.#handleCellDragSelection(currentTableHit, hit);
+        return;
+      }
+      const anchor = this.#dragAnchor;
+      const head = hit.pos;
+      const { selAnchor, selHead } = this.#calculateExtendedSelection(anchor, head, this.#dragExtensionMode);
+      try {
+        const tr = editor.state.tr.setSelection(TextSelection$1.create(editor.state.doc, selAnchor, selHead));
+        editor.view?.dispatch(tr);
+        this.#callbacks.scheduleSelectionUpdate?.();
+      } catch (error) {
+        console.warn("[SELECTION] Failed to extend selection during drag:", error);
+      }
+    }
+    #handleCellDragSelection(currentTableHit, hit) {
+      const headCellPos = currentTableHit ? this.#getCellPosFromTableHit(currentTableHit) : null;
+      if (headCellPos === null) return;
+      if (this.#cellDragMode !== "active") {
+        this.#cellDragMode = "active";
+      }
+      const editor = this.#deps?.getEditor();
+      if (!editor) return;
+      try {
+        const doc2 = editor.state.doc;
+        const anchorCellPos = this.#cellAnchor.cellPos;
+        const clampedAnchor = Math.max(0, Math.min(anchorCellPos, doc2.content.size));
+        const clampedHead = Math.max(0, Math.min(headCellPos, doc2.content.size));
+        const cellSelection = CellSelection.create(doc2, clampedAnchor, clampedHead);
+        const tr = editor.state.tr.setSelection(cellSelection);
+        editor.view?.dispatch(tr);
+        this.#callbacks.scheduleSelectionUpdate?.();
+      } catch (error) {
+        console.warn("[CELL-SELECTION] Failed to create CellSelection, falling back to TextSelection:", error);
+        const anchor = this.#dragAnchor;
+        const head = hit.pos;
+        const { selAnchor, selHead } = this.#calculateExtendedSelection(anchor, head, this.#dragExtensionMode);
+        try {
+          const tr = editor.state.tr.setSelection(TextSelection$1.create(editor.state.doc, selAnchor, selHead));
+          editor.view?.dispatch(tr);
+          this.#callbacks.scheduleSelectionUpdate?.();
+        } catch {
+        }
+      }
+    }
+    #handleHover(normalized) {
+      if (!this.#deps) return;
+      const sessionMode = this.#deps.getHeaderFooterSession()?.session?.mode ?? "body";
+      if (sessionMode !== "body") {
+        this.#callbacks.clearHoverRegion?.();
+        return;
+      }
+      if (this.#deps.getDocumentMode() === "viewing") {
+        this.#callbacks.clearHoverRegion?.();
+        return;
+      }
+      const region = this.#callbacks.hitTestHeaderFooterRegion?.(normalized.x, normalized.y);
+      if (!region) {
+        this.#callbacks.clearHoverRegion?.();
+        return;
+      }
+      const currentHover = this.#deps.getHeaderFooterSession()?.hoverRegion;
+      if (currentHover && currentHover.kind === region.kind && currentHover.pageIndex === region.pageIndex && currentHover.sectionType === region.sectionType) {
+        return;
+      }
+      this.#deps.getHeaderFooterSession()?.renderHover(region);
+      this.#callbacks.renderHoverRegion?.(region);
+    }
+    #handleMarginClickEnd(event, pendingMarginClick) {
+      const sessionMode = this.#deps?.getHeaderFooterSession()?.session?.mode ?? "body";
+      if (sessionMode !== "body" || this.#deps?.isViewLocked()) {
+        this.#clearDragPointerState();
+        return;
+      }
+      const editor = this.#deps?.getEditor();
+      const doc2 = editor?.state?.doc;
+      if (!doc2) {
+        this.#clearDragPointerState();
+        return;
+      }
+      const epochMapper = this.#deps?.getEpochMapper();
+      if (!epochMapper) {
+        this.#clearDragPointerState();
+        return;
+      }
+      if (pendingMarginClick.kind === "aboveFirstLine") {
+        const pos = this.#getFirstTextPosition();
+        try {
+          const tr = editor.state.tr.setSelection(TextSelection$1.create(doc2, pos));
+          editor.view?.dispatch(tr);
+          this.#callbacks.scheduleSelectionUpdate?.();
+        } catch {
+        }
+        this.#debugLastHit = { source: "margin", pos: null, layoutEpoch: null, mappedPos: pos };
+        this.#callbacks.updateSelectionDebugHud?.();
+        this.#clearDragPointerState();
+        return;
+      }
+      if (pendingMarginClick.kind === "right") {
+        const mappedEnd2 = epochMapper.mapPosFromLayoutToCurrentDetailed(
+          pendingMarginClick.pmEnd,
+          pendingMarginClick.layoutEpoch,
+          1
+        );
+        if (!mappedEnd2.ok) {
+          this.#callbacks.setPendingDocChange?.();
+          this.#callbacks.scheduleRerender?.();
+          this.#clearDragPointerState();
+          return;
+        }
+        const caretPos = Math.max(0, Math.min(mappedEnd2.pos, doc2.content.size));
+        try {
+          const tr = editor.state.tr.setSelection(TextSelection$1.create(doc2, caretPos));
+          editor.view?.dispatch(tr);
+          this.#callbacks.scheduleSelectionUpdate?.();
+        } catch {
+        }
+        this.#debugLastHit = {
+          source: "margin",
+          pos: pendingMarginClick.pmEnd,
+          layoutEpoch: pendingMarginClick.layoutEpoch,
+          mappedPos: caretPos
+        };
+        this.#callbacks.updateSelectionDebugHud?.();
+        this.#clearDragPointerState();
+        return;
+      }
+      const mappedStart = epochMapper.mapPosFromLayoutToCurrentDetailed(
+        pendingMarginClick.pmStart,
+        pendingMarginClick.layoutEpoch,
+        1
+      );
+      const mappedEnd = epochMapper.mapPosFromLayoutToCurrentDetailed(
+        pendingMarginClick.pmEnd,
+        pendingMarginClick.layoutEpoch,
+        -1
+      );
+      if (!mappedStart.ok || !mappedEnd.ok) {
+        this.#callbacks.setPendingDocChange?.();
+        this.#callbacks.scheduleRerender?.();
+        this.#clearDragPointerState();
+        return;
+      }
+      const selFrom = Math.max(0, Math.min(Math.min(mappedStart.pos, mappedEnd.pos), doc2.content.size));
+      const selTo = Math.max(0, Math.min(Math.max(mappedStart.pos, mappedEnd.pos), doc2.content.size));
+      try {
+        const tr = editor.state.tr.setSelection(TextSelection$1.create(doc2, selFrom, selTo));
+        editor.view?.dispatch(tr);
+        this.#callbacks.scheduleSelectionUpdate?.();
+      } catch {
+      }
+      this.#debugLastHit = {
+        source: "margin",
+        pos: pendingMarginClick.pmStart,
+        layoutEpoch: pendingMarginClick.layoutEpoch,
+        mappedPos: selFrom
+      };
+      this.#callbacks.updateSelectionDebugHud?.();
+      this.#clearDragPointerState();
+    }
+    #clearDragPointerState() {
+      this.#dragLastPointer = null;
+      this.#dragLastRawHit = null;
+      this.#dragUsedPageNotMountedFallback = false;
+    }
+    #focusHeaderFooterShortcut(kind) {
+      const pageIndex = this.#callbacks.getCurrentPageIndex?.() ?? 0;
+      const region = this.#callbacks.findRegionForPage?.(kind, pageIndex);
+      if (!region) {
+        this.#callbacks.emitHeaderFooterEditBlocked?.("missingRegion");
+        return;
+      }
+      this.#callbacks.activateHeaderFooterRegion?.(region);
+    }
+    #focusEditorAtFirstPosition() {
+      const editor = this.#deps?.getEditor();
+      const editorDom = editor?.view?.dom;
+      if (!editorDom) return;
+      const validPos = this.#getFirstTextPosition();
+      const doc2 = editor?.state?.doc;
+      if (doc2) {
+        try {
+          const tr = editor.state.tr.setSelection(TextSelection$1.create(doc2, validPos));
+          editor.view?.dispatch(tr);
+        } catch {
+        }
+      }
+      editorDom.focus();
+      editor?.view?.focus();
+      this.#callbacks.scheduleSelectionUpdate?.();
+    }
+    #focusEditor() {
+      if (document.activeElement instanceof HTMLElement) {
+        document.activeElement.blur();
+      }
+      const editor = this.#deps?.getEditor();
+      const editorDom = editor?.view?.dom;
+      if (editorDom) {
+        editorDom.focus();
+        editor?.view?.focus();
+      }
+    }
+  }
+  const createDefaultScheduler = () => {
+    if (typeof window !== "undefined" && typeof window.requestAnimationFrame === "function") {
+      return {
+        requestAnimationFrame: (cb) => window.requestAnimationFrame(cb),
+        cancelAnimationFrame: (handle2) => window.cancelAnimationFrame(handle2)
+      };
+    }
+    const anyGlobal = globalThis;
+    if (typeof anyGlobal.requestAnimationFrame === "function" && typeof anyGlobal.cancelAnimationFrame === "function") {
+      return {
+        requestAnimationFrame: (cb) => anyGlobal.requestAnimationFrame(cb),
+        cancelAnimationFrame: (handle2) => anyGlobal.cancelAnimationFrame(handle2)
+      };
+    }
+    return {
+      requestAnimationFrame: (cb) => {
+        const handle2 = anyGlobal.setTimeout?.(() => cb(Date.now()), 0);
+        return handle2;
+      },
+      cancelAnimationFrame: (handle2) => {
+        anyGlobal.clearTimeout?.(handle2);
+      }
+    };
+  };
+  class SelectionSyncCoordinator extends EventEmitter$1 {
+    #docEpoch = 0;
+    #layoutEpoch = 0;
+    #layoutUpdating = false;
+    #pending = false;
+    #scheduled = false;
+    #rafHandle = null;
+    #scheduler;
+    /**
+     * Creates a new SelectionSyncCoordinator.
+     *
+     * @param options - Configuration options
+     * @param options.scheduler - Custom scheduler for animation frames (useful for testing), defaults to platform scheduler
+     */
+    constructor(options) {
+      super();
+      this.#scheduler = options?.scheduler ?? createDefaultScheduler();
+    }
+    /**
+     * Gets the current document epoch.
+     *
+     * @returns The document epoch (increments on each document-changing transaction)
+     */
+    getDocEpoch() {
+      return this.#docEpoch;
+    }
+    /**
+     * Gets the current layout epoch.
+     *
+     * @returns The epoch of the document version currently painted in the DOM
+     */
+    getLayoutEpoch() {
+      return this.#layoutEpoch;
+    }
+    /**
+     * Checks if a layout update is currently in progress.
+     *
+     * @returns True if between onLayoutStart() and onLayoutComplete(), false otherwise
+     */
+    isLayoutUpdating() {
+      return this.#layoutUpdating;
+    }
+    /**
+     * Updates the document epoch and triggers conditional rendering.
+     *
+     * @param epoch - The new document epoch (must be finite and non-negative)
+     *
+     * @remarks
+     * When the document epoch changes:
+     * 1. Any scheduled render is cancelled (layout will be out of sync)
+     * 2. If layout has already caught up, rendering is rescheduled
+     *
+     * Calling with the same epoch as the current value is a no-op.
+     * Invalid epoch values are silently ignored.
+     */
+    setDocEpoch(epoch) {
+      if (!Number.isFinite(epoch) || epoch < 0) return;
+      if (epoch === this.#docEpoch) return;
+      this.#docEpoch = epoch;
+      this.#cancelScheduledRender();
+      this.#maybeSchedule();
+    }
+    /**
+     * Notifies the coordinator that layout computation has started.
+     *
+     * @remarks
+     * Marks the layout as updating and cancels any scheduled renders, since the DOM
+     * is about to change and current position data will be stale.
+     *
+     * Safe to call multiple times (e.g., if layouts overlap) - subsequent calls are ignored
+     * until onLayoutComplete() is called.
+     */
+    onLayoutStart() {
+      if (this.#layoutUpdating) return;
+      this.#layoutUpdating = true;
+      this.#cancelScheduledRender();
+    }
+    /**
+     * Notifies the coordinator that layout painting has completed.
+     *
+     * @param layoutEpoch - The document epoch that was just painted to the DOM
+     *
+     * @remarks
+     * Marks the layout as no longer updating, records the new layout epoch, and attempts
+     * to schedule rendering if conditions are now safe.
+     *
+     * If the layoutEpoch is invalid (not a finite non-negative number), it is ignored and
+     * the previous layoutEpoch value is retained.
+     *
+     * This method is the primary trigger for selection rendering - if there's a pending
+     * render request and layoutEpoch >= docEpoch, a render event will be scheduled.
+     */
+    onLayoutComplete(layoutEpoch) {
+      this.#layoutUpdating = false;
+      if (Number.isFinite(layoutEpoch) && layoutEpoch >= 0) {
+        this.#layoutEpoch = layoutEpoch;
+      }
+      this.#maybeSchedule();
+    }
+    /**
+     * Notifies the coordinator that layout was aborted without completing.
+     *
+     * @remarks
+     * Marks the layout as no longer updating (without updating layoutEpoch) and attempts
+     * to schedule rendering if conditions are safe.
+     *
+     * Use this when layout computation is cancelled or fails partway through.
+     */
+    onLayoutAbort() {
+      this.#layoutUpdating = false;
+      this.#maybeSchedule();
+    }
+    /**
+     * Requests that selection rendering occur when conditions become safe.
+     *
+     * @param options - Rendering options
+     * @param options.immediate - If true, attempts to render immediately (synchronously) if safe, defaults to false
+     *
+     * @remarks
+     * Marks a render as pending and schedules it to occur on the next animation frame if
+     * conditions are safe (layout not updating, layoutEpoch >= docEpoch).
+     *
+     * If options.immediate is true, also attempts a synchronous render before scheduling.
+     * Use immediate rendering sparingly, as it can cause multiple renders per frame.
+     *
+     * Multiple calls are coalesced - only one render will occur per animation frame.
+     */
+    requestRender(options) {
+      this.#pending = true;
+      if (options?.immediate) {
+        this.flushNow();
+      }
+      this.#maybeSchedule();
+    }
+    /**
+     * Attempts to render selection immediately (synchronously) if conditions are safe.
+     *
+     * @remarks
+     * If there's a pending render request and conditions are safe (layout not updating,
+     * layoutEpoch >= docEpoch), this method:
+     * 1. Cancels any scheduled asynchronous render
+     * 2. Clears the pending flag
+     * 3. Emits the 'render' event synchronously
+     *
+     * If no render is pending or conditions are not safe, this is a no-op.
+     *
+     * Use this for immediate selection updates in response to user actions (e.g., click
+     * handlers) where waiting for the next animation frame would cause noticeable lag.
+     */
+    flushNow() {
+      if (!this.#pending) return;
+      if (!this.#isSafeToRender()) return;
+      this.#cancelScheduledRender();
+      this.#pending = false;
+      this.emit("render", { docEpoch: this.#docEpoch, layoutEpoch: this.#layoutEpoch });
+    }
+    /**
+     * Permanently tears down the coordinator, cancelling pending renders and removing all listeners.
+     *
+     * @remarks
+     * After calling destroy(), this instance should not be used again. All scheduled renders
+     * are cancelled and all event listeners are removed.
+     *
+     * Safe to call multiple times.
+     */
+    destroy() {
+      this.#cancelScheduledRender();
+      this.removeAllListeners();
+    }
+    #isSafeToRender() {
+      return !this.#layoutUpdating && this.#layoutEpoch >= this.#docEpoch;
+    }
+    #maybeSchedule() {
+      if (!this.#pending) return;
+      if (!this.#isSafeToRender()) return;
+      if (this.#scheduled) return;
+      this.#scheduled = true;
+      this.#rafHandle = this.#scheduler.requestAnimationFrame(() => {
+        this.#scheduled = false;
+        this.#rafHandle = null;
+        if (!this.#pending) return;
+        if (!this.#isSafeToRender()) return;
+        this.#pending = false;
+        this.emit("render", { docEpoch: this.#docEpoch, layoutEpoch: this.#layoutEpoch });
+      });
+    }
+    #cancelScheduledRender() {
+      if (this.#rafHandle != null) {
+        try {
+          this.#scheduler.cancelAnimationFrame(this.#rafHandle);
+        } finally {
+          this.#rafHandle = null;
+        }
+      }
+      this.#scheduled = false;
+    }
+  }
+  const uiSurfaces = /* @__PURE__ */ new WeakSet();
+  function isInRegisteredSurface(event) {
     const path2 = typeof event.composedPath === "function" ? event.composedPath() : [];
     if (path2.length > 0) {
       for (const node22 of path2) {
@@ -91500,37 +92429,6 @@ ${o}
       return event.key.length === 1 && !event.ctrlKey && !event.metaKey && !event.altKey;
     }
   }
-  const WORD_CHARACTER_REGEX = /[\p{L}\p{N}'\u2018\u2019_~-]/u;
-  function isWordCharacter(char) {
-    if (!char) {
-      return false;
-    }
-    return WORD_CHARACTER_REGEX.test(char);
-  }
-  function calculateExtendedSelection(blocks2, anchor, head, mode) {
-    if (mode === "word") {
-      const anchorBounds = findWordBoundaries(blocks2, anchor);
-      const headBounds = findWordBoundaries(blocks2, head);
-      if (anchorBounds && headBounds) {
-        if (head >= anchor) {
-          return { selAnchor: anchorBounds.from, selHead: headBounds.to };
-        } else {
-          return { selAnchor: anchorBounds.to, selHead: headBounds.from };
-        }
-      }
-    } else if (mode === "para") {
-      const anchorBounds = findParagraphBoundaries(blocks2, anchor);
-      const headBounds = findParagraphBoundaries(blocks2, head);
-      if (anchorBounds && headBounds) {
-        if (head >= anchor) {
-          return { selAnchor: anchorBounds.from, selHead: headBounds.to };
-        } else {
-          return { selAnchor: anchorBounds.to, selHead: headBounds.from };
-        }
-      }
-    }
-    return { selAnchor: anchor, selHead: head };
-  }
   function getAtomNodeTypes(schema) {
     if (!schema) return [];
     const types2 = [];
@@ -91586,104 +92484,6 @@ ${o}
     if (!ok2) return null;
     return map2;
   }
-  function registerPointerClick(event, previous2, options) {
-    const time2 = event.timeStamp ?? performance.now();
-    const timeDelta = time2 - previous2.lastClickTime;
-    const withinTime = timeDelta <= options.timeThresholdMs;
-    const distanceX = Math.abs(event.clientX - previous2.lastClickPosition.x);
-    const distanceY = Math.abs(event.clientY - previous2.lastClickPosition.y);
-    const withinDistance = distanceX <= options.distanceThresholdPx && distanceY <= options.distanceThresholdPx;
-    const clickCount = withinTime && withinDistance ? Math.min(previous2.clickCount + 1, options.maxClickCount) : 1;
-    return {
-      clickCount,
-      lastClickTime: time2,
-      lastClickPosition: { x: event.clientX, y: event.clientY }
-    };
-  }
-  function getFirstTextPosition(doc2) {
-    if (!doc2 || !doc2.content) {
-      return 1;
-    }
-    let validPos = 1;
-    doc2.nodesBetween(0, doc2.content.size, (node2, pos) => {
-      if (node2.isTextblock) {
-        validPos = pos + 1;
-        return false;
-      }
-      return true;
-    });
-    return validPos;
-  }
-  function computeWordSelectionRangeAt(state, pos) {
-    if (!state?.doc) {
-      return null;
-    }
-    if (pos < 0 || pos > state.doc.content.size) {
-      return null;
-    }
-    const textblockPos = findNearestTextblockResolvedPos(state.doc, pos);
-    if (!textblockPos) {
-      return null;
-    }
-    const parentStart = textblockPos.start();
-    const parentEnd = textblockPos.end();
-    const sampleEnd = Math.min(pos + 1, parentEnd);
-    const charAtPos = state.doc.textBetween(pos, sampleEnd, "\0", "\0");
-    if (!isWordCharacter(charAtPos)) {
-      return null;
-    }
-    let startPos = pos;
-    while (startPos > parentStart) {
-      const prevChar = state.doc.textBetween(startPos - 1, startPos, "\0", "\0");
-      if (!isWordCharacter(prevChar)) {
-        break;
-      }
-      startPos -= 1;
-    }
-    let endPos = pos;
-    while (endPos < parentEnd) {
-      const nextChar = state.doc.textBetween(endPos, endPos + 1, "\0", "\0");
-      if (!isWordCharacter(nextChar)) {
-        break;
-      }
-      endPos += 1;
-    }
-    if (startPos === endPos) {
-      return null;
-    }
-    return { from: startPos, to: endPos };
-  }
-  function computeParagraphSelectionRangeAt(state, pos) {
-    if (!state?.doc) {
-      return null;
-    }
-    const textblockPos = findNearestTextblockResolvedPos(state.doc, pos);
-    if (!textblockPos) {
-      return null;
-    }
-    return { from: textblockPos.start(), to: textblockPos.end() };
-  }
-  function findNearestTextblockResolvedPos(doc2, pos) {
-    const $pos = doc2.resolve(pos);
-    let textblockPos = $pos;
-    while (textblockPos.depth > 0) {
-      if (textblockPos.parent?.isTextblock) {
-        break;
-      }
-      if (!textblockPos.parent || textblockPos.depth === 0) {
-        break;
-      }
-      const beforePos = textblockPos.before();
-      if (beforePos < 0 || beforePos > doc2.content.size) {
-        return null;
-      }
-      textblockPos = doc2.resolve(beforePos);
-    }
-    if (!textblockPos.parent?.isTextblock) {
-      return null;
-    }
-    return textblockPos;
-  }
   function syncHiddenEditorA11yAttributes(pmDom, documentMode) {
     const element2 = pmDom;
     if (!(element2 instanceof HTMLElement)) return;
@@ -92353,314 +93153,255 @@ ${o}
     }
     return true;
   }
-  function getCellPosFromTableHit(tableHit, doc2, blocks2) {
-    if (!tableHit || !tableHit.block || typeof tableHit.block.id !== "string") {
-      console.warn("[getCellPosFromTableHit] Invalid tableHit input:", tableHit);
-      return null;
-    }
-    if (typeof tableHit.cellRowIndex !== "number" || typeof tableHit.cellColIndex !== "number" || tableHit.cellRowIndex < 0 || tableHit.cellColIndex < 0) {
-      console.warn("[getCellPosFromTableHit] Invalid cell indices:", {
-        row: tableHit.cellRowIndex,
-        col: tableHit.cellColIndex
-      });
-      return null;
-    }
-    if (!doc2) return null;
-    const tableBlocks = blocks2.filter((b2) => b2.kind === "table");
-    const targetTableIndex = tableBlocks.findIndex((b2) => b2.id === tableHit.block.id);
-    if (targetTableIndex === -1) return null;
-    let tablePos = null;
-    let currentTableIndex = 0;
-    try {
-      doc2.descendants((node2, pos) => {
-        if (node2.type.name === "table") {
-          if (currentTableIndex === targetTableIndex) {
-            tablePos = pos;
-            return false;
-          }
-          currentTableIndex++;
-        }
-        return true;
-      });
-    } catch (error) {
-      console.error("[getCellPosFromTableHit] Error during document traversal:", error);
-      return null;
-    }
-    if (tablePos === null) return null;
-    const tableNode = doc2.nodeAt(tablePos);
-    if (!tableNode || tableNode.type.name !== "table") return null;
-    const targetRowIndex = tableHit.cellRowIndex;
-    const targetColIndex = tableHit.cellColIndex;
-    if (targetRowIndex >= tableNode.childCount) {
-      console.warn("[getCellPosFromTableHit] Target row index out of bounds:", {
-        targetRowIndex,
-        tableChildCount: tableNode.childCount
-      });
-      return null;
-    }
-    let currentPos = tablePos + 1;
-    for (let r2 = 0; r2 < tableNode.childCount && r2 <= targetRowIndex; r2++) {
-      const row2 = tableNode.child(r2);
-      if (r2 === targetRowIndex) {
-        currentPos += 1;
-        let logicalCol = 0;
-        for (let cellIndex = 0; cellIndex < row2.childCount; cellIndex++) {
-          const cell2 = row2.child(cellIndex);
-          const rawColspan = cell2.attrs?.colspan;
-          const colspan = typeof rawColspan === "number" && Number.isFinite(rawColspan) && rawColspan > 0 ? rawColspan : 1;
-          if (targetColIndex >= logicalCol && targetColIndex < logicalCol + colspan) {
-            return currentPos;
-          }
-          currentPos += cell2.nodeSize;
-          logicalCol += colspan;
-        }
-        console.warn("[getCellPosFromTableHit] Target column not found in row:", {
-          targetColIndex,
-          logicalColReached: logicalCol,
-          rowCellCount: row2.childCount
-        });
-        return null;
-      } else {
-        currentPos += row2.nodeSize;
+  const INTERNAL_MIME_TYPE = "application/x-field-annotation";
+  const FIELD_ANNOTATION_DATA_TYPE = "fieldAnnotation";
+  function isValidFieldAnnotationAttributes(attrs) {
+    if (!attrs || typeof attrs !== "object") return false;
+    const a2 = attrs;
+    return typeof a2.fieldId === "string" && typeof a2.fieldType === "string" && typeof a2.displayLabel === "string" && typeof a2.type === "string";
+  }
+  function parseIntSafe$1(value) {
+    if (!value) return void 0;
+    const parsed = parseInt(value, 10);
+    return Number.isFinite(parsed) ? parsed : void 0;
+  }
+  function extractFieldAnnotationData(element2) {
+    const dataset = element2.dataset;
+    const attributes = {};
+    for (const key2 in dataset) {
+      const value = dataset[key2];
+      if (value !== void 0) {
+        attributes[key2] = value;
       }
     }
-    return null;
+    return {
+      fieldId: dataset.fieldId,
+      fieldType: dataset.fieldType,
+      variant: dataset.variant ?? dataset.type,
+      displayLabel: dataset.displayLabel,
+      pmStart: parseIntSafe$1(dataset.pmStart),
+      pmEnd: parseIntSafe$1(dataset.pmEnd),
+      attributes
+    };
   }
-  function getTablePosFromHit(tableHit, doc2, blocks2) {
-    if (!doc2) return null;
-    const tableBlocks = blocks2.filter((b2) => b2.kind === "table");
-    const targetTableIndex = tableBlocks.findIndex((b2) => b2.id === tableHit.block.id);
-    if (targetTableIndex === -1) return null;
-    let tablePos = null;
-    let currentTableIndex = 0;
-    doc2.descendants((node2, pos) => {
-      if (node2.type.name === "table") {
-        if (currentTableIndex === targetTableIndex) {
-          tablePos = pos;
-          return false;
-        }
-        currentTableIndex++;
-      }
-      return true;
-    });
-    return tablePos;
+  function hasFieldAnnotationData(event) {
+    if (!event.dataTransfer) return false;
+    const types2 = event.dataTransfer.types;
+    return types2.includes(INTERNAL_MIME_TYPE) || types2.includes(FIELD_ANNOTATION_DATA_TYPE);
   }
-  function shouldUseCellSelection(currentTableHit, cellAnchor, cellDragMode) {
-    if (!cellAnchor) return false;
-    if (!currentTableHit) return cellDragMode === "active";
-    if (currentTableHit.block.id !== cellAnchor.tableBlockId) {
-      return cellDragMode === "active";
-    }
-    const sameCell = currentTableHit.cellRowIndex === cellAnchor.cellRowIndex && currentTableHit.cellColIndex === cellAnchor.cellColIndex;
-    if (!sameCell) {
-      return true;
-    }
-    return cellDragMode === "active";
+  function isInternalDrag(event) {
+    return event.dataTransfer?.types?.includes(INTERNAL_MIME_TYPE) ?? false;
   }
-  function hitTestTable(layout, blocks2, measures, normalizedX, normalizedY, configuredPageHeight, pageGapFallback, geometryHelper) {
-    if (!layout) {
+  function extractDragData(event) {
+    if (!event.dataTransfer) return null;
+    let jsonData = event.dataTransfer.getData(INTERNAL_MIME_TYPE);
+    if (!jsonData) {
+      jsonData = event.dataTransfer.getData(FIELD_ANNOTATION_DATA_TYPE);
+    }
+    if (!jsonData) return null;
+    try {
+      const parsed = JSON.parse(jsonData);
+      return parsed.sourceField ?? parsed.attributes ?? parsed;
+    } catch {
       return null;
     }
-    let pageY = 0;
-    let pageHit = null;
-    if (geometryHelper) {
-      const idx = geometryHelper.getPageIndexAtY(normalizedY) ?? geometryHelper.getNearestPageIndex(normalizedY);
-      if (idx != null && layout.pages[idx]) {
-        pageHit = { pageIndex: idx, page: layout.pages[idx] };
-        pageY = geometryHelper.getPageTop(idx);
-      }
+  }
+  class DragDropManager {
+    #deps = null;
+    // Bound handlers for cleanup
+    #boundHandleDragStart = null;
+    #boundHandleDragOver = null;
+    #boundHandleDrop = null;
+    #boundHandleDragEnd = null;
+    #boundHandleDragLeave = null;
+    #boundHandleWindowDragOver = null;
+    #boundHandleWindowDrop = null;
+    // ==========================================================================
+    // Setup
+    // ==========================================================================
+    setDependencies(deps) {
+      this.#deps = deps;
     }
-    if (!pageHit) {
-      const gap = layout.pageGap ?? pageGapFallback;
-      for (let i2 = 0; i2 < layout.pages.length; i2++) {
-        const page = layout.pages[i2];
-        const pageHeight = page.size?.h ?? configuredPageHeight;
-        if (normalizedY >= pageY && normalizedY < pageY + pageHeight) {
-          pageHit = { pageIndex: i2, page };
-          break;
-        }
-        pageY += pageHeight + gap;
-      }
+    bind() {
+      if (!this.#deps) return;
+      const viewportHost = this.#deps.getViewportHost();
+      const painterHost = this.#deps.getPainterHost();
+      this.#boundHandleDragStart = this.#handleDragStart.bind(this);
+      this.#boundHandleDragOver = this.#handleDragOver.bind(this);
+      this.#boundHandleDrop = this.#handleDrop.bind(this);
+      this.#boundHandleDragEnd = this.#handleDragEnd.bind(this);
+      this.#boundHandleDragLeave = this.#handleDragLeave.bind(this);
+      this.#boundHandleWindowDragOver = this.#handleWindowDragOver.bind(this);
+      this.#boundHandleWindowDrop = this.#handleWindowDrop.bind(this);
+      painterHost.addEventListener("dragstart", this.#boundHandleDragStart);
+      painterHost.addEventListener("dragend", this.#boundHandleDragEnd);
+      painterHost.addEventListener("dragleave", this.#boundHandleDragLeave);
+      viewportHost.addEventListener("dragover", this.#boundHandleDragOver);
+      viewportHost.addEventListener("drop", this.#boundHandleDrop);
+      window.addEventListener("dragover", this.#boundHandleWindowDragOver, false);
+      window.addEventListener("drop", this.#boundHandleWindowDrop, false);
+    }
+    unbind() {
+      if (!this.#deps) return;
+      const viewportHost = this.#deps.getViewportHost();
+      const painterHost = this.#deps.getPainterHost();
+      if (this.#boundHandleDragStart) {
+        painterHost.removeEventListener("dragstart", this.#boundHandleDragStart);
+      }
+      if (this.#boundHandleDragEnd) {
+        painterHost.removeEventListener("dragend", this.#boundHandleDragEnd);
+      }
+      if (this.#boundHandleDragLeave) {
+        painterHost.removeEventListener("dragleave", this.#boundHandleDragLeave);
+      }
+      if (this.#boundHandleDragOver) {
+        viewportHost.removeEventListener("dragover", this.#boundHandleDragOver);
+      }
+      if (this.#boundHandleDrop) {
+        viewportHost.removeEventListener("drop", this.#boundHandleDrop);
+      }
+      if (this.#boundHandleWindowDragOver) {
+        window.removeEventListener("dragover", this.#boundHandleWindowDragOver, false);
+      }
+      if (this.#boundHandleWindowDrop) {
+        window.removeEventListener("drop", this.#boundHandleWindowDrop, false);
+      }
+      this.#boundHandleDragStart = null;
+      this.#boundHandleDragOver = null;
+      this.#boundHandleDrop = null;
+      this.#boundHandleDragEnd = null;
+      this.#boundHandleDragLeave = null;
+      this.#boundHandleWindowDragOver = null;
+      this.#boundHandleWindowDrop = null;
     }
-    if (!pageHit) {
-      return null;
+    destroy() {
+      this.unbind();
+      this.#deps = null;
     }
-    const pageRelativeY = normalizedY - pageY;
-    const point2 = { x: normalizedX, y: pageRelativeY };
-    return hitTestTableFragment(pageHit, blocks2, measures, point2);
-  }
-  function isValidFieldAnnotationAttributes(attrs) {
-    if (!attrs || typeof attrs !== "object") return false;
-    const a2 = attrs;
-    return typeof a2.fieldId === "string" && typeof a2.fieldType === "string" && typeof a2.displayLabel === "string" && typeof a2.type === "string";
-  }
-  const FIELD_ANNOTATION_DATA_TYPE = "fieldAnnotation";
-  function setupInternalFieldAnnotationDragHandlers({
-    painterHost,
-    getActiveEditor,
-    hitTest,
-    scheduleSelectionUpdate
-  }) {
-    return createDragHandler(painterHost, {
-      onDragOver: (event) => {
-        if (!event.hasFieldAnnotation || event.event.clientX === 0) {
-          return;
-        }
-        const activeEditor = getActiveEditor();
-        if (!activeEditor?.isEditable) {
-          return;
-        }
-        const hit = hitTest(event.clientX, event.clientY);
-        const doc2 = activeEditor.state?.doc;
-        if (!hit || !doc2) {
-          return;
-        }
-        const pos = Math.min(Math.max(hit.pos, 1), doc2.content.size);
-        const currentSelection = activeEditor.state.selection;
-        if (currentSelection instanceof TextSelection$1 && currentSelection.from === pos && currentSelection.to === pos) {
-          return;
-        }
-        try {
-          const tr = activeEditor.state.tr.setSelection(TextSelection$1.create(doc2, pos)).setMeta("addToHistory", false);
-          activeEditor.view?.dispatch(tr);
-          scheduleSelectionUpdate();
-        } catch {
-        }
-      },
-      onDrop: (event) => {
-        event.event.preventDefault();
-        event.event.stopPropagation();
-        if (event.pmPosition === null) {
-          return;
-        }
-        const activeEditor = getActiveEditor();
-        const { state, view } = activeEditor;
-        if (!state || !view) {
-          return;
-        }
-        const fieldId = event.data.fieldId;
-        if (fieldId) {
-          const targetPos = event.pmPosition;
-          const pmStart = event.data.pmStart;
-          let sourceStart = null;
-          let sourceEnd = null;
-          let sourceNode = null;
-          if (pmStart != null) {
-            const nodeAt = state.doc.nodeAt(pmStart);
-            if (nodeAt?.type?.name === "fieldAnnotation") {
-              sourceStart = pmStart;
-              sourceEnd = pmStart + nodeAt.nodeSize;
-              sourceNode = nodeAt;
-            }
-          }
-          if (sourceStart == null || sourceEnd == null || !sourceNode) {
-            state.doc.descendants((node2, pos) => {
-              if (node2.type.name === "fieldAnnotation" && node2.attrs.fieldId === fieldId) {
-                sourceStart = pos;
-                sourceEnd = pos + node2.nodeSize;
-                sourceNode = node2;
-                return false;
-              }
-              return true;
-            });
-          }
-          if (sourceStart === null || sourceEnd === null || !sourceNode) {
-            return;
-          }
-          if (targetPos >= sourceStart && targetPos <= sourceEnd) {
-            return;
-          }
-          const tr = state.tr;
-          tr.delete(sourceStart, sourceEnd);
-          const mappedTarget = tr.mapping.map(targetPos);
-          if (mappedTarget < 0 || mappedTarget > tr.doc.content.size) {
-            return;
-          }
-          tr.insert(mappedTarget, sourceNode);
-          tr.setMeta("uiEvent", "drop");
-          view.dispatch(tr);
-          return;
-        }
-        const attrs = event.data.attributes;
-        if (attrs && isValidFieldAnnotationAttributes(attrs)) {
-          const inserted = activeEditor.commands?.addFieldAnnotation?.(event.pmPosition, attrs, true);
-          if (inserted) {
-            scheduleSelectionUpdate();
-          }
-          return;
-        }
-        activeEditor.emit("fieldAnnotationDropped", {
-          sourceField: event.data,
-          editor: activeEditor,
-          coordinates: { pos: event.pmPosition }
-        });
-      }
-    });
-  }
-  function createExternalFieldAnnotationDragOverHandler({
-    getActiveEditor,
-    hitTest,
-    scheduleSelectionUpdate
-  }) {
-    return (event) => {
-      const activeEditor = getActiveEditor();
-      if (!activeEditor?.isEditable) {
+    // ==========================================================================
+    // Event Handlers
+    // ==========================================================================
+    /**
+     * Handle dragstart for internal field annotations.
+     */
+    #handleDragStart(event) {
+      const target = event.target;
+      if (!target?.dataset?.draggable || target.dataset.draggable !== "true") {
         return;
       }
-      event.preventDefault();
+      const data = extractFieldAnnotationData(target);
       if (event.dataTransfer) {
-        event.dataTransfer.dropEffect = "copy";
+        const jsonData = JSON.stringify({
+          attributes: data.attributes,
+          sourceField: data
+        });
+        event.dataTransfer.setData(INTERNAL_MIME_TYPE, jsonData);
+        event.dataTransfer.setData(FIELD_ANNOTATION_DATA_TYPE, jsonData);
+        event.dataTransfer.setData("text/plain", data.displayLabel ?? "Field Annotation");
+        event.dataTransfer.setDragImage(target, 0, 0);
+        event.dataTransfer.effectAllowed = "move";
       }
-      const dt = event.dataTransfer;
-      const hasFieldAnnotation = dt?.types?.includes(FIELD_ANNOTATION_DATA_TYPE) || Boolean(dt?.getData?.(FIELD_ANNOTATION_DATA_TYPE));
-      if (!hasFieldAnnotation) {
-        return;
+    }
+    /**
+     * Handle dragover - update cursor position to show drop location.
+     */
+    #handleDragOver(event) {
+      if (!this.#deps) return;
+      if (!hasFieldAnnotationData(event)) return;
+      const activeEditor = this.#deps.getActiveEditor();
+      if (!activeEditor?.isEditable) return;
+      event.preventDefault();
+      if (event.dataTransfer) {
+        event.dataTransfer.dropEffect = isInternalDrag(event) ? "move" : "copy";
       }
-      const hit = hitTest(event.clientX, event.clientY);
+      const hit = this.#deps.hitTest(event.clientX, event.clientY);
       const doc2 = activeEditor.state?.doc;
-      if (!hit || !doc2) {
-        return;
-      }
+      if (!hit || !doc2) return;
       const pos = Math.min(Math.max(hit.pos, 1), doc2.content.size);
       const currentSelection = activeEditor.state.selection;
-      const isSameCursor = currentSelection instanceof TextSelection$1 && currentSelection.from === pos && currentSelection.to === pos;
-      if (isSameCursor) {
+      if (currentSelection instanceof TextSelection$1 && currentSelection.from === pos && currentSelection.to === pos) {
         return;
       }
       try {
         const tr = activeEditor.state.tr.setSelection(TextSelection$1.create(doc2, pos)).setMeta("addToHistory", false);
         activeEditor.view?.dispatch(tr);
-        scheduleSelectionUpdate();
-      } catch (error) {
-      }
-    };
-  }
-  function createExternalFieldAnnotationDropHandler({
-    getActiveEditor,
-    hitTest,
-    scheduleSelectionUpdate
-  }) {
-    return (event) => {
-      const activeEditor = getActiveEditor();
-      if (!activeEditor?.isEditable) {
-        return;
-      }
-      if (event.dataTransfer?.types?.includes("application/x-field-annotation")) {
-        return;
+        this.#deps.scheduleSelectionUpdate();
+      } catch {
       }
+    }
+    /**
+     * Handle drop - either move internal annotation or insert external one.
+     */
+    #handleDrop(event) {
+      if (!this.#deps) return;
+      if (!hasFieldAnnotationData(event)) return;
       event.preventDefault();
       event.stopPropagation();
-      const fieldAnnotationData = event.dataTransfer?.getData(FIELD_ANNOTATION_DATA_TYPE);
-      if (!fieldAnnotationData) {
+      const activeEditor = this.#deps.getActiveEditor();
+      if (!activeEditor?.isEditable) return;
+      const { state, view } = activeEditor;
+      if (!state || !view) return;
+      const hit = this.#deps.hitTest(event.clientX, event.clientY);
+      const fallbackPos = state.selection?.from ?? state.doc?.content.size ?? null;
+      const dropPos = hit?.pos ?? fallbackPos;
+      if (dropPos == null) return;
+      if (isInternalDrag(event)) {
+        this.#handleInternalDrop(event, dropPos);
         return;
       }
-      const hit = hitTest(event.clientX, event.clientY);
-      const selection = activeEditor.state?.selection;
-      const fallbackPos = selection?.from ?? activeEditor.state?.doc?.content.size ?? null;
-      const pos = hit?.pos ?? fallbackPos;
-      if (pos == null) {
-        return;
+      this.#handleExternalDrop(event, dropPos);
+    }
+    /**
+     * Handle internal drop - move field annotation within document.
+     */
+    #handleInternalDrop(event, targetPos) {
+      if (!this.#deps) return;
+      const activeEditor = this.#deps.getActiveEditor();
+      const { state, view } = activeEditor;
+      if (!state || !view) return;
+      const data = extractDragData(event);
+      if (!data?.fieldId) return;
+      const pmStart = data.pmStart;
+      let sourceStart = null;
+      let sourceEnd = null;
+      let sourceNode = null;
+      if (pmStart != null) {
+        const nodeAt = state.doc.nodeAt(pmStart);
+        if (nodeAt?.type?.name === "fieldAnnotation") {
+          sourceStart = pmStart;
+          sourceEnd = pmStart + nodeAt.nodeSize;
+          sourceNode = nodeAt;
+        }
       }
+      if (sourceStart == null || sourceEnd == null || !sourceNode) {
+        state.doc.descendants((node2, pos) => {
+          if (node2.type.name === "fieldAnnotation" && node2.attrs.fieldId === data.fieldId) {
+            sourceStart = pos;
+            sourceEnd = pos + node2.nodeSize;
+            sourceNode = node2;
+            return false;
+          }
+          return true;
+        });
+      }
+      if (sourceStart === null || sourceEnd === null || !sourceNode) return;
+      if (targetPos >= sourceStart && targetPos <= sourceEnd) return;
+      const tr = state.tr;
+      tr.delete(sourceStart, sourceEnd);
+      const mappedTarget = tr.mapping.map(targetPos);
+      if (mappedTarget < 0 || mappedTarget > tr.doc.content.size) return;
+      tr.insert(mappedTarget, sourceNode);
+      tr.setMeta("uiEvent", "drop");
+      view.dispatch(tr);
+    }
+    /**
+     * Handle external drop - insert new field annotation.
+     */
+    #handleExternalDrop(event, pos) {
+      if (!this.#deps) return;
+      const activeEditor = this.#deps.getActiveEditor();
+      const fieldAnnotationData = event.dataTransfer?.getData(FIELD_ANNOTATION_DATA_TYPE);
+      if (!fieldAnnotationData) return;
       let parsedData = null;
       try {
         parsedData = JSON.parse(fieldAnnotationData);
@@ -92671,7 +93412,7 @@ ${o}
       activeEditor.emit?.("fieldAnnotationDropped", {
         sourceField,
         editor: activeEditor,
-        coordinates: hit,
+        coordinates: this.#deps.hitTest(event.clientX, event.clientY),
         pos
       });
       if (attributes && isValidFieldAnnotationAttributes(attributes)) {
@@ -92681,14 +93422,49 @@ ${o}
         if (tr) {
           activeEditor.view?.dispatch(tr);
         }
-        scheduleSelectionUpdate();
+        this.#deps.scheduleSelectionUpdate();
       }
       const editorDom = activeEditor.view?.dom;
       if (editorDom) {
         editorDom.focus();
         activeEditor.view?.focus();
       }
-    };
+    }
+    #handleDragEnd(_event) {
+      this.#deps?.getPainterHost()?.classList.remove("drag-over");
+    }
+    #handleDragLeave(event) {
+      const painterHost = this.#deps?.getPainterHost();
+      if (!painterHost) return;
+      const relatedTarget = event.relatedTarget;
+      if (!relatedTarget || !painterHost.contains(relatedTarget)) {
+        painterHost.classList.remove("drag-over");
+      }
+    }
+    /**
+     * Window-level dragover to allow drops on overlay elements.
+     */
+    #handleWindowDragOver(event) {
+      if (!hasFieldAnnotationData(event)) return;
+      const viewportHost = this.#deps?.getViewportHost();
+      const target = event.target;
+      if (viewportHost?.contains(target)) return;
+      event.preventDefault();
+      if (event.dataTransfer) {
+        event.dataTransfer.dropEffect = isInternalDrag(event) ? "move" : "copy";
+      }
+      this.#handleDragOver(event);
+    }
+    /**
+     * Window-level drop to catch drops on overlay elements.
+     */
+    #handleWindowDrop(event) {
+      if (!hasFieldAnnotationData(event)) return;
+      const viewportHost = this.#deps?.getViewportHost();
+      const target = event.target;
+      if (viewportHost?.contains(target)) return;
+      this.#handleDrop(event);
+    }
   }
   var SectionType = /* @__PURE__ */ ((SectionType2) => {
     SectionType2["CONTINUOUS"] = "continuous";
@@ -94696,16 +95472,17 @@ ${o}
     const afterRaw = pickNumber(source.after);
     const lineRaw = pickNumber(source.line);
     const lineRule = normalizeLineRule(source.lineRule);
+    const resolvedLineRule = lineRule ?? (lineRaw != null ? "auto" : void 0);
     const beforeAutospacing = toBooleanFlag(source.beforeAutospacing ?? source.beforeAutoSpacing);
     const afterAutospacing = toBooleanFlag(source.afterAutospacing ?? source.afterAutoSpacing);
     const contextualSpacing = toBooleanFlag(source.contextualSpacing);
     const before = beforeRaw != null ? twipsToPx$1(beforeRaw) : pickNumber(source.lineSpaceBefore);
     const after = afterRaw != null ? twipsToPx$1(afterRaw) : pickNumber(source.lineSpaceAfter);
-    const line = normalizeLineValue(lineRaw, lineRule);
+    const line = normalizeLineValue(lineRaw, resolvedLineRule);
     if (before != null) spacing.before = before;
     if (after != null) spacing.after = after;
     if (line != null) spacing.line = line;
-    if (lineRule) spacing.lineRule = lineRule;
+    if (resolvedLineRule) spacing.lineRule = resolvedLineRule;
     if (beforeAutospacing != null) spacing.beforeAutospacing = beforeAutospacing;
     if (afterAutospacing != null) spacing.afterAutospacing = afterAutospacing;
     if (contextualSpacing != null) spacing.contextualSpacing = contextualSpacing;
@@ -104521,8 +105298,6 @@ ${o}
   const DEFAULT_VIRTUALIZED_PAGE_GAP = 72;
   const DEFAULT_PAGE_GAP = 24;
   const DEFAULT_HORIZONTAL_PAGE_GAP = 20;
-  const MULTI_CLICK_TIME_THRESHOLD_MS = 400;
-  const MULTI_CLICK_DISTANCE_THRESHOLD_PX = 5;
   const HEADER_FOOTER_INIT_BUDGET_MS = 200;
   const MAX_ZOOM_WARNING_THRESHOLD = 10;
   const MAX_SELECTION_RECTS_PER_USER = 100;
@@ -104578,7 +105353,7 @@ ${o}
     #layoutState = { blocks: [], measures: [], layout: null, bookmarks: /* @__PURE__ */ new Map() };
     #domPainter = null;
     #pageGeometryHelper = null;
-    #dragHandlerCleanup = null;
+    #dragDropManager = null;
     #layoutError = null;
     #layoutErrorState = "healthy";
     #errorBanner = null;
@@ -104595,9 +105370,6 @@ ${o}
     #htmlAnnotationMeasureAttempts = 0;
     #domPositionIndex = new DomPositionIndex();
     #domIndexObserverManager = null;
-    #debugLastPointer = null;
-    #debugLastHit = null;
-    #pendingMarginClick = null;
     #rafHandle = null;
     #editorListeners = [];
     #sectionMetadata = [];
@@ -104614,25 +105386,7 @@ ${o}
     #ariaLiveRegion = null;
     #a11ySelectionAnnounceTimeout = null;
     #a11yLastAnnouncedSelectionKey = null;
-    #clickCount = 0;
-    #lastClickTime = 0;
-    #lastClickPosition = { x: 0, y: 0 };
-    #lastSelectedImageBlockId = null;
     #lastSelectedFieldAnnotation = null;
-    // Drag selection state
-    #dragAnchor = null;
-    #dragAnchorPageIndex = null;
-    #isDragging = false;
-    #dragExtensionMode = "char";
-    #dragLastPointer = null;
-    #dragLastRawHit = null;
-    #dragUsedPageNotMountedFallback = false;
-    #suppressFocusInFromDraggable = false;
-    // Cell selection drag state
-    // Tracks cell-specific context when drag starts in a table for multi-cell selection
-    #cellAnchor = null;
-    /** Cell drag mode state machine: 'none' = not in table, 'pending' = in table but haven't crossed cell boundary, 'active' = crossed cell boundary */
-    #cellDragMode = "none";
     // Remote cursor/presence state management
     /** Manager for remote cursor rendering and awareness subscriptions */
     #remoteCursorManager = null;
@@ -104640,6 +105394,9 @@ ${o}
     #remoteCursorOverlay = null;
     /** DOM element for rendering local selection/caret (dual-layer overlay architecture) */
     #localSelectionLayer = null;
+    // Editor input management
+    /** Manager for pointer events, focus, drag selection, and click handling */
+    #editorInputManager = null;
     constructor(options) {
       super();
       if (!options?.element) {
@@ -104848,6 +105605,7 @@ ${o}
         this.#setupHeaderFooterSession();
         this.#applyZoom();
         this.#setupEditorListeners();
+        this.#initializeEditorInputManager();
         this.#setupPointerHandlers();
         this.#setupDragHandlers();
         this.#setupInputBridge();
@@ -105769,8 +106527,8 @@ ${o}
           docEpoch: this.#epochMapper.getCurrentEpoch(),
           layoutEpoch: this.#layoutEpoch,
           selection,
-          lastPointer: this.#debugLastPointer,
-          lastHit: this.#debugLastHit
+          lastPointer: this.#editorInputManager?.debugLastPointer ?? null,
+          lastHit: this.#editorInputManager?.debugLastHit ?? null
         });
       } catch {
       }
@@ -106163,15 +106921,12 @@ ${o}
       this.#editorListeners = [];
       this.#domIndexObserverManager?.destroy();
       this.#domIndexObserverManager = null;
-      this.#viewportHost?.removeEventListener("pointerdown", this.#handlePointerDown);
-      this.#viewportHost?.removeEventListener("dblclick", this.#handleDoubleClick);
-      this.#viewportHost?.removeEventListener("pointermove", this.#handlePointerMove);
-      this.#viewportHost?.removeEventListener("pointerup", this.#handlePointerUp);
-      this.#viewportHost?.removeEventListener("pointerleave", this.#handlePointerLeave);
-      this.#viewportHost?.removeEventListener("dragover", this.#handleDragOver);
-      this.#viewportHost?.removeEventListener("drop", this.#handleDrop);
-      this.#visibleHost?.removeEventListener("keydown", this.#handleKeyDown);
-      this.#visibleHost?.removeEventListener("focusin", this.#handleVisibleHostFocusIn);
+      if (this.#editorInputManager) {
+        safeCleanup(() => {
+          this.#editorInputManager?.destroy();
+          this.#editorInputManager = null;
+        }, "Editor input manager");
+      }
       this.#inputBridge?.notifyTargetChanged();
       this.#inputBridge?.destroy();
       this.#inputBridge = null;
@@ -106179,7 +106934,6 @@ ${o}
         clearTimeout(this.#a11ySelectionAnnounceTimeout);
         this.#a11ySelectionAnnounceTimeout = null;
       }
-      this.#clearCellAnchor();
       if (this.#options?.documentId) {
         PresentationEditor.#instances.delete(this.#options.documentId);
       }
@@ -106189,8 +106943,8 @@ ${o}
       }, "Header/footer session manager");
       this.#domPainter = null;
       this.#pageGeometryHelper = null;
-      this.#dragHandlerCleanup?.();
-      this.#dragHandlerCleanup = null;
+      this.#dragDropManager?.destroy();
+      this.#dragDropManager = null;
       this.#selectionOverlay?.remove();
       this.#painterHost?.remove();
       this.#hiddenHost?.remove();
@@ -106237,7 +106991,7 @@ ${o}
         }
         if (transaction?.docChanged) {
           this.#updateLocalAwarenessCursor();
-          this.#clearCellAnchor();
+          this.#editorInputManager?.clearCellAnchor();
         }
       };
       const handleSelection = () => {
@@ -106333,39 +107087,83 @@ ${o}
         cursors: Array.from(this.#remoteCursorManager.state.values())
       });
     }
-    /**
-     * Render remote cursors from existing state without normalization.
-     * Delegates to RemoteCursorManager.
-     * @private
-     */
-    #renderRemoteCursors() {
-      this.#remoteCursorManager?.render(this.#getRemoteCursorRenderDeps());
-    }
+    /**
+     * Render remote cursors from existing state without normalization.
+     * Delegates to RemoteCursorManager.
+     * @private
+     */
+    #renderRemoteCursors() {
+      this.#remoteCursorManager?.render(this.#getRemoteCursorRenderDeps());
+    }
+    /**
+     * Initialize the EditorInputManager with dependencies and callbacks.
+     * @private
+     */
+    #initializeEditorInputManager() {
+      this.#editorInputManager = new EditorInputManager();
+      this.#editorInputManager.setDependencies({
+        getActiveEditor: () => this.getActiveEditor(),
+        getEditor: () => this.#editor,
+        getLayoutState: () => this.#layoutState,
+        getEpochMapper: () => this.#epochMapper,
+        getViewportHost: () => this.#viewportHost,
+        getVisibleHost: () => this.#visibleHost,
+        getHeaderFooterSession: () => this.#headerFooterSession,
+        getPageGeometryHelper: () => this.#pageGeometryHelper,
+        getZoom: () => this.#layoutOptions.zoom ?? 1,
+        isViewLocked: () => this.#isViewLocked(),
+        getDocumentMode: () => this.#documentMode,
+        getPageElement: (pageIndex) => this.#getPageElement(pageIndex),
+        isSelectionAwareVirtualizationEnabled: () => this.#isSelectionAwareVirtualizationEnabled()
+      });
+      this.#editorInputManager.setCallbacks({
+        scheduleSelectionUpdate: () => this.#scheduleSelectionUpdate(),
+        scheduleRerender: () => this.#scheduleRerender(),
+        setPendingDocChange: () => {
+          this.#pendingDocChange = true;
+        },
+        updateSelectionVirtualizationPins: (options) => this.#updateSelectionVirtualizationPins(options),
+        scheduleA11ySelectionAnnouncement: (options) => this.#scheduleA11ySelectionAnnouncement(options),
+        goToAnchor: (href) => this.goToAnchor(href),
+        emit: (event, payload) => this.emit(event, payload),
+        normalizeClientPoint: (clientX, clientY) => this.#normalizeClientPoint(clientX, clientY),
+        hitTestHeaderFooterRegion: (x2, y2) => this.#hitTestHeaderFooterRegion(x2, y2),
+        exitHeaderFooterMode: () => this.#exitHeaderFooterMode(),
+        activateHeaderFooterRegion: (region) => this.#activateHeaderFooterRegion(region),
+        createDefaultHeaderFooter: (region) => this.#createDefaultHeaderFooter(region),
+        emitHeaderFooterEditBlocked: (reason) => this.#emitHeaderFooterEditBlocked(reason),
+        findRegionForPage: (kind, pageIndex) => this.#findRegionForPage(kind, pageIndex),
+        getCurrentPageIndex: () => this.#getCurrentPageIndex(),
+        resolveDescriptorForRegion: (region) => this.#resolveDescriptorForRegion(region),
+        updateSelectionDebugHud: () => this.#updateSelectionDebugHud(),
+        clearHoverRegion: () => this.#clearHoverRegion(),
+        renderHoverRegion: (region) => this.#renderHoverRegion(region),
+        focusEditorAfterImageSelection: () => this.#focusEditorAfterImageSelection(),
+        resolveFieldAnnotationSelectionFromElement: (el) => this.#resolveFieldAnnotationSelectionFromElement(el),
+        computePendingMarginClick: (pointerId, x2, y2) => this.#computePendingMarginClick(pointerId, x2, y2),
+        selectWordAt: (pos) => this.#selectWordAt(pos),
+        selectParagraphAt: (pos) => this.#selectParagraphAt(pos),
+        finalizeDragSelectionWithDom: (pointer, dragAnchor, dragMode) => this.#finalizeDragSelectionWithDom(pointer, dragAnchor, dragMode),
+        hitTestTable: (x2, y2) => this.#hitTestTable(x2, y2)
+      });
+    }
     #setupPointerHandlers() {
-      this.#viewportHost.addEventListener("pointerdown", this.#handlePointerDown);
-      this.#viewportHost.addEventListener("dblclick", this.#handleDoubleClick);
-      this.#viewportHost.addEventListener("pointermove", this.#handlePointerMove);
-      this.#viewportHost.addEventListener("pointerup", this.#handlePointerUp);
-      this.#viewportHost.addEventListener("pointerleave", this.#handlePointerLeave);
-      this.#viewportHost.addEventListener("dragover", this.#handleDragOver);
-      this.#viewportHost.addEventListener("drop", this.#handleDrop);
-      this.#visibleHost.addEventListener("keydown", this.#handleKeyDown);
-      this.#visibleHost.addEventListener("focusin", this.#handleVisibleHostFocusIn);
+      this.#editorInputManager?.bind();
     }
     /**
-     * Sets up drag and drop handlers for field annotations in the layout engine view.
-     * Uses the DragHandler from layout-bridge to handle drag events and map drop
-     * coordinates to ProseMirror positions.
+     * Sets up drag and drop handlers for field annotations.
      */
     #setupDragHandlers() {
-      this.#dragHandlerCleanup?.();
-      this.#dragHandlerCleanup = null;
-      this.#dragHandlerCleanup = setupInternalFieldAnnotationDragHandlers({
-        painterHost: this.#painterHost,
+      this.#dragDropManager?.destroy();
+      this.#dragDropManager = new DragDropManager();
+      this.#dragDropManager.setDependencies({
         getActiveEditor: () => this.getActiveEditor(),
         hitTest: (clientX, clientY) => this.hitTest(clientX, clientY),
-        scheduleSelectionUpdate: () => this.#scheduleSelectionUpdate()
+        scheduleSelectionUpdate: () => this.#scheduleSelectionUpdate(),
+        getViewportHost: () => this.#viewportHost,
+        getPainterHost: () => this.#painterHost
       });
+      this.#dragDropManager.bind();
     }
     /**
      * Focus the editor after image selection and schedule selection update.
@@ -106483,516 +107281,6 @@ ${o}
       });
       this.#headerFooterSession.initialize();
     }
-    #handlePointerDown = (event) => {
-      if (event.button !== 0) {
-        return;
-      }
-      if (event.ctrlKey && navigator.platform.includes("Mac")) {
-        return;
-      }
-      this.#pendingMarginClick = null;
-      const target = event.target;
-      if (target?.closest?.(".superdoc-ruler-handle") != null) {
-        return;
-      }
-      const linkEl = target?.closest?.("a.superdoc-link");
-      if (linkEl) {
-        const href = linkEl.getAttribute("href") ?? "";
-        const isAnchorLink = href.startsWith("#") && href.length > 1;
-        const isTocLink = linkEl.closest(".superdoc-toc-entry") !== null;
-        if (isAnchorLink && isTocLink) {
-          event.preventDefault();
-          event.stopPropagation();
-          this.goToAnchor(href);
-          return;
-        }
-        event.preventDefault();
-        event.stopPropagation();
-        const linkClickEvent = new CustomEvent("superdoc-link-click", {
-          bubbles: true,
-          composed: true,
-          detail: {
-            href,
-            target: linkEl.getAttribute("target"),
-            rel: linkEl.getAttribute("rel"),
-            tooltip: linkEl.getAttribute("title"),
-            element: linkEl,
-            clientX: event.clientX,
-            clientY: event.clientY
-          }
-        });
-        linkEl.dispatchEvent(linkClickEvent);
-        return;
-      }
-      const annotationEl = target?.closest?.(".annotation[data-pm-start]");
-      const isDraggableAnnotation = target?.closest?.('[data-draggable="true"]') != null;
-      this.#suppressFocusInFromDraggable = isDraggableAnnotation;
-      if (annotationEl) {
-        if (!this.#editor.isEditable) {
-          return;
-        }
-        const resolved = this.#resolveFieldAnnotationSelectionFromElement(annotationEl);
-        if (resolved) {
-          try {
-            const tr = this.#editor.state.tr.setSelection(NodeSelection.create(this.#editor.state.doc, resolved.pos));
-            this.#editor.view?.dispatch(tr);
-          } catch {
-          }
-          this.#editor.emit("fieldAnnotationClicked", {
-            editor: this.#editor,
-            node: resolved.node,
-            nodePos: resolved.pos,
-            event,
-            currentTarget: annotationEl
-          });
-        }
-        return;
-      }
-      if (!this.#layoutState.layout) {
-        if (!isDraggableAnnotation) {
-          event.preventDefault();
-        }
-        if (document.activeElement instanceof HTMLElement) {
-          document.activeElement.blur();
-        }
-        const editorDom2 = this.#editor.view?.dom;
-        if (!editorDom2) {
-          return;
-        }
-        const validPos = this.#getFirstTextPosition();
-        const doc22 = this.#editor?.state?.doc;
-        if (doc22) {
-          try {
-            const tr = this.#editor.state.tr.setSelection(TextSelection$1.create(doc22, validPos));
-            this.#editor.view?.dispatch(tr);
-          } catch (error) {
-          }
-        }
-        editorDom2.focus();
-        this.#editor.view?.focus();
-        this.#scheduleSelectionUpdate();
-        return;
-      }
-      const normalizedPoint = this.#normalizeClientPoint(event.clientX, event.clientY);
-      if (!normalizedPoint) {
-        return;
-      }
-      const { x: x2, y: y2 } = normalizedPoint;
-      this.#debugLastPointer = { clientX: event.clientX, clientY: event.clientY, x: x2, y: y2 };
-      const sessionMode = this.#headerFooterSession?.session?.mode ?? "body";
-      if (sessionMode !== "body") {
-        const activeEditorHost = this.#headerFooterSession?.overlayManager?.getActiveEditorHost?.();
-        const clickedInsideEditorHost = activeEditorHost && (activeEditorHost.contains(event.target) || activeEditorHost === event.target);
-        if (clickedInsideEditorHost) {
-          return;
-        }
-        const headerFooterRegion2 = this.#hitTestHeaderFooterRegion(x2, y2);
-        if (!headerFooterRegion2) {
-          this.#exitHeaderFooterMode();
-        } else {
-          return;
-        }
-      }
-      const headerFooterRegion = this.#hitTestHeaderFooterRegion(x2, y2);
-      if (headerFooterRegion) {
-        return;
-      }
-      const rawHit = clickToPosition(
-        this.#layoutState.layout,
-        this.#layoutState.blocks,
-        this.#layoutState.measures,
-        { x: x2, y: y2 },
-        this.#viewportHost,
-        event.clientX,
-        event.clientY,
-        this.#pageGeometryHelper ?? void 0
-      );
-      const doc2 = this.#editor.state?.doc;
-      const mapped = rawHit && doc2 ? this.#epochMapper.mapPosFromLayoutToCurrentDetailed(rawHit.pos, rawHit.layoutEpoch, 1) : null;
-      if (mapped && !mapped.ok) {
-        debugLog("warn", "pointerdown mapping failed", mapped);
-      }
-      const hit = rawHit && doc2 && mapped?.ok ? { ...rawHit, pos: Math.max(0, Math.min(mapped.pos, doc2.content.size)), layoutEpoch: mapped.toEpoch } : null;
-      this.#debugLastHit = hit ? { source: "dom", pos: rawHit?.pos ?? null, layoutEpoch: rawHit?.layoutEpoch ?? null, mappedPos: hit.pos } : { source: "none", pos: rawHit?.pos ?? null, layoutEpoch: rawHit?.layoutEpoch ?? null, mappedPos: null };
-      this.#updateSelectionDebugHud();
-      if (!isDraggableAnnotation) {
-        event.preventDefault();
-      }
-      if (!rawHit) {
-        if (document.activeElement instanceof HTMLElement) {
-          document.activeElement.blur();
-        }
-        const editorDom2 = this.#editor.view?.dom;
-        if (editorDom2) {
-          const validPos = this.#getFirstTextPosition();
-          const doc22 = this.#editor?.state?.doc;
-          if (doc22) {
-            try {
-              const tr = this.#editor.state.tr.setSelection(TextSelection$1.create(doc22, validPos));
-              this.#editor.view?.dispatch(tr);
-            } catch (error) {
-            }
-          }
-          editorDom2.focus();
-          this.#editor.view?.focus();
-          this.#scheduleSelectionUpdate();
-        }
-        return;
-      }
-      if (!hit || !doc2) {
-        this.#pendingDocChange = true;
-        this.#scheduleRerender();
-        return;
-      }
-      const fragmentHit = getFragmentAtPosition(
-        this.#layoutState.layout,
-        this.#layoutState.blocks,
-        this.#layoutState.measures,
-        rawHit.pos
-      );
-      const targetImg = event.target?.closest?.("img");
-      const imgPmStart = targetImg?.dataset?.pmStart ? Number(targetImg.dataset.pmStart) : null;
-      if (!Number.isNaN(imgPmStart) && imgPmStart != null) {
-        const doc22 = this.#editor.state.doc;
-        const imgLayoutEpochRaw = targetImg?.dataset?.layoutEpoch;
-        const imgLayoutEpoch = imgLayoutEpochRaw != null ? Number(imgLayoutEpochRaw) : NaN;
-        const rawLayoutEpoch = Number.isFinite(rawHit.layoutEpoch) ? rawHit.layoutEpoch : NaN;
-        const effectiveEpoch = Number.isFinite(imgLayoutEpoch) && Number.isFinite(rawLayoutEpoch) ? Math.max(imgLayoutEpoch, rawLayoutEpoch) : Number.isFinite(imgLayoutEpoch) ? imgLayoutEpoch : rawHit.layoutEpoch;
-        const mappedImg = this.#epochMapper.mapPosFromLayoutToCurrentDetailed(imgPmStart, effectiveEpoch, 1);
-        if (!mappedImg.ok) {
-          debugLog("warn", "inline image mapping failed", mappedImg);
-          this.#pendingDocChange = true;
-          this.#scheduleRerender();
-          return;
-        }
-        const clampedImgPos = Math.max(0, Math.min(mappedImg.pos, doc22.content.size));
-        if (clampedImgPos < 0 || clampedImgPos >= doc22.content.size) {
-          return;
-        }
-        const newSelectionId = `inline-${clampedImgPos}`;
-        if (this.#lastSelectedImageBlockId && this.#lastSelectedImageBlockId !== newSelectionId) {
-          this.emit("imageDeselected", { blockId: this.#lastSelectedImageBlockId });
-        }
-        try {
-          const tr = this.#editor.state.tr.setSelection(NodeSelection.create(doc22, clampedImgPos));
-          this.#editor.view?.dispatch(tr);
-          const selector = `.superdoc-inline-image[data-pm-start="${imgPmStart}"]`;
-          const targetElement = this.#viewportHost.querySelector(selector);
-          this.emit("imageSelected", {
-            element: targetElement ?? targetImg,
-            blockId: null,
-            pmStart: clampedImgPos
-          });
-          this.#lastSelectedImageBlockId = newSelectionId;
-        } catch (error) {
-        }
-        this.#focusEditorAfterImageSelection();
-        return;
-      }
-      if (fragmentHit && (fragmentHit.fragment.kind === "image" || fragmentHit.fragment.kind === "drawing")) {
-        const doc22 = this.#editor.state.doc;
-        try {
-          const tr = this.#editor.state.tr.setSelection(NodeSelection.create(doc22, hit.pos));
-          this.#editor.view?.dispatch(tr);
-          if (this.#lastSelectedImageBlockId && this.#lastSelectedImageBlockId !== fragmentHit.fragment.blockId) {
-            this.emit("imageDeselected", { blockId: this.#lastSelectedImageBlockId });
-          }
-          if (fragmentHit.fragment.kind === "image") {
-            const targetElement = this.#viewportHost.querySelector(
-              `.superdoc-image-fragment[data-pm-start="${fragmentHit.fragment.pmStart}"]`
-            );
-            if (targetElement) {
-              this.emit("imageSelected", {
-                element: targetElement,
-                blockId: fragmentHit.fragment.blockId,
-                pmStart: fragmentHit.fragment.pmStart
-              });
-              this.#lastSelectedImageBlockId = fragmentHit.fragment.blockId;
-            }
-          }
-        } catch (error) {
-        }
-        this.#focusEditorAfterImageSelection();
-        return;
-      }
-      if (this.#lastSelectedImageBlockId) {
-        this.emit("imageDeselected", { blockId: this.#lastSelectedImageBlockId });
-        this.#lastSelectedImageBlockId = null;
-      }
-      if (event.shiftKey && this.#editor.state.selection.$anchor) {
-        const anchor = this.#editor.state.selection.anchor;
-        const head = hit.pos;
-        const { selAnchor, selHead } = this.#calculateExtendedSelection(anchor, head, this.#dragExtensionMode);
-        try {
-          const tr = this.#editor.state.tr.setSelection(TextSelection$1.create(this.#editor.state.doc, selAnchor, selHead));
-          this.#editor.view?.dispatch(tr);
-          this.#scheduleSelectionUpdate();
-        } catch (error) {
-          console.warn("[SELECTION] Failed to extend selection on shift+click:", {
-            error,
-            anchor,
-            head,
-            selAnchor,
-            selHead,
-            mode: this.#dragExtensionMode
-          });
-        }
-        if (document.activeElement instanceof HTMLElement) {
-          document.activeElement.blur();
-        }
-        const editorDom2 = this.#editor.view?.dom;
-        if (editorDom2) {
-          editorDom2.focus();
-          this.#editor.view?.focus();
-        }
-        return;
-      }
-      const clickDepth = this.#registerPointerClick(event);
-      if (clickDepth === 1) {
-        this.#dragAnchor = hit.pos;
-        this.#dragAnchorPageIndex = hit.pageIndex;
-        this.#pendingMarginClick = this.#computePendingMarginClick(event.pointerId, x2, y2);
-        const tableHit = this.#hitTestTable(x2, y2);
-        if (tableHit) {
-          const tablePos = this.#getTablePosFromHit(tableHit);
-          if (tablePos !== null) {
-            this.#setCellAnchor(tableHit, tablePos);
-          }
-        } else {
-          this.#clearCellAnchor();
-        }
-      } else {
-        this.#pendingMarginClick = null;
-      }
-      this.#dragLastPointer = { clientX: event.clientX, clientY: event.clientY, x: x2, y: y2 };
-      this.#dragLastRawHit = hit;
-      this.#dragUsedPageNotMountedFallback = false;
-      this.#isDragging = true;
-      if (clickDepth >= 3) {
-        this.#dragExtensionMode = "para";
-      } else if (clickDepth === 2) {
-        this.#dragExtensionMode = "word";
-      } else {
-        this.#dragExtensionMode = "char";
-      }
-      debugLog(
-        "verbose",
-        `Drag selection start ${JSON.stringify({
-          pointer: { clientX: event.clientX, clientY: event.clientY, x: x2, y: y2 },
-          clickDepth,
-          extensionMode: this.#dragExtensionMode,
-          anchor: this.#dragAnchor,
-          anchorPageIndex: this.#dragAnchorPageIndex,
-          rawHit: rawHit ? {
-            pos: rawHit.pos,
-            pageIndex: rawHit.pageIndex,
-            blockId: rawHit.blockId,
-            lineIndex: rawHit.lineIndex,
-            layoutEpoch: rawHit.layoutEpoch
-          } : null,
-          mapped: mapped ? mapped.ok ? { ok: true, pos: mapped.pos, fromEpoch: mapped.fromEpoch, toEpoch: mapped.toEpoch } : {
-            ok: false,
-            reason: mapped.reason,
-            fromEpoch: mapped.fromEpoch,
-            toEpoch: mapped.toEpoch
-          } : null,
-          hit: hit ? { pos: hit.pos, pageIndex: hit.pageIndex, layoutEpoch: hit.layoutEpoch } : null
-        })}`
-      );
-      if (typeof this.#viewportHost.setPointerCapture === "function") {
-        this.#viewportHost.setPointerCapture(event.pointerId);
-      }
-      let handledByDepth = false;
-      const sessionModeForDepth = this.#headerFooterSession?.session?.mode ?? "body";
-      if (sessionModeForDepth === "body") {
-        const selectionPos = clickDepth >= 2 && this.#dragAnchor !== null ? this.#dragAnchor : hit.pos;
-        if (clickDepth >= 3) {
-          handledByDepth = this.#selectParagraphAt(selectionPos);
-        } else if (clickDepth === 2) {
-          handledByDepth = this.#selectWordAt(selectionPos);
-        }
-      }
-      if (!handledByDepth) {
-        try {
-          const doc22 = this.#editor.state.doc;
-          let nextSelection = TextSelection$1.create(doc22, hit.pos);
-          if (!nextSelection.$from.parent.inlineContent) {
-            nextSelection = Selection.near(doc22.resolve(hit.pos), 1);
-          }
-          const tr = this.#editor.state.tr.setSelection(nextSelection);
-          this.#editor.view?.dispatch(tr);
-        } catch {
-        }
-      }
-      this.#scheduleSelectionUpdate();
-      if (document.activeElement instanceof HTMLElement) {
-        document.activeElement.blur();
-      }
-      const editorDom = this.#editor.view?.dom;
-      if (!editorDom) {
-        return;
-      }
-      editorDom.focus();
-      this.#editor.view?.focus();
-    };
-    /**
-     * Finds the first valid text position in the document.
-     *
-     * Traverses the document tree to locate the first textblock node (paragraph, heading, etc.)
-     * and returns a position inside it. This is used when focusing the editor but no specific
-     * position is available (e.g., clicking outside text content or before layout is ready).
-     *
-     * @returns The position inside the first textblock, or 1 if no textblock is found
-     * @private
-     */
-    #getFirstTextPosition() {
-      return getFirstTextPosition(this.#editor?.state?.doc ?? null);
-    }
-    /**
-     * Registers a pointer click event and tracks multi-click sequences (double, triple).
-     *
-     * This method implements multi-click detection by tracking the timing and position
-     * of consecutive clicks. Clicks within 400ms and 5px of each other increment the
-     * click count, up to a maximum of 3 (single, double, triple).
-     *
-     * @param event - The mouse event from the pointer down handler
-     * @returns The current click count (1 = single, 2 = double, 3 = triple)
-     * @private
-     */
-    #registerPointerClick(event) {
-      const nextState = registerPointerClick(
-        event,
-        { clickCount: this.#clickCount, lastClickTime: this.#lastClickTime, lastClickPosition: this.#lastClickPosition },
-        {
-          timeThresholdMs: MULTI_CLICK_TIME_THRESHOLD_MS,
-          distanceThresholdPx: MULTI_CLICK_DISTANCE_THRESHOLD_PX,
-          maxClickCount: 3
-        }
-      );
-      this.#clickCount = nextState.clickCount;
-      this.#lastClickTime = nextState.lastClickTime;
-      this.#lastClickPosition = nextState.lastClickPosition;
-      return nextState.clickCount;
-    }
-    // ============================================================================
-    // Cell Selection Utilities
-    // ============================================================================
-    /**
-     * Gets the ProseMirror position at the start of a table cell from a table hit result.
-     *
-     * This method navigates the ProseMirror document structure to find the exact position where
-     * a table cell begins. The position returned is suitable for use with CellSelection.create().
-     *
-     * Algorithm:
-     * 1. Validate input (tableHit structure and cell indices)
-     * 2. Traverse document to find the table node matching tableHit.block.id
-     * 3. Navigate through table structure (table > row > cell) to target row
-     * 4. Track logical column position accounting for colspan (handles merged cells)
-     * 5. Return position when target column falls within a cell's span
-     *
-     * Merged cell handling:
-     * - Does NOT assume 1:1 mapping between cell index and logical column
-     * - Tracks cumulative logical column position by summing colspan values
-     * - A cell with colspan=3 occupies logical columns [n, n+1, n+2]
-     * - Finds the cell whose logical span contains the target column index
-     *
-     * Error handling:
-     * - Input validation with console warnings for debugging
-     * - Try-catch around document traversal (catches corrupted document errors)
-     * - Bounds checking for row indices
-     * - Null checks at each navigation step
-     *
-     * @param tableHit - The table hit result from hitTestTableFragment containing:
-     *   - block: TableBlock with the table's block ID
-     *   - cellRowIndex: 0-based row index of the target cell
-     *   - cellColIndex: 0-based logical column index of the target cell
-     * @returns The PM position at the start of the cell, or null if:
-     *   - Invalid input (null tableHit, negative indices)
-     *   - Table not found in document
-     *   - Target row out of bounds
-     *   - Target column not found in row
-     *   - Document traversal error
-     * @private
-     *
-     * @throws Never throws - all errors are caught and logged, returns null on failure
-     */
-    #getCellPosFromTableHit(tableHit) {
-      return getCellPosFromTableHit(tableHit, this.#editor.state?.doc ?? null, this.#layoutState.blocks);
-    }
-    /**
-     * Gets the table position (start of table node) from a table hit result.
-     *
-     * @param tableHit - The table hit result from hitTestTableFragment
-     * @returns The PM position at the start of the table, or null if not found
-     * @private
-     */
-    #getTablePosFromHit(tableHit) {
-      return getTablePosFromHit(tableHit, this.#editor.state?.doc ?? null, this.#layoutState.blocks);
-    }
-    /**
-     * Determines if the current drag should create a CellSelection instead of TextSelection.
-     *
-     * Implements a state machine for table cell selection:
-     * - 'none': Not in a table, use TextSelection
-     * - 'pending': Started drag in a table, but haven't crossed cell boundary yet
-     * - 'active': Crossed cell boundary, use CellSelection
-     *
-     * State transitions:
-     * - none → pending: When drag starts in a table cell (#setCellAnchor)
-     * - pending → active: When drag crosses into a different cell (this method returns true)
-     * - active → none: When drag ends (#clearCellAnchor)
-     * - * → none: When document changes or clicking outside table
-     *
-     * Decision logic:
-     * 1. No cell anchor → false (not in table drag mode)
-     * 2. Current position outside table → return current state (stay in 'active' if already there)
-     * 3. Different table → treat as outside table
-     * 4. Different cell in same table → true (activate cell selection)
-     * 5. Same cell → return current state (stay in 'active' if already there, else false)
-     *
-     * This state machine ensures:
-     * - Text selection works normally within a single cell
-     * - Cell selection activates smoothly when crossing cell boundaries
-     * - Once activated, cell selection persists even if dragging back to anchor cell
-     *
-     * @param currentTableHit - The table hit result for the current pointer position, or null if not in a table
-     * @returns true if we should create a CellSelection, false for TextSelection
-     * @private
-     */
-    #shouldUseCellSelection(currentTableHit) {
-      return shouldUseCellSelection(currentTableHit, this.#cellAnchor, this.#cellDragMode);
-    }
-    /**
-     * Stores the cell anchor when a drag operation starts inside a table cell.
-     *
-     * @param tableHit - The table hit result for the initial click position
-     * @param tablePos - The PM position of the table node
-     * @private
-     */
-    #setCellAnchor(tableHit, tablePos) {
-      const cellPos = this.#getCellPosFromTableHit(tableHit);
-      if (cellPos === null) {
-        return;
-      }
-      this.#cellAnchor = {
-        tablePos,
-        cellPos,
-        cellRowIndex: tableHit.cellRowIndex,
-        cellColIndex: tableHit.cellColIndex,
-        tableBlockId: tableHit.block.id
-      };
-      this.#cellDragMode = "pending";
-    }
-    /**
-     * Clears the cell drag state.
-     * Called when drag ends or when clicking outside a table.
-     *
-     * @private
-     */
-    #clearCellAnchor() {
-      this.#cellAnchor = null;
-      this.#cellDragMode = "none";
-    }
     /**
      * Attempts to perform a table hit test for the given normalized coordinates.
      *
@@ -107097,415 +107385,6 @@ ${o}
     #calculateExtendedSelection(anchor, head, mode) {
       return calculateExtendedSelection(this.#layoutState.blocks, anchor, head, mode);
     }
-    #handlePointerMove = (event) => {
-      if (!this.#layoutState.layout) return;
-      const normalized = this.#normalizeClientPoint(event.clientX, event.clientY);
-      if (!normalized) return;
-      if (this.#isDragging && this.#dragAnchor !== null && event.buttons & 1) {
-        this.#pendingMarginClick = null;
-        const prevPointer = this.#dragLastPointer;
-        const prevRawHit = this.#dragLastRawHit;
-        this.#dragLastPointer = { clientX: event.clientX, clientY: event.clientY, x: normalized.x, y: normalized.y };
-        const rawHit = clickToPosition(
-          this.#layoutState.layout,
-          this.#layoutState.blocks,
-          this.#layoutState.measures,
-          { x: normalized.x, y: normalized.y },
-          this.#viewportHost,
-          event.clientX,
-          event.clientY,
-          this.#pageGeometryHelper ?? void 0
-        );
-        if (!rawHit) {
-          debugLog(
-            "verbose",
-            `Drag selection update (no hit) ${JSON.stringify({
-              pointer: { clientX: event.clientX, clientY: event.clientY, x: normalized.x, y: normalized.y },
-              prevPointer,
-              anchor: this.#dragAnchor
-            })}`
-          );
-          return;
-        }
-        const doc2 = this.#editor.state?.doc;
-        if (!doc2) return;
-        this.#dragLastRawHit = rawHit;
-        const pageMounted = this.#getPageElement(rawHit.pageIndex) != null;
-        if (!pageMounted && this.#isSelectionAwareVirtualizationEnabled()) {
-          this.#dragUsedPageNotMountedFallback = true;
-          debugLog("warn", "Geometry fallback", { reason: "page_not_mounted", pageIndex: rawHit.pageIndex });
-        }
-        this.#updateSelectionVirtualizationPins({ includeDragBuffer: true, extraPages: [rawHit.pageIndex] });
-        const mappedHead = this.#epochMapper.mapPosFromLayoutToCurrentDetailed(rawHit.pos, rawHit.layoutEpoch, 1);
-        if (!mappedHead.ok) {
-          debugLog("warn", "drag mapping failed", mappedHead);
-          debugLog(
-            "verbose",
-            `Drag selection update (map failed) ${JSON.stringify({
-              pointer: { clientX: event.clientX, clientY: event.clientY, x: normalized.x, y: normalized.y },
-              prevPointer,
-              anchor: this.#dragAnchor,
-              rawHit: {
-                pos: rawHit.pos,
-                pageIndex: rawHit.pageIndex,
-                blockId: rawHit.blockId,
-                lineIndex: rawHit.lineIndex,
-                layoutEpoch: rawHit.layoutEpoch
-              },
-              mapped: {
-                ok: false,
-                reason: mappedHead.reason,
-                fromEpoch: mappedHead.fromEpoch,
-                toEpoch: mappedHead.toEpoch
-              }
-            })}`
-          );
-          return;
-        }
-        const hit = {
-          ...rawHit,
-          pos: Math.max(0, Math.min(mappedHead.pos, doc2.content.size)),
-          layoutEpoch: mappedHead.toEpoch
-        };
-        this.#debugLastHit = {
-          source: pageMounted ? "dom" : "geometry",
-          pos: rawHit.pos,
-          layoutEpoch: rawHit.layoutEpoch,
-          mappedPos: hit.pos
-        };
-        this.#updateSelectionDebugHud();
-        const anchor = this.#dragAnchor;
-        const head = hit.pos;
-        const { selAnchor, selHead } = this.#calculateExtendedSelection(anchor, head, this.#dragExtensionMode);
-        debugLog(
-          "verbose",
-          `Drag selection update ${JSON.stringify({
-            pointer: { clientX: event.clientX, clientY: event.clientY, x: normalized.x, y: normalized.y },
-            prevPointer,
-            rawHit: {
-              pos: rawHit.pos,
-              pageIndex: rawHit.pageIndex,
-              blockId: rawHit.blockId,
-              lineIndex: rawHit.lineIndex,
-              layoutEpoch: rawHit.layoutEpoch
-            },
-            prevRawHit: prevRawHit ? {
-              pos: prevRawHit.pos,
-              pageIndex: prevRawHit.pageIndex,
-              blockId: prevRawHit.blockId,
-              lineIndex: prevRawHit.lineIndex,
-              layoutEpoch: prevRawHit.layoutEpoch
-            } : null,
-            mappedHead: { pos: mappedHead.pos, fromEpoch: mappedHead.fromEpoch, toEpoch: mappedHead.toEpoch },
-            hit: { pos: hit.pos, pageIndex: hit.pageIndex, layoutEpoch: hit.layoutEpoch },
-            anchor,
-            head,
-            selAnchor,
-            selHead,
-            direction: head >= anchor ? "down" : "up",
-            selectionDirection: selHead >= selAnchor ? "down" : "up",
-            extensionMode: this.#dragExtensionMode,
-            hitSource: pageMounted ? "dom" : "geometry",
-            pageMounted
-          })}`
-        );
-        const currentTableHit = this.#hitTestTable(normalized.x, normalized.y);
-        const shouldUseCellSel = this.#shouldUseCellSelection(currentTableHit);
-        if (shouldUseCellSel && this.#cellAnchor) {
-          const headCellPos = currentTableHit ? this.#getCellPosFromTableHit(currentTableHit) : null;
-          if (headCellPos !== null) {
-            if (this.#cellDragMode !== "active") {
-              this.#cellDragMode = "active";
-            }
-            try {
-              const doc22 = this.#editor.state.doc;
-              const anchorCellPos = this.#cellAnchor.cellPos;
-              const clampedAnchor = Math.max(0, Math.min(anchorCellPos, doc22.content.size));
-              const clampedHead = Math.max(0, Math.min(headCellPos, doc22.content.size));
-              const cellSelection = CellSelection.create(doc22, clampedAnchor, clampedHead);
-              const tr = this.#editor.state.tr.setSelection(cellSelection);
-              this.#editor.view?.dispatch(tr);
-              this.#scheduleSelectionUpdate();
-            } catch (error) {
-              console.warn("[CELL-SELECTION] Failed to create CellSelection, falling back to TextSelection:", error);
-              const anchor2 = this.#dragAnchor;
-              const head2 = hit.pos;
-              const { selAnchor: selAnchor2, selHead: selHead2 } = this.#calculateExtendedSelection(anchor2, head2, this.#dragExtensionMode);
-              try {
-                const tr = this.#editor.state.tr.setSelection(
-                  TextSelection$1.create(this.#editor.state.doc, selAnchor2, selHead2)
-                );
-                this.#editor.view?.dispatch(tr);
-                this.#scheduleSelectionUpdate();
-              } catch {
-              }
-            }
-            return;
-          }
-        }
-        try {
-          const tr = this.#editor.state.tr.setSelection(TextSelection$1.create(this.#editor.state.doc, selAnchor, selHead));
-          this.#editor.view?.dispatch(tr);
-          this.#scheduleSelectionUpdate();
-        } catch (error) {
-          console.warn("[SELECTION] Failed to extend selection during drag:", {
-            error,
-            anchor,
-            head,
-            selAnchor,
-            selHead,
-            mode: this.#dragExtensionMode
-          });
-        }
-        return;
-      }
-      const sessionMode = this.#headerFooterSession?.session?.mode ?? "body";
-      if (sessionMode !== "body") {
-        this.#clearHoverRegion();
-        return;
-      }
-      if (this.#documentMode === "viewing") {
-        this.#clearHoverRegion();
-        return;
-      }
-      const region = this.#hitTestHeaderFooterRegion(normalized.x, normalized.y);
-      if (!region) {
-        this.#clearHoverRegion();
-        return;
-      }
-      const currentHover = this.#headerFooterSession?.hoverRegion;
-      if (currentHover && currentHover.kind === region.kind && currentHover.pageIndex === region.pageIndex && currentHover.sectionType === region.sectionType) {
-        return;
-      }
-      this.#headerFooterSession?.renderHover(region);
-      this.#renderHoverRegion(region);
-    };
-    #handlePointerLeave = () => {
-      this.#clearHoverRegion();
-    };
-    #handleVisibleHostFocusIn = (event) => {
-      if (isInRegisteredSurface(event)) {
-        return;
-      }
-      if (this.#suppressFocusInFromDraggable) {
-        this.#suppressFocusInFromDraggable = false;
-        return;
-      }
-      const target = event.target;
-      const activeTarget = this.#getActiveDomTarget();
-      if (!activeTarget) {
-        return;
-      }
-      const activeNode = activeTarget;
-      const containsFn = typeof activeNode.contains === "function" ? activeNode.contains : null;
-      if (target && (activeNode === target || containsFn && containsFn.call(activeNode, target))) {
-        return;
-      }
-      try {
-        if (activeTarget instanceof HTMLElement && typeof activeTarget.focus === "function") {
-          activeTarget.focus?.({
-            preventScroll: true
-          });
-        } else if (typeof activeTarget.focus === "function") {
-          activeTarget.focus();
-        }
-      } catch {
-      }
-      try {
-        this.getActiveEditor().view?.focus();
-      } catch {
-      }
-    };
-    #handlePointerUp = (event) => {
-      this.#suppressFocusInFromDraggable = false;
-      if (!this.#isDragging) return;
-      if (typeof this.#viewportHost.hasPointerCapture === "function" && typeof this.#viewportHost.releasePointerCapture === "function" && this.#viewportHost.hasPointerCapture(event.pointerId)) {
-        this.#viewportHost.releasePointerCapture(event.pointerId);
-      }
-      const pendingMarginClick = this.#pendingMarginClick;
-      this.#pendingMarginClick = null;
-      const dragAnchor = this.#dragAnchor;
-      const dragMode = this.#dragExtensionMode;
-      const dragUsedFallback = this.#dragUsedPageNotMountedFallback;
-      const dragPointer = this.#dragLastPointer;
-      this.#isDragging = false;
-      if (this.#cellDragMode !== "none") {
-        this.#cellDragMode = "none";
-      }
-      if (!pendingMarginClick || pendingMarginClick.pointerId !== event.pointerId) {
-        this.#updateSelectionVirtualizationPins({ includeDragBuffer: false });
-        if (dragUsedFallback && dragAnchor != null) {
-          const pointer = dragPointer ?? { clientX: event.clientX, clientY: event.clientY };
-          this.#finalizeDragSelectionWithDom(pointer, dragAnchor, dragMode);
-        }
-        this.#scheduleA11ySelectionAnnouncement({ immediate: true });
-        this.#dragLastPointer = null;
-        this.#dragLastRawHit = null;
-        this.#dragUsedPageNotMountedFallback = false;
-        return;
-      }
-      const sessionModeForDrag = this.#headerFooterSession?.session?.mode ?? "body";
-      if (sessionModeForDrag !== "body" || this.#isViewLocked()) {
-        this.#dragLastPointer = null;
-        this.#dragLastRawHit = null;
-        this.#dragUsedPageNotMountedFallback = false;
-        return;
-      }
-      const doc2 = this.#editor.state?.doc;
-      if (!doc2) {
-        this.#dragLastPointer = null;
-        this.#dragLastRawHit = null;
-        this.#dragUsedPageNotMountedFallback = false;
-        return;
-      }
-      if (pendingMarginClick.kind === "aboveFirstLine") {
-        const pos = this.#getFirstTextPosition();
-        try {
-          const tr = this.#editor.state.tr.setSelection(TextSelection$1.create(doc2, pos));
-          this.#editor.view?.dispatch(tr);
-          this.#scheduleSelectionUpdate();
-        } catch {
-        }
-        this.#debugLastHit = { source: "margin", pos: null, layoutEpoch: null, mappedPos: pos };
-        this.#updateSelectionDebugHud();
-        this.#dragLastPointer = null;
-        this.#dragLastRawHit = null;
-        this.#dragUsedPageNotMountedFallback = false;
-        return;
-      }
-      if (pendingMarginClick.kind === "right") {
-        const mappedEnd2 = this.#epochMapper.mapPosFromLayoutToCurrentDetailed(
-          pendingMarginClick.pmEnd,
-          pendingMarginClick.layoutEpoch,
-          1
-        );
-        if (!mappedEnd2.ok) {
-          debugLog("warn", "right margin mapping failed", mappedEnd2);
-          this.#pendingDocChange = true;
-          this.#scheduleRerender();
-          this.#dragLastPointer = null;
-          this.#dragLastRawHit = null;
-          this.#dragUsedPageNotMountedFallback = false;
-          return;
-        }
-        const caretPos = Math.max(0, Math.min(mappedEnd2.pos, doc2.content.size));
-        try {
-          const tr = this.#editor.state.tr.setSelection(TextSelection$1.create(doc2, caretPos));
-          this.#editor.view?.dispatch(tr);
-          this.#scheduleSelectionUpdate();
-        } catch {
-        }
-        this.#debugLastHit = {
-          source: "margin",
-          pos: pendingMarginClick.pmEnd,
-          layoutEpoch: pendingMarginClick.layoutEpoch,
-          mappedPos: caretPos
-        };
-        this.#updateSelectionDebugHud();
-        this.#dragLastPointer = null;
-        this.#dragLastRawHit = null;
-        this.#dragUsedPageNotMountedFallback = false;
-        return;
-      }
-      const mappedStart = this.#epochMapper.mapPosFromLayoutToCurrentDetailed(
-        pendingMarginClick.pmStart,
-        pendingMarginClick.layoutEpoch,
-        1
-      );
-      const mappedEnd = this.#epochMapper.mapPosFromLayoutToCurrentDetailed(
-        pendingMarginClick.pmEnd,
-        pendingMarginClick.layoutEpoch,
-        -1
-      );
-      if (!mappedStart.ok || !mappedEnd.ok) {
-        if (!mappedStart.ok) debugLog("warn", "left margin mapping failed (start)", mappedStart);
-        if (!mappedEnd.ok) debugLog("warn", "left margin mapping failed (end)", mappedEnd);
-        this.#pendingDocChange = true;
-        this.#scheduleRerender();
-        this.#dragLastPointer = null;
-        this.#dragLastRawHit = null;
-        this.#dragUsedPageNotMountedFallback = false;
-        return;
-      }
-      const selFrom = Math.max(0, Math.min(Math.min(mappedStart.pos, mappedEnd.pos), doc2.content.size));
-      const selTo = Math.max(0, Math.min(Math.max(mappedStart.pos, mappedEnd.pos), doc2.content.size));
-      try {
-        const tr = this.#editor.state.tr.setSelection(TextSelection$1.create(doc2, selFrom, selTo));
-        this.#editor.view?.dispatch(tr);
-        this.#scheduleSelectionUpdate();
-      } catch {
-      }
-      this.#debugLastHit = {
-        source: "margin",
-        pos: pendingMarginClick.pmStart,
-        layoutEpoch: pendingMarginClick.layoutEpoch,
-        mappedPos: selFrom
-      };
-      this.#updateSelectionDebugHud();
-      this.#dragLastPointer = null;
-      this.#dragLastRawHit = null;
-      this.#dragUsedPageNotMountedFallback = false;
-    };
-    #handleDragOver = createExternalFieldAnnotationDragOverHandler({
-      getActiveEditor: () => this.getActiveEditor(),
-      hitTest: (clientX, clientY) => this.hitTest(clientX, clientY),
-      scheduleSelectionUpdate: () => this.#scheduleSelectionUpdate()
-    });
-    #handleDrop = createExternalFieldAnnotationDropHandler({
-      getActiveEditor: () => this.getActiveEditor(),
-      hitTest: (clientX, clientY) => this.hitTest(clientX, clientY),
-      scheduleSelectionUpdate: () => this.#scheduleSelectionUpdate()
-    });
-    #handleDoubleClick = (event) => {
-      if (event.button !== 0) return;
-      if (!this.#layoutState.layout) return;
-      const rect = this.#viewportHost.getBoundingClientRect();
-      const zoom = this.#layoutOptions.zoom ?? 1;
-      const scrollLeft = this.#visibleHost.scrollLeft ?? 0;
-      const scrollTop = this.#visibleHost.scrollTop ?? 0;
-      const x2 = (event.clientX - rect.left + scrollLeft) / zoom;
-      const y2 = (event.clientY - rect.top + scrollTop) / zoom;
-      const region = this.#hitTestHeaderFooterRegion(x2, y2);
-      if (region) {
-        event.preventDefault();
-        event.stopPropagation();
-        const descriptor = this.#resolveDescriptorForRegion(region);
-        const hfManager = this.#headerFooterSession?.manager;
-        if (!descriptor && hfManager) {
-          this.#createDefaultHeaderFooter(region);
-          hfManager.refresh();
-        }
-        this.#activateHeaderFooterRegion(region);
-      } else if ((this.#headerFooterSession?.session?.mode ?? "body") !== "body") {
-        this.#exitHeaderFooterMode();
-      }
-    };
-    #handleKeyDown = (event) => {
-      const sessionModeForKey = this.#headerFooterSession?.session?.mode ?? "body";
-      if (event.key === "Escape" && sessionModeForKey !== "body") {
-        event.preventDefault();
-        this.#exitHeaderFooterMode();
-        return;
-      }
-      if (event.ctrlKey && event.altKey && !event.shiftKey) {
-        if (event.code === "KeyH") {
-          event.preventDefault();
-          this.#focusHeaderFooterShortcut("header");
-        } else if (event.code === "KeyF") {
-          event.preventDefault();
-          this.#focusHeaderFooterShortcut("footer");
-        }
-      }
-    };
-    #focusHeaderFooterShortcut(kind) {
-      const pageIndex = this.#getCurrentPageIndex();
-      const region = this.#findRegionForPage(kind, pageIndex);
-      if (!region) {
-        this.#emitHeaderFooterEditBlocked("missingRegion");
-        return;
-      }
-      this.#activateHeaderFooterRegion(region);
-    }
     #scheduleRerender() {
       if (this.#renderScheduled) {
         return;
@@ -107970,7 +107849,7 @@ ${o}
         return;
       }
       this.#syncSelectedFieldAnnotationClass(selection);
-      this.#updateSelectionVirtualizationPins({ includeDragBuffer: this.#isDragging });
+      this.#updateSelectionVirtualizationPins({ includeDragBuffer: this.#editorInputManager?.isDragging ?? false });
       if (selection instanceof CellSelection) {
         try {
           this.#localSelectionLayer.innerHTML = "";
@@ -108718,7 +108597,7 @@ ${o}
         {
           ariaLiveRegion: this.#ariaLiveRegion,
           sessionMode,
-          isDragging: this.#isDragging,
+          isDragging: this.#editorInputManager?.isDragging ?? false,
           visibleHost: this.#visibleHost,
           currentTimeout: this.#a11ySelectionAnnounceTimeout,
           announceNow: () => {
@@ -108846,9 +108725,9 @@ ${o}
         } : null,
         docSize,
         includeDragBuffer: Boolean(options?.includeDragBuffer),
-        isDragging: this.#isDragging,
-        dragAnchorPageIndex: this.#dragAnchorPageIndex,
-        dragLastHitPageIndex: this.#dragLastRawHit ? this.#dragLastRawHit.pageIndex : null,
+        isDragging: this.#editorInputManager?.isDragging ?? false,
+        dragAnchorPageIndex: this.#editorInputManager?.dragAnchorPageIndex ?? null,
+        dragLastHitPageIndex: this.#editorInputManager?.dragLastHitPageIndex ?? null,
         extraPages: options?.extraPages
       });
       painter.setVirtualizationPins(pins);
@@ -108862,9 +108741,10 @@ ${o}
       }
       const normalized = this.#normalizeClientPoint(pointer.clientX, pointer.clientY);
       if (!normalized) return;
+      const dragLastRawHit = this.#editorInputManager?.dragLastRawHit;
       this.#updateSelectionVirtualizationPins({
         includeDragBuffer: false,
-        extraPages: this.#dragLastRawHit ? [this.#dragLastRawHit.pageIndex] : void 0
+        extraPages: dragLastRawHit ? [dragLastRawHit.pageIndex] : void 0
       });
       const refined = clickToPosition(
         layout,
@@ -108881,7 +108761,7 @@ ${o}
         debugLog("warn", "Drag finalize: endpoint page still not mounted", { pageIndex: refined.pageIndex });
         return;
       }
-      const prior = this.#dragLastRawHit;
+      const prior = dragLastRawHit;
       if (prior && (prior.pos !== refined.pos || prior.pageIndex !== refined.pageIndex)) {
         debugLog("info", "Drag finalize refined hit", {
           fromPos: prior.pos,
@@ -109084,7 +108964,7 @@ ${o}
         localSelectionLayer,
         blocks: this.#layoutState.blocks,
         measures: this.#layoutState.measures,
-        cellAnchorTableBlockId: this.#cellAnchor?.tableBlockId ?? null,
+        cellAnchorTableBlockId: this.#editorInputManager?.cellAnchor?.tableBlockId ?? null,
         convertPageLocalToOverlayCoords: (pageIndex, x2, y2) => this.#convertPageLocalToOverlayCoords(pageIndex, x2, y2)
       });
     }
@@ -153615,7 +153495,7 @@ ${reason}`);
       this.config.colors = shuffleArray(this.config.colors);
       this.userColorMap = /* @__PURE__ */ new Map();
       this.colorIndex = 0;
-      this.version = "1.8.0-next.3";
+      this.version = "1.8.0-next.4";
       this.#log("🦋 [superdoc] Using SuperDoc version:", this.version);
       this.superdocId = config2.superdocId || v4();
       this.colors = this.config.colors;