fix: skip inline atom markers when detecting table boundary for arrow key navigation

Paragraphs in imported documents can contain invisible inline markers
(bookmarkStart, bookmarkEnd, permEnd, commentRangeEnd, etc.) adjacent
to runs. The boundary detection functions treated these as meaningful
content, preventing ArrowRight/ArrowLeft from exiting or entering the
table when the cursor was at the edge of a run followed or preceded by
such markers.

Replace the strict last-child/first-child index check with
allInlineMarkersBetween, which skips over inline non-run nodes that
carry no text content.

Author: luccas-harbour

packages/super-editor/src/extensions/table/tableHelpers/tableBoundaryNavigation.js

@@ -39,13 +39,39 @@ function findParagraphDepth($pos) {
   return findAncestorDepth($pos, (node) => node.type.name === 'paragraph');
 }
 
+/**
+ * Returns true when every sibling of the paragraph between `fromIndex`
+ * (inclusive) and `toIndex` (exclusive) is an invisible inline marker
+ * (e.g. bookmarkStart, bookmarkEnd, permEnd, commentRangeEnd). These are
+ * zero-width nodes the cursor should not stop at, so they should not
+ * prevent boundary detection.
+ *
+ * A node is considered an invisible marker when it is inline, not a run,
+ * and carries no text content.
+ *
+ * @param {import('prosemirror-model').Node} paragraph
+ * @param {number} fromIndex
+ * @param {number} toIndex
+ * @returns {boolean}
+ */
+function allInlineMarkersBetween(paragraph, fromIndex, toIndex) {
+  for (let i = fromIndex; i < toIndex; i += 1) {
+    const child = paragraph.child(i);
+    if (child.type.name === 'run') return false;
+    if (!child.isInline) return false;
+    if (child.textContent !== '') return false;
+  }
+  return true;
+}
+
 /**
  * Returns true when the caret should be treated as being at the effective end
  * of the paragraph for horizontal navigation purposes.
  *
  * This is run-aware: the end of the final run in the paragraph counts as the
  * end of the text block even when the selection has not advanced to the raw
- * paragraph boundary position yet.
+ * paragraph boundary position yet. Trailing inline atoms (bookmarks,
+ * permission markers, etc.) are ignored.
  *
  * @param {import('prosemirror-model').ResolvedPos} $head
  * @returns {boolean}
@@ -63,13 +89,16 @@ export function isAtEffectiveParagraphEnd($head) {
   if (runDepth < 0) return false;
   if ($head.pos !== $head.end(runDepth)) return false;
 
-  return $head.index(paragraphDepth) === paragraph.childCount - 1;
+  const runIndex = $head.index(paragraphDepth);
+  return allInlineMarkersBetween(paragraph, runIndex + 1, paragraph.childCount);
 }
 
 /**
  * Returns true when the caret should be treated as being at the effective start
  * of the paragraph for horizontal navigation purposes.
  *
+ * Leading inline atoms (bookmarks, permission markers, etc.) are ignored.
+ *
  * @param {import('prosemirror-model').ResolvedPos} $head
  * @returns {boolean}
  */
