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

package/dist/chunks/{index-DJtl6sUM.cjs → index-zX9xjVrM.cjs}

@@ -1,7 +1,7 @@
 "use strict";
 const jszip = require("./jszip-C8_CqJxM.cjs");
 const helpers$1 = require("./helpers-nOdwpmwb.cjs");
-const superEditor_converter = require("./SuperConverter-0rmmECRS.cjs");
+const superEditor_converter = require("./SuperConverter-z513kcRv.cjs");
 const vue = require("./vue-De9wkgLl.cjs");
 require("./jszip.min-BPh2MMAa.cjs");
 const eventemitter3 = require("./eventemitter3-BQuRcMPI.cjs");
@@ -16102,7 +16102,7 @@ const canUseDOM = () => {
     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) {
@@ -18759,7 +18759,7 @@ class Editor extends EventEmitter {
    * 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");
@@ -28801,24 +28801,6 @@ class DomPainter {
     }
     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).
@@ -40156,255 +40138,6 @@ var Priority = /* @__PURE__ */ ((Priority2) => {
   /** 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(element) {
-  const dataset = element.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, config = {}) {
-    this.container = container;
-    this.config = config;
-    this.mimeType = config.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 types = event.dataTransfer.types;
-    return types.includes(this.mimeType) || types.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(config) {
-    this.config = { ...this.config, ...config };
-    if (config.mimeType) {
-      this.mimeType = config.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, config = {}) {
-  const handler = new DragHandler(container, config);
-  return () => handler.destroy();
-}
 const isAtomicFragment = (fragment) => {
   return fragment.kind === "drawing" || fragment.kind === "image";
 };
@@ -41968,230 +41701,1432 @@ class RemoteCursorManager {
     this.#isSetup = false;
   }
 }
-const createDefaultScheduler = () => {
-  if (typeof window !== "undefined" && typeof window.requestAnimationFrame === "function") {
-    return {
-      requestAnimationFrame: (cb) => window.requestAnimationFrame(cb),
-      cancelAnimationFrame: (handle) => window.cancelAnimationFrame(handle)
-    };
+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: (handle) => anyGlobal.cancelAnimationFrame(handle)
-    };
+  return WORD_CHARACTER_REGEX.test(char);
+}
+function calculateExtendedSelection(blocks, anchor, head, mode) {
+  if (mode === "word") {
+    const anchorBounds = findWordBoundaries(blocks, anchor);
+    const headBounds = findWordBoundaries(blocks, 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(blocks, anchor);
+    const headBounds = findParagraphBoundaries(blocks, 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, previous, options) {
+  const time2 = event.timeStamp ?? performance.now();
+  const timeDelta = time2 - previous.lastClickTime;
+  const withinTime = timeDelta <= options.timeThresholdMs;
+  const distanceX = Math.abs(event.clientX - previous.lastClickPosition.x);
+  const distanceY = Math.abs(event.clientY - previous.lastClickPosition.y);
+  const withinDistance = distanceX <= options.distanceThresholdPx && distanceY <= options.distanceThresholdPx;
+  const clickCount = withinTime && withinDistance ? Math.min(previous.clickCount + 1, options.maxClickCount) : 1;
   return {
-    requestAnimationFrame: (cb) => {
-      const handle = anyGlobal.setTimeout?.(() => cb(Date.now()), 0);
-      return handle;
-    },
-    cancelAnimationFrame: (handle) => {
-      anyGlobal.clearTimeout?.(handle);
-    }
+    clickCount,
+    lastClickTime: time2,
+    lastClickPosition: { x: event.clientX, y: event.clientY }
   };
-};
-class SelectionSyncCoordinator extends EventEmitter {
-  #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, (node, pos) => {
+    if (node.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, blocks) {
+  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 = blocks.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((node, pos) => {
+      if (node.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 row = tableNode.child(r2);
+    if (r2 === targetRowIndex) {
+      currentPos += 1;
+      let logicalCol = 0;
+      for (let cellIndex = 0; cellIndex < row.childCount; cellIndex++) {
+        const cell = row.child(cellIndex);
+        const rawColspan = cell.attrs?.colspan;
+        const colspan = typeof rawColspan === "number" && Number.isFinite(rawColspan) && rawColspan > 0 ? rawColspan : 1;
+        if (targetColIndex >= logicalCol && targetColIndex < logicalCol + colspan) {
+          return currentPos;
+        }
+        currentPos += cell.nodeSize;
+        logicalCol += colspan;
       }
+      console.warn("[getCellPosFromTableHit] Target column not found in row:", {
+        targetColIndex,
+        logicalColReached: logicalCol,
+        rowCellCount: row.childCount
+      });
+      return null;
+    } else {
+      currentPos += row.nodeSize;
     }
-    this.#scheduled = false;
   }
+  return null;
 }
-const uiSurfaces = /* @__PURE__ */ new WeakSet();
-function isInRegisteredSurface(event) {
-  const path = typeof event.composedPath === "function" ? event.composedPath() : [];
+function getTablePosFromHit(tableHit, doc2, blocks) {
+  if (!doc2) return null;
+  const tableBlocks = blocks.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((node, pos) => {
+    if (node.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, blocks, 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 i = 0; i < layout.pages.length; i++) {
+      const page = layout.pages[i];
+      const pageHeight = page.size?.h ?? configuredPageHeight;
+      if (normalizedY >= pageY && normalizedY < pageY + pageHeight) {
+        pageHit = { pageIndex: i, page };
+        break;
+      }
+      pageY += pageHeight + gap;
+    }
+  }
+  if (!pageHit) {
+    return null;
+  }
+  const pageRelativeY = normalizedY - pageY;
+  const point = { x: normalizedX, y: pageRelativeY };
+  return hitTestTableFragment(pageHit, blocks, measures, point);
+}
+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(x, y2) {
+    return this.#callbacks.hitTestTable?.(x, 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, y: y2 } = normalizedPoint;
+    this.#debugLastPointer = { clientX: event.clientX, clientY: event.clientY, x, y: y2 };
+    const sessionMode = this.#deps.getHeaderFooterSession()?.session?.mode ?? "body";
+    if (sessionMode !== "body") {
+      if (this.#handleClickInHeaderFooterMode(event, x, y2)) return;
+    }
+    const headerFooterRegion = this.#callbacks.hitTestHeaderFooterRegion?.(x, y2);
+    if (headerFooterRegion) return;
+    const viewportHost = this.#deps.getViewportHost();
+    const pageGeometryHelper = this.#deps.getPageGeometryHelper();
+    const rawHit = clickToPosition(
+      layoutState.layout,
+      layoutState.blocks,
+      layoutState.measures,
+      { x, 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, x, y2) ?? null;
+      const tableHit = this.#hitTestTable(x, 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, 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 = superEditor_converter.TextSelection.create(doc2, hit.pos);
+        if (!nextSelection.$from.parent.inlineContent) {
+          nextSelection = superEditor_converter.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 x = (event.clientX - rect.left + scrollLeft) / zoom;
+    const y2 = (event.clientY - rect.top + scrollTop) / zoom;
+    const region = this.#callbacks.hitTestHeaderFooterRegion?.(x, 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(superEditor_converter.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, x, 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?.(x, 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(superEditor_converter.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) {
+      if (vue.process$1.env.NODE_ENV === "development") {
+        console.warn(`[EditorInputManager] Failed to create NodeSelection for inline image:`, 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(superEditor_converter.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) {
+      if (vue.process$1.env.NODE_ENV === "development") {
+        console.warn("[EditorInputManager] Failed to create NodeSelection for atomic fragment:", 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(superEditor_converter.TextSelection.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(superEditor_converter.TextSelection.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(superEditor_converter.TextSelection.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(superEditor_converter.TextSelection.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(superEditor_converter.TextSelection.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(superEditor_converter.TextSelection.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(superEditor_converter.TextSelection.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: (handle) => window.cancelAnimationFrame(handle)
+    };
+  }
+  const anyGlobal = globalThis;
+  if (typeof anyGlobal.requestAnimationFrame === "function" && typeof anyGlobal.cancelAnimationFrame === "function") {
+    return {
+      requestAnimationFrame: (cb) => anyGlobal.requestAnimationFrame(cb),
+      cancelAnimationFrame: (handle) => anyGlobal.cancelAnimationFrame(handle)
+    };
+  }
+  return {
+    requestAnimationFrame: (cb) => {
+      const handle = anyGlobal.setTimeout?.(() => cb(Date.now()), 0);
+      return handle;
+    },
+    cancelAnimationFrame: (handle) => {
+      anyGlobal.clearTimeout?.(handle);
+    }
+  };
+};
+class SelectionSyncCoordinator extends EventEmitter {
+  #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 path = typeof event.composedPath === "function" ? event.composedPath() : [];
   if (path.length > 0) {
     for (const node2 of path) {
       if (uiSurfaces.has(node2)) return true;
@@ -42552,37 +43487,6 @@ class PresentationInputBridge {
     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(blocks, anchor, head, mode) {
-  if (mode === "word") {
-    const anchorBounds = findWordBoundaries(blocks, anchor);
-    const headBounds = findWordBoundaries(blocks, 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(blocks, anchor);
-    const headBounds = findParagraphBoundaries(blocks, 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 types = [];
@@ -42638,104 +43542,6 @@ function buildPositionMapFromPmDoc(pmDoc, jsonDoc) {
   if (!ok) return null;
   return map3;
 }
-function registerPointerClick(event, previous, options) {
-  const time2 = event.timeStamp ?? performance.now();
-  const timeDelta = time2 - previous.lastClickTime;
-  const withinTime = timeDelta <= options.timeThresholdMs;
-  const distanceX = Math.abs(event.clientX - previous.lastClickPosition.x);
-  const distanceY = Math.abs(event.clientY - previous.lastClickPosition.y);
-  const withinDistance = distanceX <= options.distanceThresholdPx && distanceY <= options.distanceThresholdPx;
-  const clickCount = withinTime && withinDistance ? Math.min(previous.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, (node, pos) => {
-    if (node.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 element = pmDom;
   if (!(element instanceof HTMLElement)) return;
@@ -43405,317 +44211,255 @@ async function goToAnchor({
   }
   return true;
 }
-function getCellPosFromTableHit(tableHit, doc2, blocks) {
-  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 = blocks.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((node, pos) => {
-      if (node.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 row = tableNode.child(r2);
-    if (r2 === targetRowIndex) {
-      currentPos += 1;
-      let logicalCol = 0;
-      for (let cellIndex = 0; cellIndex < row.childCount; cellIndex++) {
-        const cell = row.child(cellIndex);
-        const rawColspan = cell.attrs?.colspan;
-        const colspan = typeof rawColspan === "number" && Number.isFinite(rawColspan) && rawColspan > 0 ? rawColspan : 1;
-        if (targetColIndex >= logicalCol && targetColIndex < logicalCol + colspan) {
-          return currentPos;
-        }
-        currentPos += cell.nodeSize;
-        logicalCol += colspan;
-      }
-      console.warn("[getCellPosFromTableHit] Target column not found in row:", {
-        targetColIndex,
-        logicalColReached: logicalCol,
-        rowCellCount: row.childCount
-      });
-      return null;
-    } else {
-      currentPos += row.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 a = attrs;
+  return typeof a.fieldId === "string" && typeof a.fieldType === "string" && typeof a.displayLabel === "string" && typeof a.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(element) {
+  const dataset = element.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, blocks) {
-  if (!doc2) return null;
-  const tableBlocks = blocks.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((node, pos) => {
-    if (node.type.name === "table") {
-      if (currentTableIndex === targetTableIndex) {
-        tablePos = pos;
-        return false;
-      }
-      currentTableIndex++;
-    }
-    return true;
-  });
-  return tablePos;
+function hasFieldAnnotationData(event) {
+  if (!event.dataTransfer) return false;
+  const types = event.dataTransfer.types;
+  return types.includes(INTERNAL_MIME_TYPE) || types.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, blocks, 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 i = 0; i < layout.pages.length; i++) {
-      const page = layout.pages[i];
-      const pageHeight = page.size?.h ?? configuredPageHeight;
-      if (normalizedY >= pageY && normalizedY < pageY + pageHeight) {
-        pageHit = { pageIndex: i, 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 point = { x: normalizedX, y: pageRelativeY };
-  return hitTestTableFragment(pageHit, blocks, measures, point);
-}
-function isValidFieldAnnotationAttributes(attrs) {
-  if (!attrs || typeof attrs !== "object") return false;
-  const a = attrs;
-  return typeof a.fieldId === "string" && typeof a.fieldType === "string" && typeof a.displayLabel === "string" && typeof a.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 superEditor_converter.TextSelection && currentSelection.from === pos && currentSelection.to === pos) {
-        return;
-      }
-      try {
-        const tr = activeEditor.state.tr.setSelection(superEditor_converter.TextSelection.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((node, pos) => {
-            if (node.type.name === "fieldAnnotation" && node.attrs.fieldId === fieldId) {
-              sourceStart = pos;
-              sourceEnd = pos + node.nodeSize;
-              sourceNode = node;
-              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 superEditor_converter.TextSelection && currentSelection.from === pos && currentSelection.to === pos;
-    if (isSameCursor) {
+    if (currentSelection instanceof superEditor_converter.TextSelection && currentSelection.from === pos && currentSelection.to === pos) {
       return;
     }
     try {
       const tr = activeEditor.state.tr.setSelection(superEditor_converter.TextSelection.create(doc2, pos)).setMeta("addToHistory", false);
       activeEditor.view?.dispatch(tr);
-      scheduleSelectionUpdate();
-    } catch (error) {
-      if (vue.process$1.env.NODE_ENV === "development") {
-        console.debug("[PresentationEditor] Drag position update skipped:", 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((node, pos) => {
+        if (node.type.name === "fieldAnnotation" && node.attrs.fieldId === data.fieldId) {
+          sourceStart = pos;
+          sourceEnd = pos + node.nodeSize;
+          sourceNode = node;
+          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);
@@ -43726,7 +44470,7 @@ function createExternalFieldAnnotationDropHandler({
     activeEditor.emit?.("fieldAnnotationDropped", {
       sourceField,
       editor: activeEditor,
-      coordinates: hit,
+      coordinates: this.#deps.hitTest(event.clientX, event.clientY),
       pos
     });
     if (attributes && isValidFieldAnnotationAttributes(attributes)) {
@@ -43736,14 +44480,49 @@ function createExternalFieldAnnotationDropHandler({
       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";
@@ -45797,16 +46576,17 @@ const normalizeParagraphSpacing = (value) => {
   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;
@@ -55622,8 +56402,6 @@ const DEFAULT_MARGINS = { top: 72, right: 72, bottom: 72, left: 72 };
 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;
@@ -55679,7 +56457,7 @@ class PresentationEditor extends EventEmitter {
   #layoutState = { blocks: [], measures: [], layout: null, bookmarks: /* @__PURE__ */ new Map() };
   #domPainter = null;
   #pageGeometryHelper = null;
-  #dragHandlerCleanup = null;
+  #dragDropManager = null;
   #layoutError = null;
   #layoutErrorState = "healthy";
   #errorBanner = null;
@@ -55696,9 +56474,6 @@ class PresentationEditor extends EventEmitter {
   #htmlAnnotationMeasureAttempts = 0;
   #domPositionIndex = new DomPositionIndex();
   #domIndexObserverManager = null;
-  #debugLastPointer = null;
-  #debugLastHit = null;
-  #pendingMarginClick = null;
   #rafHandle = null;
   #editorListeners = [];
   #sectionMetadata = [];
@@ -55715,25 +56490,7 @@ class PresentationEditor extends EventEmitter {
   #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;
@@ -55741,6 +56498,9 @@ class PresentationEditor extends EventEmitter {
   #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) {
@@ -55949,6 +56709,7 @@ class PresentationEditor extends EventEmitter {
       this.#setupHeaderFooterSession();
       this.#applyZoom();
       this.#setupEditorListeners();
+      this.#initializeEditorInputManager();
       this.#setupPointerHandlers();
       this.#setupDragHandlers();
       this.#setupInputBridge();
@@ -56873,8 +57634,8 @@ class PresentationEditor extends EventEmitter {
         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 {
     }
@@ -57267,15 +58028,12 @@ class PresentationEditor extends EventEmitter {
     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;
@@ -57283,7 +58041,6 @@ class PresentationEditor extends EventEmitter {
       clearTimeout(this.#a11ySelectionAnnounceTimeout);
       this.#a11ySelectionAnnounceTimeout = null;
     }
-    this.#clearCellAnchor();
     if (this.#options?.documentId) {
       PresentationEditor.#instances.delete(this.#options.documentId);
     }
@@ -57293,8 +58050,8 @@ class PresentationEditor extends EventEmitter {
     }, "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();
@@ -57341,7 +58098,7 @@ class PresentationEditor extends EventEmitter {
       }
       if (transaction?.docChanged) {
         this.#updateLocalAwarenessCursor();
-        this.#clearCellAnchor();
+        this.#editorInputManager?.clearCellAnchor();
       }
     };
     const handleSelection = () => {
@@ -57445,31 +58202,75 @@ class PresentationEditor extends EventEmitter {
   #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: (x, y2) => this.#hitTestHeaderFooterRegion(x, 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, x, y2) => this.#computePendingMarginClick(pointerId, x, y2),
+      selectWordAt: (pos) => this.#selectWordAt(pos),
+      selectParagraphAt: (pos) => this.#selectParagraphAt(pos),
+      finalizeDragSelectionWithDom: (pointer, dragAnchor, dragMode) => this.#finalizeDragSelectionWithDom(pointer, dragAnchor, dragMode),
+      hitTestTable: (x, y2) => this.#hitTestTable(x, 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.
@@ -57587,536 +58388,6 @@ class PresentationEditor extends EventEmitter {
     });
     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(superEditor_converter.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(superEditor_converter.TextSelection.create(doc22, validPos));
-          this.#editor.view?.dispatch(tr);
-        } catch (error) {
-          if (vue.process$1.env.NODE_ENV === "development") {
-            console.warn("[PresentationEditor] Failed to set selection to first text position:", error);
-          }
-        }
-      }
-      editorDom2.focus();
-      this.#editor.view?.focus();
-      this.#scheduleSelectionUpdate();
-      return;
-    }
-    const normalizedPoint = this.#normalizeClientPoint(event.clientX, event.clientY);
-    if (!normalizedPoint) {
-      return;
-    }
-    const { x, y: y2 } = normalizedPoint;
-    this.#debugLastPointer = { clientX: event.clientX, clientY: event.clientY, x, 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(x, y2);
-      if (!headerFooterRegion2) {
-        this.#exitHeaderFooterMode();
-      } else {
-        return;
-      }
-    }
-    const headerFooterRegion = this.#hitTestHeaderFooterRegion(x, y2);
-    if (headerFooterRegion) {
-      return;
-    }
-    const rawHit = clickToPosition(
-      this.#layoutState.layout,
-      this.#layoutState.blocks,
-      this.#layoutState.measures,
-      { x, 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(superEditor_converter.TextSelection.create(doc22, validPos));
-            this.#editor.view?.dispatch(tr);
-          } catch (error) {
-            if (vue.process$1.env.NODE_ENV === "development") {
-              console.warn("[PresentationEditor] Failed to set selection to first text position:", 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) {
-        if (vue.process$1.env.NODE_ENV === "development") {
-          console.warn(
-            `[PresentationEditor] Invalid position ${clampedImgPos} for inline image (document size: ${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(superEditor_converter.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) {
-        if (vue.process$1.env.NODE_ENV === "development") {
-          console.warn(
-            `[PresentationEditor] Failed to create NodeSelection for inline image at position ${imgPmStart}:`,
-            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(superEditor_converter.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) {
-        if (vue.process$1.env.NODE_ENV === "development") {
-          console.warn("[PresentationEditor] Failed to create NodeSelection for atomic fragment:", 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(superEditor_converter.TextSelection.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, x, y2);
-      const tableHit = this.#hitTestTable(x, 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, 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, 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 = superEditor_converter.TextSelection.create(doc22, hit.pos);
-        if (!nextSelection.$from.parent.inlineContent) {
-          nextSelection = superEditor_converter.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.
    *
@@ -58227,415 +58498,6 @@ class PresentationEditor extends EventEmitter {
   #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(
-                superEditor_converter.TextSelection.create(this.#editor.state.doc, selAnchor2, selHead2)
-              );
-              this.#editor.view?.dispatch(tr);
-              this.#scheduleSelectionUpdate();
-            } catch {
-            }
-          }
-          return;
-        }
-      }
-      try {
-        const tr = this.#editor.state.tr.setSelection(superEditor_converter.TextSelection.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(superEditor_converter.TextSelection.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(superEditor_converter.TextSelection.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(superEditor_converter.TextSelection.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 x = (event.clientX - rect.left + scrollLeft) / zoom;
-    const y2 = (event.clientY - rect.top + scrollTop) / zoom;
-    const region = this.#hitTestHeaderFooterRegion(x, 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;
@@ -59106,7 +58968,7 @@ class PresentationEditor extends EventEmitter {
       return;
     }
     this.#syncSelectedFieldAnnotationClass(selection);
-    this.#updateSelectionVirtualizationPins({ includeDragBuffer: this.#isDragging });
+    this.#updateSelectionVirtualizationPins({ includeDragBuffer: this.#editorInputManager?.isDragging ?? false });
     if (selection instanceof CellSelection) {
       try {
         this.#localSelectionLayer.innerHTML = "";
@@ -59860,7 +59722,7 @@ class PresentationEditor extends EventEmitter {
       {
         ariaLiveRegion: this.#ariaLiveRegion,
         sessionMode,
-        isDragging: this.#isDragging,
+        isDragging: this.#editorInputManager?.isDragging ?? false,
         visibleHost: this.#visibleHost,
         currentTimeout: this.#a11ySelectionAnnounceTimeout,
         announceNow: () => {
@@ -59988,9 +59850,9 @@ class PresentationEditor extends EventEmitter {
       } : 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);
@@ -60004,9 +59866,10 @@ class PresentationEditor extends EventEmitter {
     }
     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,
@@ -60023,7 +59886,7 @@ class PresentationEditor extends EventEmitter {
       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,
@@ -60226,7 +60089,7 @@ class PresentationEditor extends EventEmitter {
       localSelectionLayer,
       blocks: this.#layoutState.blocks,
       measures: this.#layoutState.measures,
-      cellAnchorTableBlockId: this.#cellAnchor?.tableBlockId ?? null,
+      cellAnchorTableBlockId: this.#editorInputManager?.cellAnchor?.tableBlockId ?? null,
       convertPageLocalToOverlayCoords: (pageIndex, x, y2) => this.#convertPageLocalToOverlayCoords(pageIndex, x, y2)
     });
   }