packages/docs/src/view/peer-cursor.ts (1)

161-165: ⚠️ Potential issue | 🟠 Major

Make nested cursor Y relative to the outer row before fragment lookup.

yOffsetInTable includes the top-level table’s rowYOffsets[rowIndex], but findSplitFragment() compares against row-local rowSplitOffset/rowSplitHeight. Nested cursors in any outer row after row 0 can resolve to the wrong fragment and render too low.

🐛 Proposed fix

         const outerRowIndex = nestingPath[0].rowIndex;
-        const cursorInRow = yOffsetInTable + targetLayout.runLineY;
+        const outerRowTop = lb.layoutTable.rowYOffsets[outerRowIndex] ?? 0;
+        const cursorInRow = yOffsetInTable + targetLayout.runLineY - outerRowTop;

               }
               if (outerCellData.blocks[bIdx]?.id === nextTableId) {
-                lineEndInRow = yOffsetInTable + outerCell.lines[li].height;
+                const outerPadding = outerCellData.style?.padding ?? 4;
+                const outerLineTop =
+                  (lb.layoutTable.rowYOffsets[outerSeg.rowIndex] ?? 0) +
+                  outerPadding +
+                  outerCell.lines[li].y;
+                lineEndInRow = outerLineTop + outerCell.lines[li].height - outerRowTop;
                 break;
               }

Also applies to: 270-306

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@packages/docs/src/view/peer-cursor.ts` around lines 161 - 165, yOffsetInTable
includes the outer table’s tl.rowYOffsets[rowIndex], causing nested cursors to
use absolute table Y when calling findSplitFragment(); compute a row-local Y
before fragment lookup by subtracting tl.rowYOffsets[rowIndex] (e.g. let
yOffsetInRow = yOffsetInTable - tl.rowYOffsets[rowIndex]) and pass that
row-local value to findSplitFragment()/any comparisons against
rowSplitOffset/rowSplitHeight; apply the same fix in the other nested-cursor
fragment-lookup block around the 270-306 region where the same pattern occurs.

packages/docs/src/view/image-selection-overlay.ts (1)

359-365: ⚠️ Potential issue | 🟠 Major

Filter nested-table image rects by the active split fragment.

Direct image runs are skipped when outside [rowSplitOffset, rowSplitOffset + rowSplitHeight), but nested tables are always traversed. In a split outer row, this emits every nested image for every fragment and can overwrite the image’s map entry with coordinates from the wrong page fragment.

Thread the visible fragment window into collectNestedTableImageRects() or skip recursion when the nested-table line is outside the fragment.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@packages/docs/src/view/image-selection-overlay.ts` around lines 359 - 365,
The nested-table traversal ignores the active split fragment, causing nested
image rects from other fragments to be emitted; update the call site in the
block that checks line.nestedTable and innerBlock to pass the current visible
fragment window (rowSplitOffset and rowSplitHeight or equivalent bounds) into
collectNestedTableImageRects, and modify collectNestedTableImageRects to accept
these bounds and filter emitted rects (or skip recursion) when the nested table
line falls outside [rowSplitOffset, rowSplitOffset + rowSplitHeight). Use the
symbols collectNestedTableImageRects, line.nestedTable, innerBlock.tableData,
rowSplitOffset and rowSplitHeight to locate and update both the caller and the
callee so nested images are only collected for the active fragment.

packages/docs/src/view/text-editor.ts (1)

2661-2692: ⚠️ Potential issue | 🟠 Major

Handle full-document deletion before the same-block branch.

For a document containing only a table block, startBlockIdx === endBlockIdx, so Cmd+A Delete takes the same-block deleteText(..., 0) path and leaves the table shell. Move the full-selection replacement check above the same-block branch.

Suggested restructuring

     const { start, end } = normalized;
     const startBlockIdx = this.doc.getBlockIndex(start.blockId);
     const endBlockIdx = this.doc.getBlockIndex(end.blockId);
