fix(ui): resolve captured-selection rects against the routed editor (SD-2936)

The previous patch documented a body-only limitation; this is the
actual fix. getRects(capture) and getAnchorRect(options, capture) now
take both the host editor (for the presentation layer's getRangeRects)
and the routed editor (for resolveTextTarget against the captured
block ids).

For captures taken in a non-body story (header, footer, footnote,
endnote), the routed editor at call time owns the PM document those
block ids belong to. Resolving against it produces the right positions,
which then flow through presentationEditor.getRangeRects to land on
the right surface. The previous resolveHostEditor-only path resolved
non-body block ids against the body PM doc and silently returned [].

The remaining limitation: when focus has moved to a sidebar / composer
by call time, the routed editor falls back to the body and the
captured non-body block ids no longer resolve there. The function
returns [] gracefully in that case rather than misclassifying. Fully
cross-surface captures need a story-keyed editor lookup on
PresentationEditor that doesn't yet exist publicly — that's a
follow-up.

Author: caio-pizzol

packages/super-editor/src/ui/create-super-doc-ui.ts

@@ -1601,19 +1601,37 @@ export function createSuperDocUI(options: SuperDocUIOptions): SuperDocUI {
       if (!slice.target && !slice.selectionTarget) return null;
       return deepFreeze(deepClone(slice));
     },
-    // Painted-selection rects route through the host editor.
-    // PresentationEditor lives at the host, and the live-selection rect
-    // the painter knows about reflects the routed editor's PM selection
-    // already, so calling against the host returns the right answer for
-    // body / header / footer / note alike.
+    // Painted-selection rects need both editors:
+    //
+    // - The host editor owns the presentation layer (the rect engine
+    //   lives there). The live path also flows through it because
+    //   `presentationEditor.getSelectionRects()` calls `getActiveEditor()`
+    //   internally and dispatches to the routed surface.
+    // - The routed editor owns the PM document that captured block ids
+    //   belong to. For body captures the two editors are the same; for
+    //   captures taken while editing a header / footer / footnote /
+    //   endnote, the routed editor is the story editor and the host
+    //   editor's PM doc would silently fail to resolve those ids.
+    //
+    // When focus has moved to a sidebar / composer by call time, the
+    // routed editor falls back to the body, and a non-body capture's
+    // block ids won't resolve there. The helper returns [] gracefully
+    // in that case (rather than wrong rects from another surface).
     getRects(capture) {
-      const editor = resolveHostEditor(superdoc);
-      return getSelectionRects(editor as unknown as Parameters<typeof getSelectionRects>[0], capture);
+      const hostEditor = resolveHostEditor(superdoc);
+      const routedEditor = resolveRoutedEditor(superdoc);
+      return getSelectionRects(
+        hostEditor as unknown as Parameters<typeof getSelectionRects>[0],
+        routedEditor as unknown as Parameters<typeof getSelectionRects>[1],
+        capture,
+      );
     },
     getAnchorRect(options, capture) {
-      const editor = resolveHostEditor(superdoc);
+      const hostEditor = resolveHostEditor(superdoc);
+      const routedEditor = resolveRoutedEditor(superdoc);
       return getSelectionAnchorRect(
-        editor as unknown as Parameters<typeof getSelectionAnchorRect>[0],
+        hostEditor as unknown as Parameters<typeof getSelectionAnchorRect>[0],
+        routedEditor as unknown as Parameters<typeof getSelectionAnchorRect>[1],
         options,
         capture,
       );

packages/super-editor/src/ui/selection-rects.test.ts

@@ -200,30 +200,6 @@ describe('ui.selection.getRects — captured selection', () => {
     expect(ui.selection.getRects(fakeCapture)).toEqual([]);
   });
 
-  it('returns [] for a capture whose target lives in a non-body story (body-only limitation)', () => {
-    const { superdoc, mocks } = makeStubs({
-      rangeRects: [{ pageIndex: 0, left: 10, top: 10, right: 50, bottom: 30, width: 40, height: 20 }],
-    });
-    const ui = createSuperDocUI({ superdoc });
-
-    const headerCapture = Object.freeze({
-      empty: false,
-      target: {
-        kind: 'text',
-        story: 'header',
-        segments: [{ blockId: 'b1', range: { start: 0, end: 4 } }],
-      },
-      selectionTarget: null,
-      activeMarks: [],
-      activeCommentIds: [],
-      activeChangeIds: [],
-      quotedText: 'test',
-    }) as never;
-
-    expect(ui.selection.getRects(headerCapture)).toEqual([]);
-    expect(mocks.getRangeRects).not.toHaveBeenCalled();
-  });
-
   it('returns [] when getRangeRects is missing on the presentation stub', () => {
     const { superdoc, editor } = makeStubs();
     (editor as { presentationEditor: unknown }).presentationEditor = {

packages/super-editor/src/ui/selection-rects.ts

@@ -21,45 +21,33 @@ interface RawRangeRect {
   height: number;
 }
 
-// Captures whose target lives in a non-body story (header, footer,
-// footnote, endnote) need a story-aware rect resolver on
-// `PresentationEditor` that doesn't yet exist publicly. The live path
-// works for non-body selections because `presentationEditor
-// .getSelectionRects()` calls `getActiveEditor()` internally and
-// dispatches to the right surface; the captured path can't, because by
-// the time the consumer is asking for rects, focus has often moved away
-// (composer textarea, sidebar, modal) and the active surface is back on
-// body. Until a follow-up surfaces a `getRangeRectsForStory(from, to,
-// story)` primitive, captures referencing non-body stories return [].
-// Same posture as `scroll-into-view`'s text-anchored path.
-function captureIsBodyOnly(capture: SelectionCapture): boolean {
-  const story = (capture.target as { story?: unknown } | null)?.story;
-  if (story === undefined || story === null) return true;
-  if (typeof story === 'string') return story === 'body';
-  if (typeof story === 'object') {
-    const kind = (story as { kind?: unknown }).kind;
-    return kind === undefined || kind === 'body';
-  }
-  return true;
-}
-
 /**
  * Resolve the painted rects of the current selection, or of a captured
  * one when `capture` is provided. Empty array when the editor has no
  * presentation layer (SSR / non-paginated mounts), no current selection,
  * or a stale capture whose target no longer resolves.
  *
- * Captures referencing non-body stories return [] — the underlying
- * story-aware rect resolver is a follow-up (body-only matches the same
- * posture as `scroll-into-view`'s text-anchored path).
+ * Two editors are accepted because the capture path needs both:
+ * - `hostEditor` owns the presentation layer (`getRangeRects`).
+ * - `routedEditor` owns the PM document that captured block ids belong
+ *   to. For body-only captures these are the same instance; for
+ *   captures taken while editing a header / footer / footnote /
+ *   endnote, the routed editor is the story editor.
+ *
+ * The live path uses only `hostEditor.presentationEditor.getSelectionRects()`,
+ * which routes through its internal `getActiveEditor()` and works on
+ * every surface.
  */
-export function getSelectionRects(editor: Editor | null, capture?: SelectionCapture | null): ViewportRect[] {
-  const presentation = editor?.presentationEditor;
+export function getSelectionRects(
+  hostEditor: Editor | null,
+  routedEditor: Editor | null,
+  capture?: SelectionCapture | null,
+): ViewportRect[] {
+  const presentation = hostEditor?.presentationEditor;
   if (!presentation) return [];
 
   if (capture) {
-    if (!captureIsBodyOnly(capture)) return [];
-    return getCapturedSelectionRects(editor!, capture);
+    return getCapturedSelectionRects(hostEditor!, routedEditor ?? hostEditor!, capture);
   }
 
   if (typeof presentation.getSelectionRects !== 'function') return [];
@@ -76,11 +64,12 @@ export function getSelectionRects(editor: Editor | null, capture?: SelectionCapt
  * `null` when the selection produces no painted rects.
  */
 export function getSelectionAnchorRect(
-  editor: Editor | null,
+  hostEditor: Editor | null,
+  routedEditor: Editor | null,
   options?: SelectionAnchorRectOptions,
   capture?: SelectionCapture | null,
 ): ViewportRect | null {
-  const rects = getSelectionRects(editor, capture);
+  const rects = getSelectionRects(hostEditor, routedEditor, capture);
   if (rects.length === 0) return null;
 
   const placement = options?.placement ?? 'start';
@@ -89,8 +78,12 @@ export function getSelectionAnchorRect(
   return rects[0]!;
 }
 
-function getCapturedSelectionRects(editor: Editor, capture: SelectionCapture): ViewportRect[] {
-  const presentation = editor.presentationEditor;
+function getCapturedSelectionRects(
+  hostEditor: Editor,
+  routedEditor: Editor,
+  capture: SelectionCapture,
+): ViewportRect[] {
+  const presentation = hostEditor.presentationEditor;
   if (!presentation || typeof presentation.getRangeRects !== 'function') return [];
 
   const segments = capture.target?.segments;
@@ -102,15 +95,22 @@ function getCapturedSelectionRects(editor: Editor, capture: SelectionCapture): V
   const first = segments[0]!;
   const last = segments[segments.length - 1]!;
 
+  // Resolve block ids against the routed editor so captures taken in
+  // header / footer / footnote / endnote stories still resolve while
+  // the user remains in that story (the routed editor is the one whose
+  // PM document those block ids belong to). When focus has moved
+  // elsewhere by call time, the routed editor falls back to the body,
+  // and a non-body capture's block ids won't resolve there — the
+  // function returns [] gracefully.
   let fromResolved: { from: number; to: number } | null = null;
   let toResolved: { from: number; to: number } | null = null;
   try {
-    fromResolved = resolveTextTarget(editor, {
+    fromResolved = resolveTextTarget(routedEditor, {
       kind: 'text',
       blockId: first.blockId,
       range: first.range,
     });
-    toResolved = resolveTextTarget(editor, {
+    toResolved = resolveTextTarget(routedEditor, {
       kind: 'text',
       blockId: last.blockId,
       range: last.range,

packages/super-editor/src/ui/types.ts

@@ -799,14 +799,15 @@ export interface SelectionHandle {
    * footer, footnote, endnote — because `PresentationEditor` routes
    * selection-rect lookups through its currently active editor.
    *
-   * The captured path is body-only today: captures whose target lives
-   * in a non-body story return `[]`. Story-aware rect resolution for
-   * captures requires a `getRangeRectsForStory(from, to, story)`
-   * primitive on PresentationEditor that doesn't yet exist; until that
-   * lands, consumers building floating UI on header / footer / note
-   * surfaces should query rects from the live selection (no capture)
-   * before focus moves elsewhere. Same posture as
-   * `ui.viewport.scrollIntoView` for text-anchored targets.
+   * The captured path resolves block ids against the currently routed
+   * editor, so captures taken in a non-body story still produce the
+   * right rects while the user remains in that story (the common case
+   * for a bubble menu or composer that opens a sidebar). When focus
+   * has moved to a different story (or the body) by call time, the
+   * captured block ids no longer resolve and the call returns `[]`
+   * rather than rects from the wrong surface — fully cross-surface
+   * captured rects need a story-keyed lookup that doesn't yet exist
+   * publicly on `PresentationEditor`.
    */
   getRects(capture?: SelectionCapture | null): ViewportRect[];
   /**