@@ -86,7 +115,8 @@ export function isAtEffectiveParagraphStart($head) {
   if (runDepth < 0) return false;
   if ($head.pos !== $head.start(runDepth)) return false;
 
-  return $head.index(paragraphDepth) === 0;
+  const runIndex = $head.index(paragraphDepth);
+  return allInlineMarkersBetween(paragraph, 0, runIndex);
 }
 
 /**

packages/super-editor/src/extensions/table/tableHelpers/tableBoundaryNavigation.test.js

@@ -108,6 +108,70 @@ const DOC_WITH_PROTECTED_TRAILING_PARAGRAPH = {
   ],
 };
 
+/**
+ * Same table layout as DOC, but the first cell has a leading bookmarkStart
+ * and the last cell has a trailing bookmarkEnd. This simulates imported
+ * documents where inline atom markers sit at paragraph edges.
+ */
+const DOC_WITH_INLINE_ATOMS = {
+  type: 'doc',
+  content: [
+    {
+      type: 'paragraph',
+      content: [{ type: 'run', content: [{ type: 'text', text: 'Before' }] }],
+    },
+    {
+      type: 'table',
+      attrs: {
+        tableProperties: {},
+        grid: [{ col: 1500 }],
+      },
+      content: [
+        {
+          type: 'tableRow',
+          content: [
+            {
+              type: 'tableCell',
+              attrs: { colspan: 1, rowspan: 1, colwidth: [150] },
+              content: [
+                {
+                  type: 'paragraph',
+                  content: [
+                    { type: 'bookmarkStart', attrs: { id: '0', name: 'bm1' } },
+                    { type: 'run', content: [{ type: 'text', text: 'First' }] },
+                  ],
+                },
+              ],
+            },
+          ],
+        },
+        {
+          type: 'tableRow',
+          content: [
+            {
+              type: 'tableCell',
+              attrs: { colspan: 1, rowspan: 1, colwidth: [150] },
+              content: [
+                {
+                  type: 'paragraph',
+                  content: [
+                    { type: 'run', content: [{ type: 'text', text: 'Last' }] },
+                    { type: 'bookmarkEnd', attrs: { id: '0' } },
+                  ],
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    },
+    {
+      type: 'paragraph',
+      content: [{ type: 'run', content: [{ type: 'text', text: 'After' }] }],
+    },
+  ],
+};
+
 function findTextPos(doc, search) {
   let found = null;
   doc.descendants((node, pos) => {
@@ -281,4 +345,50 @@ describe('tableBoundaryNavigation', () => {
 
     expect(handled).toBe(true);
   });
+
+  describe('inline atom markers at paragraph edges', () => {
+    let atomEditor;
+    let atomDoc;
+
+    beforeEach(() => {
+      ({ editor: atomEditor } = initTestEditor({ loadFromSchema: true, content: DOC_WITH_INLINE_ATOMS }));
+      atomDoc = atomEditor.state.doc;
+    });
+
+    it('treats the end of the last run as paragraph end even with a trailing bookmarkEnd', () => {
+      const lastPos = findTextPos(atomDoc, 'Last');
+      const endOfLast = lastPos + 'Last'.length;
+      const state = atomEditor.state.apply(atomEditor.state.tr.setSelection(TextSelection.create(atomDoc, endOfLast)));
+
+      expect(isAtEffectiveParagraphEnd(state.selection.$head)).toBe(true);
+    });
+
+    it('treats the start of the first run as paragraph start even with a leading bookmarkStart', () => {
+      const firstPos = findTextPos(atomDoc, 'First');
+      const state = atomEditor.state.apply(atomEditor.state.tr.setSelection(TextSelection.create(atomDoc, firstPos)));
+
+      expect(isAtEffectiveParagraphStart(state.selection.$head)).toBe(true);
+    });
+
+    it('exits the table rightward from the last cell despite a trailing bookmarkEnd', () => {
+      const lastPos = findTextPos(atomDoc, 'Last');
+      const endOfLast = lastPos + 'Last'.length;
+      const afterPos = findTextPos(atomDoc, 'After');
+      const state = atomEditor.state.apply(atomEditor.state.tr.setSelection(TextSelection.create(atomDoc, endOfLast)));
+
+      const nextSelection = getTableBoundaryExitSelection(state, 1);
+      expect(nextSelection).not.toBeNull();
+      expect(nextSelection.from).toBe(afterPos);
+    });
+
+    it('exits the table leftward from the first cell despite a leading bookmarkStart', () => {
+      const firstPos = findTextPos(atomDoc, 'First');
+      const beforeEnd = findTextPos(atomDoc, 'Before') + 'Before'.length;
+      const state = atomEditor.state.apply(atomEditor.state.tr.setSelection(TextSelection.create(atomDoc, firstPos)));
+
+      const nextSelection = getTableBoundaryExitSelection(state, -1);
+      expect(nextSelection).not.toBeNull();
+      expect(nextSelection.from).toBe(beforeEnd);
+    });
+  });
 });