fix: handle document-root selections (AllSelection, NodeSelection) in insertTable

When the selection is at depth 0 (e.g. Ctrl+A or a selected top-level
block like documentSection), $from.end() + 1 overflowed past
doc.content.size, causing a RangeError in insertTopLevelTableWithSeparators.

Guard on $from.depth === 0 and replace the selected range directly so
the table is inserted correctly with a trailing separator paragraph and
the cursor lands in the first cell.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: luccas-harbour

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

@@ -188,7 +188,7 @@ import {
 } from '../table-cell/helpers/legacyBorderMigration.js';
 import { isInTable } from '@helpers/isInTable.js';
 import { findParentNode } from '@helpers/findParentNode.js';
-import { TextSelection, Plugin, PluginKey } from 'prosemirror-state';
+import { NodeSelection, TextSelection, Plugin, PluginKey } from 'prosemirror-state';
 import { isCellSelection } from './tableHelpers/isCellSelection.js';
 import {
   addColumnBefore as originalAddColumnBefore,
@@ -733,23 +733,35 @@ export const Table = Node.create({
           const node = createTable(editor.schema, rows, cols, withHeaderRow, null, widths, tableAttrs);
 
           if (dispatch) {
-            let offset = tr.selection.$from.end() + 1;
+            let offset;
             let replaceRange = undefined;
-            const paragraphDepth =
-              tr.selection.$from.parent?.type?.name === 'run' ? tr.selection.$from.depth - 1 : tr.selection.$from.depth;
-            const paragraph = tr.selection.$from.node(paragraphDepth);
-            const isTopLevelParagraph = paragraphDepth === 1;
-            const isEmptyParagraph = paragraph.type.name === 'paragraph' && paragraph.textContent === '';
-
-            if (isTopLevelParagraph && isEmptyParagraph) {
-              offset = tr.selection.$from.before(paragraphDepth);
-              replaceRange = {
-                from: tr.selection.$from.before(paragraphDepth),
-                to: tr.selection.$from.after(paragraphDepth),
-              };
-            } else if (tr.selection.$from.parent?.type?.name === 'run') {
-              // If in a run, insert after the parent paragraph.
-              offset = tr.selection.$from.after(paragraphDepth);
+
+            if (tr.selection.$from.depth === 0) {
+              // Selection is at the document root (e.g. AllSelection via Ctrl+A,
+              // or NodeSelection on a top-level block). Replace the selected
+              // range with the new table.
+              offset = tr.selection.from;
+              replaceRange = { from: tr.selection.from, to: tr.selection.to };
+            } else {
+              offset = tr.selection.$from.end() + 1;
+              const paragraphDepth =
+                tr.selection.$from.parent?.type?.name === 'run'
+                  ? tr.selection.$from.depth - 1
+                  : tr.selection.$from.depth;
+              const paragraph = tr.selection.$from.node(paragraphDepth);
+              const isTopLevelParagraph = paragraphDepth === 1;
+              const isEmptyParagraph = paragraph.type.name === 'paragraph' && paragraph.textContent === '';
+
+              if (isTopLevelParagraph && isEmptyParagraph) {
+                offset = tr.selection.$from.before(paragraphDepth);
+                replaceRange = {
+                  from: tr.selection.$from.before(paragraphDepth),
+                  to: tr.selection.$from.after(paragraphDepth),
+                };
+              } else if (tr.selection.$from.parent?.type?.name === 'run') {
+                // If in a run, insert after the parent paragraph.
+                offset = tr.selection.$from.after(paragraphDepth);
+              }
             }
 
             const { inserted } = insertTopLevelTableWithSeparators(tr, state.doc, offset, node, replaceRange);

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

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeAll, beforeEach, afterEach } from 'vitest';
-import { EditorState, TextSelection } from 'prosemirror-state';
+import { AllSelection, EditorState, NodeSelection, TextSelection } from 'prosemirror-state';
 import { CellSelection, TableMap } from 'prosemirror-tables';
 import { loadTestDataForEditorTests, initTestEditor } from '@tests/helpers/helpers.js';
 import { createTable } from './tableHelpers/createTable.js';
@@ -1267,6 +1267,77 @@ describe('Table commands', async () => {
       expect(editor.state.doc.child(1).type.name).toBe('paragraph');
       expect(editor.state.doc.childCount).toBe(2);
     });
+
+    it('does not throw when insertTable is called with a NodeSelection on a top-level block', async () => {
+      const { docx, media, mediaFiles, fonts } = cachedBlankDoc;
+      ({ editor } = initTestEditor({ content: docx, media, mediaFiles, fonts }));
+
+      // Insert a documentSection (atom: true, group: 'block') to get a
+      // selectable top-level block node. When selected as a NodeSelection,
+      // $from.depth is 0 and $from.end() returns doc.content.size, which
+      // previously caused insertTable to compute an out-of-range offset.
+      const { schema } = editor.state;
+      const sectionNode = schema.nodes.documentSection.create(null, [schema.nodes.paragraph.create()]);
+      const { tr } = editor.state;
+      const insertPos = tr.selection.$from.before(1);
+      tr.insert(insertPos, sectionNode);
+      tr.setSelection(NodeSelection.create(tr.doc, insertPos));
+      editor.view.dispatch(tr);
+
+      expect(editor.state.selection).toBeInstanceOf(NodeSelection);
+      expect(editor.state.selection.$from.depth).toBe(0);
+
+      // Inserting a table while a top-level node is selected should not throw
+      expect(() => editor.commands.insertTable({ rows: 2, cols: 2 })).not.toThrow();
+
+      // Verify a table was actually inserted
+      const tablePos = findTablePos(editor.state.doc);
+      expect(tablePos).not.toBeNull();
+
+      // Verify the cursor is inside the first table cell
+      const table = editor.state.doc.nodeAt(tablePos);
+      const map = TableMap.get(table);
+      const firstCellTextPos = tablePos + 1 + map.map[0] + 2;
+
+      const { $from } = editor.state.selection;
+      expect(editor.state.selection.from).toBe(firstCellTextPos);
+      expect($from.parent.type.name).toBe('paragraph');
+      expect($from.node($from.depth - 1).type.spec.tableRole).toBe('cell');
+    });
+
+    it('places cursor in first cell and adds trailing paragraph when inserting table with AllSelection', async () => {
+      const { docx, media, mediaFiles, fonts } = cachedBlankDoc;
+      ({ editor } = initTestEditor({ content: docx, media, mediaFiles, fonts }));
+
+      // Type some text so the paragraph is non-empty (simulates a real document)
+      editor.commands.insertContent('This is a test');
+
+      // Select all content (Ctrl+A equivalent)
+      editor.view.dispatch(editor.state.tr.setSelection(new AllSelection(editor.state.doc)));
+      expect(editor.state.selection).toBeInstanceOf(AllSelection);
+
+      // Insert a table while everything is selected
+      editor.commands.insertTable({ rows: 2, cols: 2 });
+
+      // The table should be followed by a trailing separator paragraph
+      const doc = editor.state.doc;
+      const tablePos = findTablePos(doc);
+      expect(tablePos).not.toBeNull();
+      const table = doc.nodeAt(tablePos);
+      const tableEndPos = tablePos + table.nodeSize;
+      const $afterTable = doc.resolve(tableEndPos);
+      const nodeAfterTable = $afterTable.nodeAfter;
+      expect(nodeAfterTable?.type.name).toBe('paragraph');
+
+      // The cursor should be in the first table cell, not the last
+      const map = TableMap.get(table);
+      const firstCellTextPos = tablePos + 1 + map.map[0] + 2;
+
+      const { $from } = editor.state.selection;
+      expect(editor.state.selection.from).toBe(firstCellTextPos);
+      expect($from.parent.type.name).toBe('paragraph');
+      expect($from.node($from.depth - 1).type.spec.tableRole).toBe('cell');
+    });
   });
 
   describe('normalizeNewTableAttrs tblLook (SD-2086)', async () => {