+    const blocks = this.doc.document.blocks;
+    const lastBlock = this.doc.getBlock(end.blockId);
+    const isFullSelection = startBlockIdx === 0
+      && endBlockIdx === blocks.length - 1
+      && start.offset === 0
+      && end.offset === getBlockTextLength(lastBlock);
+
+    if (isFullSelection) {
+      const emptyBlock = createBlock();
+      this.doc.insertBlockAt(0, emptyBlock);
+      const remaining = this.doc.document.blocks.length;
+      for (let i = remaining - 1; i > 0; i--) {
+        this.doc.deleteBlockByIndex(i);
+      }
+      this.cursor.moveTo({ blockId: emptyBlock.id, offset: 0 });
+      this.selection.setRange(null);
+      this.requestRender();
+      return true;
+    }

     if (startBlockIdx === endBlockIdx) {
       // Same block — mark dirty for incremental layout
       this.doc.deleteText(start, end.offset - start.offset);
       this.markDirty(start.blockId);
     } else {
       // Multi-block structural change — force full layout recompute
       this.invalidateLayout();
-
-      // Check if entire document is selected (all blocks from first to last,
-      // at offset 0 and end). Replace with a single empty paragraph.
-      const blocks = this.doc.document.blocks;
       const firstBlock = this.doc.getBlock(start.blockId);
-      const lastBlock = this.doc.getBlock(end.blockId);
-      const isFullSelection = startBlockIdx === 0
-        && endBlockIdx === blocks.length - 1
-        && start.offset === 0
-        && end.offset === getBlockTextLength(lastBlock);
-
-      if (isFullSelection) {
-        // Replace everything with a single empty paragraph
-        const emptyBlock = createBlock();
-        this.doc.insertBlockAt(0, emptyBlock);
-        // Remove all original blocks (now shifted to indices 1..length-1)
-        const remaining = this.doc.document.blocks.length;
-        for (let i = remaining - 1; i > 0; i--) {
-          this.doc.deleteBlockByIndex(i);
-        }
-        this.cursor.moveTo({ blockId: emptyBlock.id, offset: 0 });
-        this.selection.setRange(null);
-        this.requestRender();
-        return true;
-      }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@packages/docs/src/view/text-editor.ts` around lines 2661 - 2692, The
full-document selection replacement must be detected and handled before the
same-block branch so a single-block document (e.g., a lone table) doesn't take
the deleteText path; move the isFullSelection check (using startBlockIdx,
endBlockIdx, start.offset === 0, end.offset === getBlockTextLength(lastBlock),
and blocks.length) to run before the if (startBlockIdx === endBlockIdx) branch,
and when true perform the same replacement steps (createBlock(),
this.doc.insertBlockAt(0, emptyBlock), remove remaining blocks via
this.doc.deleteBlockByIndex, move cursor via this.cursor.moveTo, clear selection
via this.selection.setRange(null), this.requestRender(), and return true) so
full-document deletion consistently replaces the whole document with a single
empty paragraph regardless of block count.

packages/docs/src/view/table-renderer.ts (1)

516-524: ⚠️ Potential issue | 🟠 Major

Draw borders at the fragment bounds when a row is split.

With split clipping, continuation fragments translate the row content upward, but the border code still draws at the original row top/bottom. Those lines are clipped out for middle/continuation fragments, so the page fragment may not get the promised top/bottom borders.

Suggested adjustment

-      const x = tableX + columnXOffsets[c];
-      const y = tableY + rowYOffsets[visibleStart];
+      const x = tableX + columnXOffsets[c];
+      const y = isSplit && r === pageStart
+        ? tableY + rowYOffsets[pageStart] + rowSplitOffset!
+        : tableY + rowYOffsets[visibleStart];
+      const borderHeight = isSplit && r === pageStart
+        ? rowSplitHeight!
+        : visibleHeight;

       // Use theme-aware default border color so borders adapt to dark mode
       const themeBorder: BorderStyle = { ...DEFAULT_BORDER_STYLE, color: Theme.defaultColor };
       drawBorder(ctx, cell.style?.borderTop ?? themeBorder, x, y, x + cellWidth, y);
-      drawBorder(ctx, cell.style?.borderBottom ?? themeBorder, x, y + visibleHeight, x + cellWidth, y + visibleHeight);
-      drawBorder(ctx, cell.style?.borderLeft ?? themeBorder, x, y, x, y + visibleHeight);
-      drawBorder(ctx, cell.style?.borderRight ?? themeBorder, x + cellWidth, y, x + cellWidth, y + visibleHeight);
+      drawBorder(ctx, cell.style?.borderBottom ?? themeBorder, x, y + borderHeight, x + cellWidth, y + borderHeight);
+      drawBorder(ctx, cell.style?.borderLeft ?? themeBorder, x, y, x, y + borderHeight);
+      drawBorder(ctx, cell.style?.borderRight ?? themeBorder, x + cellWidth, y, x + cellWidth, y + borderHeight);

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@packages/docs/src/view/table-renderer.ts` around lines 516 - 524, Borders are
being drawn at the original row bounds so when rows are split across fragments
the continuation fragments miss the top/bottom borders; update the border draw
calls to use the fragment-adjusted vertical coordinates instead of the original
row top/bottom. Specifically, compute the fragment-local top (e.g., fragmentTop
= tableY + rowYOffsets[visibleStart] + fragmentTranslationY or use the already
computed y for the fragment) and call drawBorder with that fragmentTop and
fragmentTop + visibleHeight (using symbols tableX, columnXOffsets[c], cellWidth,
visibleStart, visibleHeight, and drawBorder) so borders render at the fragment
bounds for split rows.

packages/docs/src/view/selection.ts (1)

378-386: ⚠️ Potential issue | 🟠 Major

Make nested cell selection use the clicked split fragment too.

The isNested branch still uses findPageLine(...), which returns the first outer-row fragment. For a nested table inside a split outer row, selection rects for continuation-page content can be rendered on the first fragment instead of the fragment containing nestedYOff + runLineY.

Suggested direction

       if (isNested) {
         const outerRow = resolved.outerRowIndex;
-        const found = findPageLine(paginatedLayout, blockIndex, outerRow);
-        if (!found) return undefined;
-        return found.pageY + found.pageLine.y + nestedYOff
-          + tl.rowYOffsets[ownerRow]
-          + (runLineY - tl.rowYOffsets[ownerRow]);
+        const lineInOuterRow = nestedYOff + runLineY;
+        let bestResult: number | undefined;
+        for (const page of paginatedLayout.pages) {
+          const pageY = getPageYOffset(paginatedLayout, page.pageIndex);
+          for (const pl of page.lines) {
+            if (pl.blockIndex !== blockIndex || pl.lineIndex !== outerRow) continue;
+            const splitOffset = pl.rowSplitOffset ?? 0;
+            const visibleHeight = pl.rowSplitHeight ?? pl.line.height;
+            const absY = pageY + pl.y + lineInOuterRow - splitOffset;
+            if (
+              pl.rowSplitHeight === undefined ||
+              (lineInOuterRow >= splitOffset && lineInOuterRow < splitOffset + visibleHeight)
+            ) {
+              return absY;
+            }
+            bestResult = absY;
+          }
+        }
+        return bestResult;
       }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@packages/docs/src/view/selection.ts` around lines 378 - 386, The isNested
branch in resolveLineAbsoluteY currently uses findPageLine(blockIndex, outerRow)
which returns the first outer-row fragment and causes continuation-page content
to be placed on the wrong fragment; change the logic in resolveLineAbsoluteY to
compute the target nested Y (const targetNestedY = nestedYOff + runLineY) and
search the paginatedLayout for the outer-row fragment whose pageLine vertical
span contains that target (i.e. fragment.pageLine.y <= targetNestedY <
fragment.pageLine.y + fragment.pageLine.height or equivalent), then use that
fragment's pageY and pageLine.y when computing the absolute Y instead of the
first found fragment; refer to symbols resolveLineAbsoluteY, isNested,
resolved.outerRowIndex, nestedYOff, runLineY, paginatedLayout, blockIndex and
replace the single findPageLine call with a search that selects the fragment
containing targetNestedY.