diff --git a/CHANGELOG.md b/CHANGELOG.md
index 96d028a..254a747 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,18 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+### Added
+
+- Table cells get Copy, Cut and Paste buttons in the table toolbar — the cell clipboard finally works on mobile too, where there is no Cmd+C. The buttons also accept a bare caret in a cell (that cell counts as the selection).
+- Duplicate Row and Duplicate Column actions: an exact copy appears right next to the original, header row included.
+- Select a table cell by holding the mouse button on it for a moment (desktop). The old selection circle is gone — dragging across cells selects them like in Notion.
+
+### Fixed
+
+- Pasting copied cells into another table replaces the selected cells' content instead of nesting a whole table inside a cell and breaking the layout. Pasting copied rows adds them as new rows aligned to the target table's columns, and Cut removes fully selected rows outright, Excel-style.
+
 ## [0.12.1] - 2026-10-22
 
 ### Changed
diff --git a/scripts/debug/verify-table-clipboard-android.mjs b/scripts/debug/verify-table-clipboard-android.mjs
new file mode 100644
index 0000000..e09487f
--- /dev/null
+++ b/scripts/debug/verify-table-clipboard-android.mjs
@@ -0,0 +1,108 @@
+// tmp-verify-android.mjs — mobile verification of the table clipboard task
+// on the Android emulator (CDP :9224), obsidian-plugin vault only.
+import { chromium } from 'playwright-core';
+
+const browser = await chromium.connectOverCDP('http://127.0.0.1:9224', { timeout: 10000 });
+const page = browser.contexts().flatMap((c) => c.pages()).find((p) => p.url().startsWith('http://localhost/'));
+if (page == null) throw new Error('Android Obsidian page not found');
+
+const R = {};
+R.vault = await page.evaluate(() => window.app?.vault?.getName?.() ?? null);
+R.plugin = await page.evaluate(() => !!window.app?.plugins?.getPlugin?.('inscriptum'));
+
+// write the test note (two 3-col tables) and open it; unique name per run
+const notePath = `local/table-clipboard-verify-${Date.now()}.note`;
+R.notePath = notePath;
+R.setup = await page.evaluate(async (notePath) => {
+  const mk = (name) => ({
+    type: 'table', attrs: { data: { rowsCount: 3, colsCount: 3 } },
+    content: [
+      { type: 'tableRow', content: [0, 1, 2].map((i) => ({ type: 'tableHeader', content: [{ type: 'paragraph', content: [{ type: 'text', text: name + 'h' + i }] }] })) },
+      { type: 'tableRow', content: [0, 1, 2].map((i) => ({ type: 'tableCell', content: [{ type: 'paragraph', content: [{ type: 'text', text: name + '0' + i }] }] })) },
+      { type: 'tableRow', content: [0, 1, 2].map((i) => ({ type: 'tableCell', content: [{ type: 'paragraph', content: [{ type: 'text', text: name + '1' + i }] }] })) },
+    ],
+  });
+  const doc = {
+    type: 'noteDoc',
+    content: [
+      { type: 'noteTitle', content: [{ type: 'text', text: 'table-clipboard-verify' }] },
+      mk('A'),
+      { type: 'paragraph', content: [{ type: 'text', text: 'between' }] },
+      mk('B'),
+    ],
+  };
+  await app.vault.adapter.write(notePath, JSON.stringify(doc));
+  const file = app.vault.getAbstractFileByPath(notePath);
+  const leaf = app.workspace.getLeaf('tab');
+  await leaf.openFile(file);
+  app.workspace.revealLeaf(leaf);
+  await new Promise((r) => setTimeout(r, 800));
+  const ed = leaf.view?.editor;
+  if (!ed) return { err: 'no editor' };
+  window.__ed = ed;
+  window.__cellPos = (text) => {
+    let p = null;
+    ed.state.doc.descendants((node, pos) => {
+      if (!p && (node.type.name === 'tableCell' || node.type.name === 'tableHeader') && node.textContent === text) p = pos;
+      return !p;
+    });
+    return p;
+  };
+  window.__tableTexts = (idx) => {
+    const out = [];
+    let seen = -1;
+    ed.state.doc.descendants((node) => {
+      if (node.type.name === 'table') { seen += 1; return seen === idx; }
+      if (seen === idx && (node.type.name === 'tableCell' || node.type.name === 'tableHeader')) out.push(node.textContent);
+      return true;
+    });
+    return out;
+  };
+  return { ok: true, platform: { isMobile: /is-mobile/.test(document.body.className) || Boolean(window.Capacitor), ua: navigator.userAgent.slice(0, 60) } };
+}, notePath);
+
+// rect paste: CellSelection over B00..B11 + synthetic paste with a copied 2x2
+R.rectPaste = await page.evaluate(() => {
+  const ed = window.__ed;
+  ed.commands.setCellSelection({ anchorCell: window.__cellPos('B00'), headCell: window.__cellPos('B11') });
+  const html = '<table data-pm-slice="1 1 -2 []"><tbody><tr><td colspan="1" rowspan="1" data-colwidth="50"><p>A00</p></td><td colspan="1" rowspan="1" data-colwidth="50"><p>A01</p></td></tr><tr><td colspan="1" rowspan="1" data-colwidth="50"><p>A10</p></td><td colspan="1" rowspan="1" data-colwidth="50"><p>A11</p></td></tr></tbody></table>';
+  const dt = new DataTransfer();
+  dt.setData('text/html', html);
+  dt.setData('text/plain', 'A00\n\nA01\n\nA10\n\nA11');
+  ed.view.dom.dispatchEvent(new ClipboardEvent('paste', { clipboardData: dt, bubbles: true, cancelable: true }));
+  return window.__tableTexts(1);
+});
+
+// undo
+R.afterUndo = await page.evaluate(() => {
+  window.__ed.commands.undo();
+  return window.__tableTexts(1);
+});
+
+// rows insert at caret
+R.rowsAtCaret = await page.evaluate(() => {
+  const ed = window.__ed;
+  const pos = window.__cellPos('B00');
+  ed.commands.focus(pos + 1);
+  const html = '<table data-pm-slice="1 1 -2 []"><tbody><tr><td colspan="1" rowspan="1" data-colwidth="50"><p>A00</p></td><td colspan="1" rowspan="1" data-colwidth="50"><p>A01</p></td></tr><tr><td colspan="1" rowspan="1" data-colwidth="50"><p>A10</p></td><td colspan="1" rowspan="1" data-colwidth="50"><p>A11</p></td></tr></tbody></table>';
+  const dt = new DataTransfer();
+  dt.setData('text/html', html);
+  ed.view.dom.dispatchEvent(new ClipboardEvent('paste', { clipboardData: dt, bubbles: true, cancelable: true }));
+  return window.__tableTexts(1);
+});
+
+// cleanup: close the leaf, delete this run's note (file closed first)
+R.cleanedUp = await page.evaluate(async (notePath) => {
+  const leaf = app.workspace.getLeavesOfType('note-view').find((l) => l.view?.file?.path === notePath);
+  if (leaf) {
+    try { leaf.detach(); } catch {}
+    await new Promise((r) => setTimeout(r, 300));
+  }
+  const file = app.vault.getAbstractFileByPath(notePath);
+  if (file) {
+    try { await app.vault.delete(file); } catch { return false; }
+  }
+  return true;
+}, notePath);
+await browser.close().catch(() => {});
+console.log(JSON.stringify(R, null, 2));
diff --git a/scripts/debug/verify-table-clipboard.mjs b/scripts/debug/verify-table-clipboard.mjs
new file mode 100644
index 0000000..f13e480
--- /dev/null
+++ b/scripts/debug/verify-table-clipboard.mjs
@@ -0,0 +1,224 @@
+// tmp-verify-desktop.mjs — desktop verification of the table clipboard task
+// (issue table-clipboard) in the live obsidian-plugin dev vault, CDP :9223.
+// Trusted keyboard/mouse via playwright Input; state reads via evaluate.
+import { chromium } from 'playwright-core';
+
+const browser = await chromium.connectOverCDP('http://127.0.0.1:9223', { timeout: 8000 });
+
+const R = {};
+let page = null;
+try {
+  // 0. find the dev-vault window (rule-verify-both-platforms: only the
+  //    obsidian-plugin vault may be touched)
+  const appPages = browser.contexts().flatMap((c) => c.pages()).filter((x) => x.url().startsWith('app://obsidian.md'));
+  for (const p of appPages) {
+    const vault = await p.evaluate(() => window.app?.vault?.getName?.() ?? null);
+    if (vault === 'obsidian-plugin') {
+      page = p;
+      break;
+    }
+  }
+  R.windows = await Promise.all(appPages.map((p) => p.evaluate(() => window.app?.vault?.getName?.() ?? null)));
+  if (page == null) throw new Error('obsidian-plugin vault window not found');
+
+  // The window must be OS-focused: trusted copy/cut keyboard commands are
+  // dropped by Chromium when the web contents have no focus.
+  R.windowFocus = await page.evaluate(() => {
+    const win = window.electron?.remote?.getCurrentWindow?.();
+    if (!win) return 'no electron.remote';
+    win.show();
+    win.focus();
+    return win.getTitle();
+  });
+  await page.waitForTimeout(400);
+
+  // 1. the app was reloaded (app:reload) AFTER the build, so the fresh
+  //    bundle is already live; just confirm the plugin is enabled
+  R.pluginEnabled = await page.evaluate(() => !!app.plugins.getPlugin('inscriptum'));
+
+  // 2. write the test note (two 3-col tables: header + 2 body rows each).
+  //    Unique name per run: a restored workspace tab may hold a stale doc
+  //    for a reused path (the view does not necessarily reload from disk).
+  const notePath = `local/table-clipboard-verify-${Date.now()}.note`;
+  R.notePath = notePath;
+  await page.evaluate(async (notePath) => {
+    const mk = (name) => ({
+      type: 'table', attrs: { data: { rowsCount: 3, colsCount: 3 } },
+      content: [
+        { type: 'tableRow', content: [0, 1, 2].map((i) => ({ type: 'tableHeader', content: [{ type: 'paragraph', content: [{ type: 'text', text: name + 'h' + i }] }] })) },
+        { type: 'tableRow', content: [0, 1, 2].map((i) => ({ type: 'tableCell', content: [{ type: 'paragraph', content: [{ type: 'text', text: name + '0' + i }] }] })) },
+        { type: 'tableRow', content: [0, 1, 2].map((i) => ({ type: 'tableCell', content: [{ type: 'paragraph', content: [{ type: 'text', text: name + '1' + i }] }] })) },
+      ],
+    });
+    const doc = {
+      type: 'noteDoc',
+      content: [
+        { type: 'noteTitle', content: [{ type: 'text', text: 'table-clipboard-verify' }] },
+        mk('A'),
+        { type: 'paragraph', content: [{ type: 'text', text: 'between' }] },
+        mk('B'),
+      ],
+    };
+    await app.vault.adapter.write(notePath, JSON.stringify(doc));
+    const file = app.vault.getAbstractFileByPath(notePath);
+    // close the tabs my earlier runs left behind, keep exactly one leaf
+    const existing = app.workspace.getLeavesOfType('note-view')
+      .filter((l) => (l.view?.file?.path ?? '').startsWith('local/table-clipboard-verify'));
+    const leaf = app.workspace.getLeaf('tab');
+    await leaf.openFile(file);
+    for (const l of existing) {
+      if (l !== leaf) {
+        try { l.detach(); } catch {}
+      }
+    }
+    app.workspace.revealLeaf(leaf);
+    window.__ed = leaf.view.editor ?? null;
+  }, notePath);
+  await page.waitForTimeout(1200);
+  R.editorUp = await page.evaluate(() => !!window.__ed);
+
+  // helpers evaluated in-page (re-resolve the editor: it is created
+  // asynchronously after the leaf mounts)
+  await page.evaluate((notePath) => {
+    const leaf = app.workspace.getLeavesOfType('note-view').find((l) => l.view?.file?.path === notePath);
+    window.__ed = leaf.view.editor;
+    window.__cellPos = (text) => {
+      let p = null;
+      window.__ed.state.doc.descendants((node, pos) => {
+        if (!p && (node.type.name === 'tableCell' || node.type.name === 'tableHeader') && node.textContent === text) p = pos;
+        return !p;
+      });
+      return p;
+    };
+    window.__tableTexts = (idx) => {
+      const out = [];
+      let seen = -1;
+      window.__ed.state.doc.descendants((node) => {
+        if (node.type.name === 'table') { seen += 1; return seen === idx; }
+        if (seen === idx && (node.type.name === 'tableCell' || node.type.name === 'tableHeader')) out.push(node.textContent);
+        return true;
+      });
+      return out;
+    };
+    window.__selRect = (a, b) => {
+      window.__ed.commands.setCellSelection({ anchorCell: window.__cellPos(a), headCell: window.__cellPos(b) });
+      window.__ed.view.focus();
+    };
+    window.__caret = (text) => {
+      const pos = window.__cellPos(text);
+      window.__ed.commands.focus(pos + 1);
+      window.__ed.view.focus();
+    };
+  }, notePath);
+
+  // focus the web contents with a trusted click into the editor, then keep
+  // PM focus via the API (native copy/cut need OS-focused web contents)
+  const edRect = await page.evaluate(() => {
+    const r = window.__ed.view.dom.getBoundingClientRect();
+    return { x: r.x + Math.min(80, r.width / 2), y: r.y + 8 };
+  });
+  if (edRect.width === 0) throw new Error('editor has no layout');
+  await page.mouse.click(edRect.x, edRect.y);
+  await page.waitForTimeout(200);
+  R.focusAfterClick = await page.evaluate(() => window.__ed.view.hasFocus());
+
+  // 3. rect copy from A00..A11 -> rect paste onto B00..B11
+  await page.evaluate(() => window.__selRect('A00', 'A11'));
+  await page.keyboard.press('Meta+c');
+  await page.waitForTimeout(150);
+  await page.evaluate(() => window.__selRect('B00', 'B11'));
+  await page.keyboard.press('Meta+v');
+  await page.waitForTimeout(250);
+  R.rectPaste = await page.evaluate(() => window.__tableTexts(1));
+
+  // 4. undo once — the paste must roll back in a single step
+  await page.keyboard.press('Meta+z');
+  await page.waitForTimeout(200);
+  R.afterUndo = await page.evaluate(() => window.__tableTexts(1));
+
+  // 5. rows copy (full rows A0+A1) -> caret in B00 -> paste inserts rows
+  await page.evaluate(() => window.__selRect('A00', 'A12'));
+  await page.keyboard.press('Meta+c');
+  await page.waitForTimeout(150);
+  await page.evaluate(() => window.__caret('B00'));
+  R.caretType = await page.evaluate(() => window.__ed.state.selection.constructor.name);
+  await page.keyboard.press('Meta+v');
+  await page.waitForTimeout(250);
+  R.rowsAtCaret = await page.evaluate(() => window.__tableTexts(1));
+  await page.keyboard.press('Meta+z');
+  await page.waitForTimeout(200);
+
+  // 6. Cmd+X on a full body row removes the row
+  await page.evaluate(() => window.__selRect('A00', 'A02'));
+  await page.keyboard.press('Meta+x');
+  await page.waitForTimeout(250);
+  R.cutRow = await page.evaluate(() => window.__tableTexts(0));
+  await page.keyboard.press('Meta+z');
+  await page.waitForTimeout(200);
+
+  // 7. Cmd+X on a partial rect clears contents
+  await page.evaluate(() => window.__selRect('A00', 'A11'));
+  await page.keyboard.press('Meta+x');
+  await page.waitForTimeout(250);
+  R.cutPartial = await page.evaluate(() => window.__tableTexts(0));
+  await page.keyboard.press('Meta+z');
+  await page.waitForTimeout(200);
+
+  // 8. focus after a real circle drag (trusted mouse): caret in A11 -> drag
+  //    the selection circle to B11... wait, drag stays in one table: to B02.
+  await page.evaluate(() => window.__caret('A11'));
+  await page.waitForTimeout(300);
+  const circle = await page.evaluate(() => {
+    const el = window.__ed.view.dom.querySelector('.texto-table__overlay_overlay-circle');
+    if (!el) return null;
+    const r = el.getBoundingClientRect();
+    return { x: r.x + r.width / 2, y: r.y + r.height / 2, cellPos: el.dataset.cellPos };
+  });
+  R.circle = circle;
+  if (circle) {
+    const target = await page.evaluate(() => {
+      const td = [...window.__ed.view.dom.querySelectorAll('td,th')].find((el) => el.textContent === 'A02');
+      const r = td.getBoundingClientRect();
+      return { x: r.x + r.width / 2, y: r.y + r.height / 2 };
+    });
+    await page.mouse.move(circle.x, circle.y);
+    await page.mouse.down();
+    await page.mouse.move(target.x, target.y, { steps: 8 });
+    await page.mouse.up();
+    await page.waitForTimeout(300);
+    R.afterDrag = await page.evaluate(() => {
+      const s = window.__ed.state.selection;
+      return {
+        type: s.constructor.name,
+        anchorCell: s.$anchorCell ? s.$anchorCell.pos : null,
+        headCell: s.$headCell ? s.$headCell.pos : null,
+        hasFocus: window.__ed.view.hasFocus(),
+      };
+    });
+    // 9. trusted Cmd+C right after the drag — the focus fix makes it work
+    await page.keyboard.press('Meta+c');
+    await page.waitForTimeout(150);
+    await page.evaluate(() => window.__selRect('B00', 'B12'));
+    await page.keyboard.press('Meta+v');
+    await page.waitForTimeout(250);
+    R.pasteAfterDragCopy = await page.evaluate(() => window.__tableTexts(1));
+  }
+  // cleanup: close the leaf (file not open anymore), then delete this run's
+  // note and any leftovers of earlier runs (explicit user-style deletes —
+  // never while the file is open in a view, see rule-open-file-safety)
+  await page.evaluate(async (notePath) => {
+    const files = app.vault.getFiles().filter((f) => f.path.startsWith('local/table-clipboard-verify'));
+    for (const f of files) {
+      const leaves = app.workspace.getLeavesOfType('note-view').filter((l) => l.view?.file?.path === f.path);
+      for (const l of leaves) {
+        try { l.detach(); } catch {}
+      }
+      await new Promise((r) => setTimeout(r, 150));
+      try { await app.vault.delete(f); } catch {}
+    }
+  }, notePath);
+  R.cleanedUp = true;
+} finally {
+  await browser.close().catch(() => {});
+}
+console.log(JSON.stringify(R, null, 2));
diff --git a/src/components/bubble-menu-bar/table-bubble-menu-bar.element.tsx b/src/components/bubble-menu-bar/table-bubble-menu-bar.element.tsx
index fff0e31..77d2592 100644
--- a/src/components/bubble-menu-bar/table-bubble-menu-bar.element.tsx
+++ b/src/components/bubble-menu-bar/table-bubble-menu-bar.element.tsx
@@ -20,6 +20,11 @@ import type {
   BorderPen,
   BorderSideName,
 } from "../../texto/extensions/table/helpers/borders";
+import {
+  copyTableSelection,
+  cutTableSelection,
+  pasteFromSystemClipboard,
+} from "../../texto/extensions/table/helpers/cellClipboard";
 import type { BubbleIconName } from "../icons/iconSprite";
 import { bubbleIconNodes } from "./icons.svgnode";
 
@@ -236,6 +241,12 @@ export const TableBubbleMenuElement = litView.element({
       case "colRight":
         e.chain().focus().addColumnAfter().run();
         break;
+      case "dupRow":
+        e.chain().focus().duplicateRow().run();
+        break;
+      case "dupCol":
+        e.chain().focus().duplicateColumn().run();
+        break;
       case "merge":
         e.chain().focus().mergeCells().run();
         break;
@@ -268,6 +279,22 @@ export const TableBubbleMenuElement = litView.element({
       .run();
   };
 
+  /* ── Clipboard actions (issue table-clipboard-buttons): a cell selection
+     or the caret cell (1×1). Paste reads the system clipboard inside the
+     click gesture and feeds it through the editor's paste pipeline. ── */
+  const copyCells = () => {
+    copyTableSelection(props.editor.view);
+  };
+  const cutCells = () => {
+    void cutTableSelection(props.editor.view).catch(() => {});
+  };
+  const pasteCells = () => {
+    void pasteFromSystemClipboard(props.editor.view).catch(() => {});
+  };
+  const canReadClipboard =
+    typeof navigator !== "undefined" &&
+    !!(navigator.clipboard?.read || navigator.clipboard?.readText);
+
   const syncCaret = () => {
     const editor = props.editor;
     if (editor.isDestroyed || !editor.view) return;
@@ -425,6 +452,49 @@ export const TableBubbleMenuElement = litView.element({
             >
               {bubbleIconNodes.colRight()}
             </button>
+            <button
+              class="bb-btn"
+              data-tip="Duplicate row"
+              onmousedown={(e: MouseEvent) => e.preventDefault()}
+              onclick={() => applyTableAction("dupRow")}
+            >
+              {bubbleIconNodes.dupRow()}
+            </button>
+            <button
+              class="bb-btn"
+              data-tip="Duplicate column"
+              onmousedown={(e: MouseEvent) => e.preventDefault()}
+              onclick={() => applyTableAction("dupCol")}
+            >
+              {bubbleIconNodes.dupCol()}
+            </button>
+            <span class="bubble-menu-sep"></span>
+            <button
+              class="bb-btn"
+              data-tip="Copy cells"
+              onmousedown={(e: MouseEvent) => e.preventDefault()}
+              onclick={copyCells}
+            >
+              {bubbleIconNodes.copy()}
+            </button>
+            <button
+              class="bb-btn"
+              data-tip="Cut cells"
+              onmousedown={(e: MouseEvent) => e.preventDefault()}
+              onclick={cutCells}
+            >
+              {bubbleIconNodes.cut()}
+            </button>
+            {canReadClipboard && (
+              <button
+                class="bb-btn"
+                data-tip="Paste cells"
+                onmousedown={(e: MouseEvent) => e.preventDefault()}
+                onclick={pasteCells}
+              >
+                {bubbleIconNodes.paste()}
+              </button>
+            )}
             <span class="bubble-menu-sep"></span>
             <button
               class={cls("bb-btn", !tableState.multiCell && "is-disabled")}
diff --git a/src/components/icons/iconSprite.ts b/src/components/icons/iconSprite.ts
index ff85e93..56edfa8 100644
--- a/src/components/icons/iconSprite.ts
+++ b/src/components/icons/iconSprite.ts
@@ -89,8 +89,16 @@ const BUBBLE_ICON_PATHS: Record<string, string> = {
   split: `<path d="M4 6h16v12h-16z"/><path d="M12 6v12"/><path d="M4 12h16"/>`,
   delRow: `<path d="M4 18v-4a1 1 0 0 1 1 -1h14a1 1 0 0 1 1 1v4a1 1 0 0 1 -1 1h-14a1 1 0 0 1 -1 -1z"/><path d="M9 12h6"/>`,
   delCol: `<path d="M4 6v14a1 1 0 0 0 1 1h14a1 1 0 0 0 1 -1v-14a1 1 0 0 0 -1 -1h-14a1 1 0 0 0 -1 1z"/><path d="M12 9v6"/>`,
+  /* Duplicate row/column: a ghost outline (the original) above/left of the
+     solid copy — "this plus its copy". */
+  dupRow: `<rect x="4" y="4" width="16" height="6" rx="1" opacity="0.4"/><rect x="4" y="13" width="16" height="6" rx="1"/>`,
+  dupCol: `<rect x="4" y="4" width="6" height="16" rx="1" opacity="0.4"/><rect x="13" y="4" width="6" height="16" rx="1"/>`,
   header: `<path d="M3 5a2 2 0 0 1 2 -2h14a2 2 0 0 1 2 2v14a2 2 0 0 1 -2 2h-14a2 2 0 0 1 -2 -2z"/><path d="M3 10h18"/>`,
   delTable: `<path d="M4 7h16"/><path d="M10 11v6"/><path d="M14 11v6"/><path d="M5 7l1 12a2 2 0 0 0 2 2h8a2 2 0 0 0 2 -2l1 -12"/><path d="M9 7v-3h6v3"/>`,
+  /* Clipboard actions of the table bar (copy from the toolbar set). */
+  copy: TOOLBAR_ICON_PATHS.copy,
+  cut: `<circle cx="6" cy="6" r="3"/><path d="M8.12 8.12 12 12"/><path d="M20 4 8.12 15.88"/><circle cx="6" cy="18" r="3"/><path d="M14.8 14.8 20 20"/>`,
+  paste: `<rect x="8" y="2" width="8" height="4" rx="1"/><path d="M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2"/><path d="M12 11v6"/><path d="M9 14h6"/>`,
   /* Paint bucket (Lucide, MIT) — the "cell fill" button of the table panel. */
   paintBucket: `<path d="m19 11-8-8-8.6 8.6a2 2 0 0 0 0 2.8l5.2 5.2c.8.8 2 .8 2.8 0L19 11Z"/><path d="m5 2 5 5"/><path d="M2 13h15"/><path d="M22 20a2 2 0 1 1-4 0c0-1.6 1.7-2.4 2-4 .3 1.6 2 2.4 2 4Z"/>`,
   /* Border-picker schemas: a ghost (dashed, faint) cell grid with the
diff --git a/src/storage/noteStorage.ts b/src/storage/noteStorage.ts
index 0905502..5b18eda 100644
--- a/src/storage/noteStorage.ts
+++ b/src/storage/noteStorage.ts
@@ -2,6 +2,7 @@ import type { DataAdapter, TFile, Vault } from "obsidian";
 import type { JSONContent } from "../texto/core/@types";
 import { ensureTrailingParagraphJSON } from "../texto/extensions/note-doc/trailingParagraph";
 import { ensureCellTrailingParagraphJSON } from "../texto/extensions/table/helpers/cellTrailingParagraph";
+import { normalizeCellColorAttrsJSON } from "../texto/extensions/table/helpers/cellColorAttrs";
 
 export const EMPTY_DOC: JSONContent = {
   type: "noteDoc",
@@ -45,11 +46,13 @@ export function parseNoteDoc(raw: string): JSONContent {
   // prosemirror's nodeFromJSON rejects them ("Empty text nodes are not
   // allowed") and the note would never open. Strip them on read; the next
   // normalized autosave rewrites the file without them.
-  return ensureCellTrailingParagraphJSON(
+  const doc = ensureCellTrailingParagraphJSON(
     ensureTrailingParagraphJSON(
       sanitizeNoteDoc(JSON.parse(raw) as JSONContent),
     ),
   );
+  normalizeCellColorAttrsJSON(doc);
+  return doc;
 }
 
 /** Recursively drop empty text nodes ("text" missing or "") from a parsed
diff --git a/src/storage/um/umNotepad.ts b/src/storage/um/umNotepad.ts
index 35ccbf9..a669f5d 100644
--- a/src/storage/um/umNotepad.ts
+++ b/src/storage/um/umNotepad.ts
@@ -3,6 +3,10 @@ import {
   ensureCellTrailingParagraphJSON,
   hasCellTrailingImage,
 } from "../../texto/extensions/table/helpers/cellTrailingParagraph";
+import {
+  hasCellColorAttrQuirk,
+  normalizeCellColorAttrsJSON,
+} from "../../texto/extensions/table/helpers/cellColorAttrs";
 import {
   assetExtension,
   assetPathForId,
@@ -114,6 +118,15 @@ export class UmNotepad {
       this.dirtyNotes.add(id);
     }
 
+    // Cell color attrs (table-clipboard task): clipboard-parsed cells used
+    // to carry dataColor as an array, which crashed the color rendering on
+    // the next open. Normalize on read, like the trailing repair above.
+    if (hasCellColorAttrQuirk(prepared)) {
+      normalizeCellColorAttrsJSON(prepared);
+      this.data.notes.set(id, prepared);
+      this.dirtyNotes.add(id);
+    }
+
     if (state.family === UM_SCHEMA_TITLE) {
       const normalized = normalizeTitleDoc(prepared);
       if (normalized.changed) {
diff --git a/src/styles/mobile.css b/src/styles/mobile.css
index e6795c5..f535c1c 100644
--- a/src/styles/mobile.css
+++ b/src/styles/mobile.css
@@ -673,16 +673,6 @@
    handle (rendered by the handleCellSelection plugin, see
    src/texto/extensions/table). */
 
-/* Hide the drag-selection circle on mobile: cell selection is done with a
-   long-press anywhere in the cell, so the circle is only clutter (and a
-   touch trap in the cell corner). Its container (.texto-table__overlay_overlay-circle)
-   is display:none'd entirely, so touches pass through to the cell below
-   (long-press selection / resize handle). Desktop keeps the circle drag. */
-.note-view-container.is-mobile .texto-table__overlay_overlay-circle,
-.notepad-view-container.is-mobile .texto-table__overlay_overlay-circle {
-  display: none;
-}
-
 /* The resize handle is a pure overlay: it is absolutely positioned over the
    column border and must not affect the table's own width. The wrapper gets a
    right padding on mobile (see below) so the handle of the last column fits
@@ -735,15 +725,6 @@
   touch-action: none;
 }
 
-/* The selection frame stays above the column resize handle.
-   NOTE: z-index is set on the overlay, not on the circle itself — the circle
-   lives inside the overlay's stacking context, so its own z-index cannot
-   compete with the handle outside of it. */
-.note-view-container.is-mobile .texto-table__overlay,
-.notepad-view-container.is-mobile .texto-table__overlay {
-  z-index: 4;
-}
-
 .note-view-container.is-mobile .texto-table__resize-handle::before,
 .notepad-view-container.is-mobile .texto-table__resize-handle::before {
   content: "";
diff --git a/src/texto/extensions/table/commands.duplicate.test.ts b/src/texto/extensions/table/commands.duplicate.test.ts
new file mode 100644
index 0000000..2f79af1
--- /dev/null
+++ b/src/texto/extensions/table/commands.duplicate.test.ts
@@ -0,0 +1,155 @@
+import type { Transaction } from "prosemirror-state";
+import { EditorState, TextSelection } from "prosemirror-state";
+import { describe, expect, it } from "vitest";
+
+import { buildSchema } from "../../../../tests/helpers/buildSchema";
+
+import { TableMap } from "prosemirror-tables";
+
+import { addCommands } from "./commands";
+
+const schema = buildSchema();
+
+const cell = (t: string) => ({ type: "tableCell", content: [{ type: "paragraph", content: [{ type: "text", text: t }] }] });
+const head = (t: string) => ({ type: "tableHeader", content: [{ type: "paragraph", content: [{ type: 'text', text: t }] }] });
+const row = (cells: ReturnType<typeof cell>[]) => ({ type: "tableRow", content: cells });
+const table = (rows: ReturnType<typeof row>[]) => ({
+  type: "table",
+  attrs: { data: { rowsCount: rows.length, colsCount: rows[0]?.content.length ?? 0 } },
+  content: rows,
+});
+const makeDoc = (tables: ReturnType<typeof table>[]) => ({
+  type: "noteDoc",
+  content: [{ type: "noteTitle", content: [{ type: 'text', text: "T" }] }, ...tables],
+});
+
+function cellPositions(node: ReturnType<typeof schema.nodeFromJSON>, tableIndex = 0): number[] {
+  const positions: number[] = [];
+  let seen = -1;
+  node.descendants((n, p) => {
+    if (n.type.name === "table") {
+      seen += 1;
+      return seen === tableIndex;
+    }
+    if (seen === tableIndex && (n.type.name === "tableCell" || n.type.name === "tableHeader")) {
+      positions.push(p);
+    }
+    return true;
+  });
+  return positions;
+}
+
+function cellTexts(state: EditorState, tableIndex = 0): string[] {
+  const out: string[] = [];
+  let seen = -1;
+  state.doc.descendants((n) => {
+    if (n.type.name === "table") {
+      seen += 1;
+      return seen === tableIndex;
+    }
+    if (seen === tableIndex && (n.type.name === "tableCell" || n.type.name === "tableHeader")) {
+      out.push(n.textContent);
+    }
+    return true;
+  });
+  return out;
+}
+
+/** Run a table command against a caret placed inside the cell at
+ *  `caretCell` (index within the table's cells). */
+function runCommand(
+  document: ReturnType<typeof makeDoc>,
+  name: "duplicateRow" | "duplicateColumn",
+  caretCell: number,
+): { ok: boolean; next: EditorState; positions: number[] } {
+  const node = schema.nodeFromJSON(document);
+  const positions = cellPositions(node);
+  const withCaret = EditorState.create({
+    doc: node,
+    selection: TextSelection.create(node, positions[caretCell] + 1),
+  });
+  const commands = addCommands.bind({} as never)();
+  const dispatched: Transaction[] = [];
+  // The addCommands methods are curried: (options) => Command, so the bare
+  // call materializes the Command that then takes { state, dispatch }.
+  const command = (commands[name] as unknown as (opts?: never) => (p: {
+    state: EditorState;
+    dispatch: (t: Transaction) => void;
+  }) => boolean)(undefined);
+  const ok = command({
+    state: withCaret,
+    dispatch: (tr: Transaction) => {
+      dispatched.push(tr);
+    },
+  });
+  expect(dispatched).toHaveLength(ok ? 1 : 0);
+  return {
+    ok,
+    next: dispatched.length ? withCaret.apply(dispatched[0]) : withCaret,
+    positions,
+  };
+}
+
+describe("duplicateRow", () => {
+  it("clones the caret row right below it", () => {
+    const { ok, next } = runCommand(
+      makeDoc([table([row([cell("r0a"), cell("r0b")]), row([cell("r1a"), cell("r1b")])])]),
+      "duplicateRow",
+      0,
+    );
+    expect(ok).toBe(true);
+    expect(cellTexts(next)).toEqual(["r0a", "r0b", "r0a", "r0b", "r1a", "r1b"]);
+  });
+
+  it("clones a rowspan cell unmerged into the copy", () => {
+    // Col 0 merged across rows 0-1; duplicating row 0 clones "M" as a
+    // standalone cell, the original merge keeps spanning rows 0-1.
+    const merged = {
+      type: "tableCell",
+      attrs: { rowspan: 2 },
+      content: [{ type: "paragraph", content: [{ type: "text", text: "M" }] }],
+    };
+    const { next } = runCommand(
+      makeDoc([table([
+        row([merged, cell("c01"), cell("c02")]),
+        row([cell("c11"), cell("c12")]),
+      ])]),
+      "duplicateRow",
+      1,
+    );
+    const texts = cellTexts(next);
+    // The merge crossing the insertion line extends over the copy row; the
+    // clone row fills only the free columns (the covered column has no cell
+    // in it — the extended M spans it).
+    expect(texts).toEqual(["M", "c01", "c02", "c01", "c02", "c11", "c12"]);
+    // Table shape survived: the map still resolves a consistent 3-column
+    // grid (no extra columns, no phantom rows).
+    let tableNodeRef: import("prosemirror-model").Node | undefined;
+    next.doc.descendants((n) => {
+      if (tableNodeRef == null && n.type.name === "table") tableNodeRef = n;
+      return tableNodeRef == null;
+    });
+    const map = TableMap.get(tableNodeRef as import("prosemirror-model").Node);
+    expect(map.width).toBe(3);
+    expect(map.height).toBe(3);
+  });
+});
+
+describe("duplicateColumn", () => {
+  it("clones the caret column right of itself, keeping row types", () => {
+    const { next } = runCommand(
+      makeDoc([table([
+        row([head("h0"), head("h1")]),
+        row([cell("a0"), cell("a1")]),
+        row([cell("b0"), cell("b1")]),
+      ])]),
+      "duplicateColumn",
+      0,
+    );
+    expect(cellTexts(next)).toEqual(["h0", "h0", "h1", "a0", "a0", "a1", "b0", "b0", "b1"]);
+    // The clone of the header column is a header cell.
+    const positions = cellPositions(next.doc);
+    const cloneCell = next.doc.nodeAt(positions[1]);
+    expect(cloneCell?.type.name).toBe("tableHeader");
+  });
+});
diff --git a/src/texto/extensions/table/commands.ts b/src/texto/extensions/table/commands.ts
index 42f6dbe..8a28570 100644
--- a/src/texto/extensions/table/commands.ts
+++ b/src/texto/extensions/table/commands.ts
@@ -6,8 +6,9 @@ import {
   type Transaction,
 } from "prosemirror-state";
 import { TextoCellSelection } from "./helpers/TextoCellSelection";
-import type { Node as ProseMirrorNode } from "prosemirror-model";
+import { Fragment, type Node as ProseMirrorNode, Slice } from "prosemirror-model";
 import {
+  addColumn,
   addColumnAfter,
   addColumnBefore,
   addRowAfter,
@@ -111,6 +112,144 @@ function deleteTableOverride(this: AddCommandsThis): Command {
   };
 }
 
+/* ─── Duplicate row/column (issue table-duplicate-row-column): clone the
+   selection's rows below itself / its column right of itself, like
+   Notion's "Duplicate". Merges crossing the paste line extend (the
+   addRow/addColumn convention); merges crossing the SELECTION boundary
+   are cloned unmerged (rowspan/colspan clamped to the copy region). ── */
+
+/** Offset of the start of the row with the given index, in table content
+ *  coordinates. */
+function dupRowStartOffset(table: ProseMirrorNode, rowIndex: number): number {
+  let offset = 0;
+  for (let i = 0; i < rowIndex; i += 1) {
+    offset += table.child(i).nodeSize;
+  }
+  return offset;
+}
+
+function duplicateRowOverride(this: AddCommandsThis): Command {
+  return ({ state, dispatch }) => {
+    if (!isInTable(state)) {
+      return false;
+    }
+    if (dispatch) {
+      const rect = selectedRect(state);
+      const count = rect.bottom - rect.top;
+      const tr = state.tr;
+
+      // Merges crossing the insertion line (below the rect) extend over the
+      // inserted copies; the columns they cover belong to them in every
+      // inserted row.
+      const coveredCols = new Set<number>();
+      if (rect.bottom < rect.map.height) {
+        for (let col = 0; col < rect.map.width; col += 1) {
+          const index = rect.bottom * rect.map.width + col;
+          if (rect.map.map[index] === rect.map.map[index - rect.map.width]) {
+            coveredCols.add(col);
+            const node = rect.table.nodeAt(rect.map.map[index]);
+            if (node) {
+              tr.setNodeMarkup(rect.tableStart + rect.map.map[index], null, {
+                ...node.attrs,
+                rowspan: ((node.attrs.rowspan as number) || 1) + count,
+              });
+            }
+          }
+        }
+      }
+
+      // Clone the rect's rows; a rowspan reaching past the rect bottom is
+      // clipped to the copy region, and columns covered by an extended
+      // merge get no cell in the copies.
+      const rows: ProseMirrorNode[] = [];
+      for (let row = rect.top; row < rect.bottom; row += 1) {
+        const rowNode = rect.table.child(row);
+        const rowStart = dupRowStartOffset(rect.table, row);
+        const rowEnd = rowStart + rowNode.nodeSize;
+        const cells: ProseMirrorNode[] = [];
+        const seen = new Set<number>();
+        for (let col = 0; col < rect.map.width; col += 1) {
+          if (coveredCols.has(col)) {
+            continue;
+          }
+          const offset = rect.map.map[row * rect.map.width + col];
+          if (seen.has(offset)) {
+            continue;
+          }
+          seen.add(offset);
+          if (offset < rowStart || offset >= rowEnd) {
+            continue;
+          }
+          const cellNode = rect.table.nodeAt(offset);
+          if (!cellNode) {
+            continue;
+          }
+          const maxSpan = rect.bottom - row;
+          cells.push(
+            ((cellNode.attrs.rowspan as number) || 1) > maxSpan
+              ? cellNode.type.create({ ...cellNode.attrs, rowspan: maxSpan }, cellNode.content)
+              : cellNode,
+          );
+        }
+        rows.push(rowNode.copy(Fragment.fromArray(cells)));
+      }
+
+      const pos = rect.tableStart + dupRowStartOffset(rect.table, rect.bottom);
+      tr.insert(pos, Fragment.fromArray(rows));
+      dispatch(tr.scrollIntoView());
+    }
+    return true;
+  };
+}
+
+function duplicateColumnOverride(this: AddCommandsThis): Command {
+  return ({ state, dispatch }) => {
+    if (!isInTable(state)) {
+      return false;
+    }
+    if (dispatch) {
+      const rect = selectedRect(state);
+      const tr = state.tr;
+      addColumn(tr, rect, rect.right);
+
+      // Fill the new column with clones of the selection's last column,
+      // bottom-up (an upper position stays valid after a lower edit). Rows
+      // whose slot is a rowspan continuation get nothing; a cloned cell
+      // with spans is unmerged (spans crossing the selection boundary are
+      // not reproduced).
+      const newTable = tr.doc.nodeAt(rect.tableStart - 1);
+      if (newTable) {
+        const newMap = TableMap.get(newTable);
+        const width = newMap.width;
+        for (let row = newMap.height - 1; row >= 0; row -= 1) {
+          const index = row * width + rect.right;
+          if (row > 0 && newMap.map[index] === newMap.map[index - width]) {
+            continue;
+          }
+          const newCellPos = rect.tableStart + newMap.map[index];
+          const newCell = tr.doc.nodeAt(newCellPos);
+          const srcOffset = rect.map.map[row * rect.map.width + (rect.right - 1)];
+          const src = rect.table.nodeAt(srcOffset);
+          if (!newCell || !src) {
+            continue;
+          }
+          const clone =
+            ((src.attrs.rowspan as number) || 1) > 1 || ((src.attrs.colspan as number) || 1) > 1
+              ? src.type.create({ ...src.attrs, rowspan: 1, colspan: 1 }, src.content)
+              : src;
+          tr.replace(
+            newCellPos,
+            newCellPos + newCell.nodeSize,
+            new Slice(Fragment.from(clone), 0, 0),
+          );
+        }
+      }
+      dispatch(tr.scrollIntoView());
+    }
+    return true;
+  };
+}
+
 function clearTable(this: AddCommandsThis): Command {
   return ({ tr, dispatch, state }) => {
     const anchor = findTableAnchor(state, -1, state.selection.$anchor);
@@ -534,6 +673,8 @@ export function addCommands(this: AddCommandsThis) {
     deleteTable: deleteTableOverride.bind(this),
     deleteRow: deleteRowOverride.bind(this),
     addRowAfter: addRowAfterOverride.bind(this),
+    duplicateRow: duplicateRowOverride.bind(this),
+    duplicateColumn: duplicateColumnOverride.bind(this),
     clearTable: clearTable.bind(this),
   };
 }
diff --git a/src/texto/extensions/table/elements/header/header.ts b/src/texto/extensions/table/elements/header/header.ts
index 095c961..4a72a08 100644
--- a/src/texto/extensions/table/elements/header/header.ts
+++ b/src/texto/extensions/table/elements/header/header.ts
@@ -58,7 +58,7 @@ export const TableHeader = Node.create<TableHeaderOptions>({
           dataColor: string | null;
           backgroundColor: string | null;
         }) => {
-          if (!attributes.dataColor) {
+          if (typeof attributes.dataColor !== "string") {
             return {};
           }
 
@@ -75,8 +75,11 @@ export const TableHeader = Node.create<TableHeaderOptions>({
             : { ["data-color"]: attributes.dataColor };
         },
         parseHTML: (element) => {
+          // A string or nothing — an array here (the old quirk) flowed into
+          // saved documents through clipboard-parsed cells and crashed the
+          // color rendering on every later open.
           const dataColor = element.dataset["color"];
-          return dataColor ? [dataColor] : [];
+          return dataColor ? dataColor : null;
         },
       },
       backgroundColor: {
diff --git a/src/texto/extensions/table/elements/tableCell/tableCell.ts b/src/texto/extensions/table/elements/tableCell/tableCell.ts
index 96b40dc..98a6e12 100644
--- a/src/texto/extensions/table/elements/tableCell/tableCell.ts
+++ b/src/texto/extensions/table/elements/tableCell/tableCell.ts
@@ -58,7 +58,7 @@ export const TableCell = Node.create<TableCellOptions>({
           dataColor: string | null;
           backgroundColor: string | null;
         }) => {
-          if (!attributes.dataColor) {
+          if (typeof attributes.dataColor !== "string") {
             return {};
           }
 
@@ -75,8 +75,11 @@ export const TableCell = Node.create<TableCellOptions>({
             : { ["data-color"]: attributes.dataColor };
         },
         parseHTML: (element) => {
+          // A string or nothing — an array here (the old quirk) flowed into
+          // saved documents through clipboard-parsed cells and crashed the
+          // color rendering on every later open.
           const dataColor = element.dataset["color"];
-          return dataColor ? [dataColor] : [];
+          return dataColor ? dataColor : null;
         },
       },
       backgroundColor: {
diff --git a/src/texto/extensions/table/helpers/TextoCellSelection.test.ts b/src/texto/extensions/table/helpers/TextoCellSelection.test.ts
index 1791480..e8c8c68 100644
--- a/src/texto/extensions/table/helpers/TextoCellSelection.test.ts
+++ b/src/texto/extensions/table/helpers/TextoCellSelection.test.ts
@@ -114,22 +114,25 @@ describe("resize handle decorations (mobile view)", () => {
   const caretInFirstCell = (doc: ProseMirrorNode) =>
     TextSelection.create(doc, cellPositions(doc)[0] + 1);
 
-  it("renders only the overlay on desktop (caret in cell)", () => {
-    expect(decorations(false, caretInFirstCell)).toHaveLength(1);
+  it("draws nothing on desktop — native selection (caret in cell)", () => {
+    // The circle and the custom mouse gesture are a touch affordance; on
+    // desktop the selection is native (issue table-selection-native-drag).
+    expect(decorations(false, caretInFirstCell)).toHaveLength(0);
   });
 
   it("adds a resize handle per row segment on mobile (caret in cell)", () => {
-    // 2x2: overlay + 2 handle segments (one per row).
-    expect(decorations(true, caretInFirstCell)).toHaveLength(3);
+    // 2x2: 2 handle segments (one per row); the selection circle is gone.
+    expect(decorations(true, caretInFirstCell)).toHaveLength(2);
   });
 
-  it("adds resize handles next to the multi-cell overlay on mobile", () => {
+  it("adds resize handles next to a multi-cell selection on mobile", () => {
     const cellRange = (doc: ProseMirrorNode) => {
       const [p1, , , p4] = cellPositions(doc);
       return CellSelection.create(doc, p1, p4);
     };
 
-    // Overlay + 2 handle segments (the .selectedCell class is added by tableEditing).
-    expect(decorations(true, cellRange)).toHaveLength(3);
+    // 2 handle segments (the .selectedCell class is added by tableEditing);
+    // the selection circle is gone on both platforms.
+    expect(decorations(true, cellRange)).toHaveLength(2);
   });
 });
diff --git a/src/texto/extensions/table/helpers/cellClipboard.test.ts b/src/texto/extensions/table/helpers/cellClipboard.test.ts
new file mode 100644
index 0000000..4326f74
--- /dev/null
+++ b/src/texto/extensions/table/helpers/cellClipboard.test.ts
@@ -0,0 +1,636 @@
+import type { Node as ProseMirrorNode } from "prosemirror-model";
+import { DOMSerializer, Fragment, Slice } from "prosemirror-model";
+import { EditorState, TextSelection } from "prosemirror-state";
+import type { EditorView } from "prosemirror-view";
+import { CellSelection } from "prosemirror-tables";
+import { describe, expect, it } from "vitest";
+
+import { buildSchema } from "../../../../../tests/helpers/buildSchema";
+
+import { cellClipboardPlugin, copyTableSelection, cutCellSelection, cutTableSelection, extractCellGrid } from "./cellClipboard";
+
+const schema = buildSchema();
+
+function cell(text: string, attrs: Record<string, unknown> = {}): ProseMirrorNode {
+  return schema.nodes.tableCell.create(attrs, [
+    schema.nodes.paragraph.create(null, text ? [schema.text(text)] : []),
+  ]);
+}
+
+function row(cells: Array<ProseMirrorNode>): ProseMirrorNode {
+  return schema.nodes.tableRow.create(null, cells);
+}
+
+function table(rows: Array<ProseMirrorNode>): ProseMirrorNode {
+  return schema.nodes.table.create(
+    { data: { rowsCount: rows.length, colsCount: rows[0]?.childCount ?? 0 } },
+    rows,
+  );
+}
+
+function boldCell(text: string): ProseMirrorNode {
+  return schema.nodes.tableCell.create(null, [
+    schema.nodes.paragraph.create(null, [schema.text(text, [schema.marks.bold.create()])]),
+  ]);
+}
+
+function headerCell(text: string): ProseMirrorNode {
+  return schema.nodes.tableHeader.create(null, [
+    schema.nodes.paragraph.create(null, [schema.text(text)]),
+  ]);
+}
+
+/** A doc with two plain 2x2 body tables and a paragraph between them. */
+function twoTablesDoc(): ProseMirrorNode {
+  const cellA = (t: string) => cell(t);
+  return schema.nodes.noteDoc.create(null, [
+    schema.nodes.noteTitle.create(null, [schema.text("T")]),
+    table([
+      row([cellA("A00"), cellA("A01")]),
+      row([cellA("A10"), cellA("A11")]),
+    ]),
+    schema.nodes.paragraph.create(null, [schema.text("between")]),
+    table([
+      row([cell("B00"), cell("B01")]),
+      row([cell("B10"), cell("B11")]),
+    ]),
+  ]);
+}
+
+function cellPositions(doc: ProseMirrorNode, tableIndex = 0): number[] {
+  const positions: number[] = [];
+  let seen = -1;
+  doc.descendants((node, pos) => {
+    if (node.type.name === "table") {
+      seen += 1;
+      return seen === tableIndex;
+    }
+    if (seen === tableIndex && (node.type.name === "tableCell" || node.type.name === "tableHeader")) {
+      positions.push(pos);
+    }
+    return true;
+  });
+  return positions;
+}
+
+function cellTexts(doc: ProseMirrorNode, tableIndex = 0): string[] {
+  const texts: string[] = [];
+  let seen = -1;
+  doc.descendants((node, pos) => {
+    if (node.type.name === "table") {
+      seen += 1;
+      return seen === tableIndex;
+    }
+    if (seen === tableIndex && (node.type.name === "tableCell" || node.type.name === "tableHeader")) {
+      texts.push(node.textContent);
+    }
+    return true;
+  });
+  return texts;
+}
+
+function stateWithSelection(doc: ProseMirrorNode, selection: CellSelection | TextSelection): EditorState {
+  return EditorState.create({
+    doc,
+    selection,
+    plugins: [cellClipboardPlugin()],
+  });
+}
+
+/** A fake view: handlePaste/cutCellSelection only need state, dispatch and
+ *  serializeForClipboard (real layout is not involved in these paths). */
+function fakeView(state: EditorState, onDispatch: (tr: import("prosemirror-state").Transaction) => void): EditorView {
+  const serializer = DOMSerializer.fromSchema(state.schema);
+  return {
+    state,
+    dispatch: (tr: import("prosemirror-state").Transaction) => onDispatch(tr),
+    serializeForClipboard: (slice: Slice) => {
+      const dom = createDiv();
+      dom.appendChild(serializer.serializeFragment(slice.content));
+      return { dom, text: slice.content.textBetween(0, slice.content.size, "\n\n"), slice };
+    },
+  } as unknown as EditorView;
+}
+
+function paste(state: EditorState, slice: Slice): EditorState {
+  let next = state;
+  const plugin = state.plugins.find((p) => p.spec.props?.handlePaste);
+  const handlePaste = plugin?.spec.props?.handlePaste as
+    | ((view: EditorView, event: unknown, slice: Slice) => boolean)
+    | undefined;
+  expect(handlePaste).toBeDefined();
+  handlePaste?.(fakeView(state, (tr) => { next = state.apply(tr); }), {}, slice);
+  return next;
+}
+
+function rectSelection(doc: ProseMirrorNode, tableIndex: number): CellSelection {
+  const [p1, , , p4] = cellPositions(doc, tableIndex);
+  return new CellSelection(doc.resolve(p1), doc.resolve(p4));
+}
+
+describe("extractCellGrid", () => {
+  it("reads bare rows", () => {
+    const grid = extractCellGrid(new Slice(Fragment.fromArray([row([cell("a"), cell("b")])]), 1, 1));
+    expect(grid).toHaveLength(1);
+    expect(grid?.[0]).toHaveLength(2);
+    expect(grid?.[0][0].textContent).toBe("a");
+  });
+
+  it("unwraps a whole table copy", () => {
+    const t = table([row([cell("a")]), row([cell("b")])]);
+    const grid = extractCellGrid(new Slice(Fragment.from(t), 1, 1));
+    expect(grid).toHaveLength(2);
+  });
+
+  it("reads a single-cell slice (open depths)", () => {
+    const grid = extractCellGrid(new Slice(Fragment.from(cell("a")), 1, 1));
+    expect(grid).toHaveLength(1);
+    expect(grid?.[0][0].textContent).toBe("a");
+  });
+
+  it("rejects plain content", () => {
+    const para = schema.nodes.paragraph.create(null, [schema.text("x")]);
+    expect(extractCellGrid(new Slice(Fragment.from(para), 0, 0))).toBeNull();
+  });
+});
+
+describe("paste onto a cell selection", () => {
+  it("replaces the target rect content and preserves target cell attrs", () => {
+    // Source: S01 carries bold text; S10 carries a background color attr.
+    const sourceRows = [
+      row([cell("S00"), boldCell("S01")]),
+      row([cell("S10", { backgroundColor: "#ff0000" }), cell("S11")]),
+    ];
+
+    // Target: B00 has its own background color and wider column — both must
+    // survive the paste (only content is replaced).
+    const withAttrs = schema.nodes.noteDoc.create(null, [
+      schema.nodes.noteTitle.create(null, [schema.text("T")]),
+      table([row([cell("B00"), cell("B01")]), row([cell("B10"), cell("B11")])]),
+      schema.nodes.paragraph.create(null, [schema.text("between")]),
+      table([
+        row([cell("B00", { backgroundColor: "#00ff00", colwidth: [120] }), cell("B01")]),
+        row([cell("B10"), cell("B11")]),
+      ]),
+    ]);
+    const state = stateWithSelection(withAttrs, rectSelection(withAttrs, 1));
+    const next = paste(state, new Slice(Fragment.fromArray(sourceRows), 1, 1));
+
+    expect(cellTexts(next.doc, 1)).toEqual(["S00", "S01", "S10", "S11"]);
+    // Target attrs preserved; source fill did not leak in.
+    const target = cellPositions(next.doc, 1);
+    const firstCell = next.doc.nodeAt(target[0]);
+    expect(firstCell?.attrs.backgroundColor).toBe("#00ff00");
+    expect(firstCell?.attrs.colwidth).toEqual([120]);
+    // Inline formatting travels with the content.
+    const secondCell = next.doc.nodeAt(target[1]);
+    expect(secondCell?.firstChild?.firstChild?.marks).toHaveLength(1);
+    // The selection is back over the same rectangle.
+    expect(next.selection).toBeInstanceOf(CellSelection);
+    // The source table is untouched.
+    expect(cellTexts(next.doc, 0)).toEqual(["B00", "B01", "B10", "B11"]);
+  });
+
+  it("keeps the structure valid (trailing paragraphs in every cell)", () => {
+    const doc = twoTablesDoc();
+    const state = stateWithSelection(doc, rectSelection(doc, 1));
+    const next = paste(state, new Slice(Fragment.from(cell("X")), 1, 1));
+    const texts = cellTexts(next.doc, 1);
+    expect(texts).toEqual(["X", "X", "X", "X"]);
+    let cells = 0;
+    next.doc.descendants((node) => {
+      if (node.type.name === "tableCell" || node.type.name === "tableHeader") {
+        cells += 1;
+        expect(node.lastChild?.type.name).toBe("paragraph");
+      }
+      return true;
+    });
+    expect(cells).toBe(8);
+  });
+
+  it("tiles a 1x1 copy over a larger rect and keeps spans", () => {
+    const doc = twoTablesDoc();
+    const state = stateWithSelection(doc, rectSelection(doc, 1));
+    const next = paste(state, new Slice(Fragment.from(cell("Z")), 1, 1));
+    expect(cellTexts(next.doc, 1)).toEqual(["Z", "Z", "Z", "Z"]);
+  });
+
+  it("keeps cells outside the rectangle untouched", () => {
+    // Target: 3 columns; the selection covers columns 0-1 of both body rows.
+    const doc = schema.nodes.noteDoc.create(null, [
+      schema.nodes.noteTitle.create(null, [schema.text("T")]),
+      table([
+        row([cell("A0"), cell("A1")]),
+        row([cell("A2"), cell("A3")]),
+      ]),
+      schema.nodes.paragraph.create(null, [schema.text("between")]),
+      table([
+        row([cell("B00"), cell("B01"), cell("KEEP1")]),
+        row([cell("B10"), cell("B11"), cell("KEEP2")]),
+      ]),
+    ]);
+    const positions = cellPositions(doc, 1);
+    const state = stateWithSelection(
+      doc,
+      new CellSelection(doc.resolve(positions[0]), doc.resolve(positions[4])),
+    );
+    const next = paste(state, new Slice(Fragment.fromArray([
+      row([cell("X0"), cell("X1")]),
+      row([cell("X2"), cell("X3")]),
+    ]), 1, 1));
+    expect(cellTexts(next.doc, 1)).toEqual(["X0", "X1", "KEEP1", "X2", "X3", "KEEP2"]);
+  });
+
+  it("pastes a whole-table copy onto a selection (the original bug shape)", () => {
+    // A full-table copy travels as Slice([table], 1, 1); pasting it used to
+    // nest the table into the selected cells.
+    const doc = twoTablesDoc();
+    const sourceTable = table([
+      row([cell("S0"), cell("S1")]),
+      row([cell("S2"), cell("S3")]),
+    ]);
+    const state = stateWithSelection(doc, rectSelection(doc, 1));
+    const next = paste(state, new Slice(Fragment.from(sourceTable), 1, 1));
+    expect(cellTexts(next.doc, 1)).toEqual(["S0", "S1", "S2", "S3"]);
+    // No nested table anywhere.
+    let nested = 0;
+    next.doc.descendants((node) => {
+      if (node.type.name === "tableCell") {
+        node.content.forEach((child) => {
+          if (child.type.name === "table") nested += 1;
+        });
+      }
+      return true;
+    });
+    expect(nested).toBe(0);
+  });
+
+  it("tiles source cells in order over a merged target cell", () => {
+    // Target: col 0 spans two columns (colspan 2), col 2 is separate.
+    const doc = schema.nodes.noteDoc.create(null, [
+      schema.nodes.noteTitle.create(null, [schema.text("T")]),
+      table([row([cell("A0"), cell("A1")])]),
+      schema.nodes.paragraph.create(null, [schema.text("between")]),
+      table([
+        row([
+          schema.nodes.tableCell.create({ colspan: 2 }, [
+            schema.nodes.paragraph.create(null, [schema.text("WIDE")]),
+          ]),
+          cell("C"),
+        ]),
+      ]),
+    ]);
+    const positions = cellPositions(doc, 1);
+    const state = stateWithSelection(
+      doc,
+      new CellSelection(doc.resolve(positions[0]), doc.resolve(positions[1])),
+    );
+    const next = paste(state, new Slice(Fragment.fromArray([
+      row([cell("X"), cell("Y")]),
+    ]), 1, 1));
+    // The merged cell takes the first source cell, C takes the second one.
+    expect(cellTexts(next.doc, 1)).toEqual(["X", "Y"]);
+    const target = next.doc.nodeAt(positions[0]);
+    expect(target?.attrs.colspan).toBe(2);
+  });
+
+  it("pastes header cells onto a header selection", () => {
+    const doc = twoTablesDoc(); // both tables have header rows
+    const positions = cellPositions(doc, 1);
+    const state = stateWithSelection(
+      doc,
+      new CellSelection(doc.resolve(positions[0]), doc.resolve(positions[1])),
+    );
+    const next = paste(state, new Slice(Fragment.fromArray([
+      row([headerCell("H0"), headerCell("H1")]),
+    ]), 1, 1));
+    expect(cellTexts(next.doc, 1)).toEqual(["H0", "H1", "B10", "B11"]);
+  });
+});
+
+describe("paste at a caret", () => {
+  it("single copied cell replaces the caret cell content", () => {
+    const doc = twoTablesDoc();
+    const [b0] = cellPositions(doc, 1);
+    const state = stateWithSelection(doc, TextSelection.create(doc, b0 + 1));
+    const next = paste(state, new Slice(Fragment.from(cell("Q")), 1, 1));
+    expect(cellTexts(next.doc, 1)[0]).toBe("Q");
+    expect(cellTexts(next.doc, 1)).toHaveLength(4);
+  });
+
+  it("copied rows are inserted after the caret row", () => {
+    const doc = twoTablesDoc();
+    const [b0] = cellPositions(doc, 1);
+    const state = stateWithSelection(doc, TextSelection.create(doc, b0 + 1));
+    const next = paste(state, new Slice(Fragment.fromArray([
+      row([cell("R0a"), cell("R0b")]),
+      row([cell("R1a"), cell("R1b")]),
+    ]), 1, 1));
+    expect(cellTexts(next.doc, 1)).toEqual([
+      "B00", "B01",
+      "R0a", "R0b",
+      "R1a", "R1b",
+      "B10", "B11",
+    ]);
+    expect(next.selection.from).toBeGreaterThan(b0);
+  });
+
+  it("aligns columns: extra source columns are dropped", () => {
+    const doc = twoTablesDoc(); // target is 2 columns
+    const [b0] = cellPositions(doc, 1);
+    const state = stateWithSelection(doc, TextSelection.create(doc, b0 + 1));
+    const next = paste(state, new Slice(Fragment.fromArray([
+      row([cell("c0"), cell("c1"), cell("c2")]), // the 3rd column is dropped
+    ]), 1, 1));
+    expect(cellTexts(next.doc, 1)).toEqual([
+      "B00", "B01",
+      "c0", "c1",
+      "B10", "B11",
+    ]);
+  });
+
+  it("aligns columns: missing source columns become empty cells", () => {
+    // Target is 3 columns, the source row has 2 cells — the third one pads.
+    const doc = schema.nodes.noteDoc.create(null, [
+      schema.nodes.noteTitle.create(null, [schema.text("T")]),
+      table([row([cell("A0"), cell("A1"), cell("A2")])]),
+      schema.nodes.paragraph.create(null, [schema.text("between")]),
+      table([row([cell("B0"), cell("B1"), cell("B2")])]),
+    ]);
+    const [b0] = cellPositions(doc, 1);
+    const state = stateWithSelection(doc, TextSelection.create(doc, b0 + 1));
+    const next = paste(state, new Slice(Fragment.fromArray([
+      row([cell("c0"), cell("c1")]),
+    ]), 1, 1));
+    expect(cellTexts(next.doc, 1)).toEqual(["B0", "B1", "B2", "c0", "c1", ""]);
+    // The padded cell satisfies the trailing-paragraph invariant.
+    const positions = cellPositions(next.doc, 1);
+    const padded = next.doc.nodeAt(positions[5]);
+    expect(padded?.lastChild?.type.name).toBe("paragraph");
+  });
+
+  it("inserts rows under a rowspan: merges extend, rows fill free columns", () => {
+    // 3-col table; col 0 is merged across rows 0-1 (rowspan 2). The caret
+    // sits in row 0, so the insertion point is crossed by the merge.
+    const merged = schema.nodes.tableCell.create({ rowspan: 2 }, [
+      schema.nodes.paragraph.create(null, [schema.text("M")]),
+    ]);
+    const doc = schema.nodes.noteDoc.create(null, [
+      schema.nodes.noteTitle.create(null, [schema.text("T")]),
+      table([
+        row([merged, cell("c01"), cell("c02")]),
+        row([cell("c11"), cell("c12")]),
+        row([cell("c21"), cell("c22"), cell("c23")]),
+      ]),
+    ]);
+    const positions = cellPositions(doc, 0);
+    const state = stateWithSelection(doc, TextSelection.create(doc, positions[1] + 1));
+    const next = paste(state, new Slice(Fragment.fromArray([
+      row([cell("X"), cell("Y")]),
+    ]), 1, 1));
+    // The new row holds cells at the free columns (1-2) only; col 0 is the
+    // extended merge.
+    expect(cellTexts(next.doc, 0)).toEqual([
+      "M", "c01", "c02",
+      "X", "Y",
+      "c11", "c12",
+      "c21", "c22", "c23",
+    ]);
+    // The merge crossing the insertion point extended by one row.
+    const mergedNode = next.doc.nodeAt(positions[0]);
+    expect(mergedNode?.attrs.rowspan).toBe(3);
+  });
+
+  it("pastes a copied column at a caret: a new column, not rows", () => {
+    // 3x2 target; the copy is a 2-cell vertical run (a column-shaped grid).
+    const doc = twoTablesDoc();
+    const [b0] = cellPositions(doc, 1);
+    const state = stateWithSelection(doc, TextSelection.create(doc, b0 + 1));
+    const next = paste(state, new Slice(Fragment.fromArray([
+      row([cell("K0")]),
+      row([cell("K1")]),
+    ]), 1, 1));
+    // A column is inserted right of the caret column, filled top down.
+    expect(cellTexts(next.doc, 1)).toEqual([
+      "B00", "K0", "B01",
+      "B10", "K1", "B11",
+    ]);
+    // Still 2 rows — rows must not appear.
+    let rowCount = 0;
+    let seen = -1;
+    next.doc.descendants((node) => {
+      if (node.type.name === "table") { seen += 1; return seen === 1; }
+      if (seen === 1 && node.type.name === "tableRow") rowCount += 1;
+      return true;
+    });
+    expect(rowCount).toBe(2);
+  });
+
+  it("column paste fills only the available rows and keeps types", () => {
+    // Target: header row + 1 body row; the copy is a 2-row single-cell grid
+    // (a column) — both rows fill, the copy's second cell is dropped.
+    const doc = schema.nodes.noteDoc.create(null, [
+      schema.nodes.noteTitle.create(null, [schema.text("T")]),
+      table([row([cell("A0"), cell("A1")])]),
+      schema.nodes.paragraph.create(null, [schema.text("between")]),
+      table([
+        row([headerCell("Bh"), cell("B0")]),
+        row([cell("B1"), cell("B2")]),
+      ]),
+    ]);
+    const positions = cellPositions(doc, 1);
+    const state = stateWithSelection(doc, TextSelection.create(doc, positions[1] + 1));
+    const next = paste(state, new Slice(Fragment.fromArray([
+      row([headerCell("K")]),
+      row([cell("K2")]),
+      row([cell("K3")]),
+    ]), 1, 1));
+    // The column is inserted right of the caret's column (B0 is the second
+    // column); the third copied row is dropped (the target has only two).
+    expect(cellTexts(next.doc, 1)).toEqual(["Bh", "B0", "K", "B1", "B2", "K2"]);
+    // The filled cell of the header row is a header cell.
+    const newTop = next.doc.nodeAt(cellPositions(next.doc, 1)[2]);
+    expect(newTop?.type.name).toBe("tableHeader");
+  });
+});
+
+describe("cut (Excel semantics)", () => {
+  const flush = () => new Promise((r) => window.setTimeout(r, 0));
+
+  function stubWriteOk(): void {
+    (navigator as unknown as { clipboard: unknown }).clipboard = {
+      writeText: async (t: string) => {
+        void t;
+      },
+    };
+  }
+
+  function stubWriteDenied(): void {
+    (navigator as unknown as { clipboard: unknown }).clipboard = {
+      write: async () => {
+        throw new Error("denied");
+      },
+      writeText: async () => {
+        throw new Error("denied");
+      },
+    };
+  }
+
+  async function cutWith(state: EditorState, stub: () => void = stubWriteOk): Promise<{ dispatched: Array<import("prosemirror-state").Transaction>; next: EditorState }> {
+    const dispatched: Array<import("prosemirror-state").Transaction> = [];
+    stub();
+    const view = {
+      state,
+      dispatch: (tr: import("prosemirror-state").Transaction) => dispatched.push(tr),
+      serializeForClipboard: (slice: Slice) => ({
+        dom: createDiv(),
+        text: "",
+        slice,
+      }),
+    } as unknown as EditorView;
+    expect(cutCellSelection(view)).toBe(true);
+    // The delete is dispatched only after the clipboard write confirmed.
+    await flush();
+    expect(dispatched).toHaveLength(1);
+    return { dispatched, next: state.apply(dispatched[0]) };
+  }
+
+  it("removes full rows (a body row out of several)", async () => {
+    // 3 body rows in the second table; select the middle one.
+    const doc = schema.nodes.noteDoc.create(null, [
+      schema.nodes.noteTitle.create(null, [schema.text("T")]),
+      table([row([cell("A0")]), row([cell("A1")]), row([cell("A2")])]),
+      schema.nodes.paragraph.create(null, [schema.text("between")]),
+      table([row([cell("B0")]), row([cell("B1")]), row([cell("B2")])]),
+    ]);
+    const positions = cellPositions(doc, 1);
+    const state = stateWithSelection(doc, new CellSelection(doc.resolve(positions[1])));
+    const { next } = await cutWith(state);
+    expect(cellTexts(next.doc, 1)).toEqual(["B0", "B2"]);
+  });
+
+  it("cutting every row removes the table (an empty table is invalid)", async () => {
+    const doc = twoTablesDoc();
+    const state = stateWithSelection(doc, rectSelection(doc, 1));
+    const { next } = await cutWith(state);
+    let tables = 0;
+    next.doc.descendants((node) => {
+      if (node.type.name === "table") tables += 1;
+      return true;
+    });
+    expect(tables).toBe(1);
+  });
+
+  it("clears contents of a partial rectangle", async () => {
+    const doc = twoTablesDoc();
+    const [p1] = cellPositions(doc, 1);
+    // Select only the first cell of the second table (1x1 "rect").
+    const state = stateWithSelection(doc, new CellSelection(doc.resolve(p1)));
+    const { next } = await cutWith(state);
+    expect(cellTexts(next.doc, 1)).toEqual(["", "B01", "B10", "B11"]);
+    // Structure survived: still 4 cells.
+    expect(cellTexts(next.doc, 1)).toHaveLength(4);
+  });
+
+  it("a denied clipboard leaves the content intact (cut deletes only after the copy landed)", async () => {
+    const doc = twoTablesDoc();
+    const state = stateWithSelection(doc, rectSelection(doc, 1));
+    const dispatched: Array<import("prosemirror-state").Transaction> = [];
+    stubWriteDenied();
+    const view = {
+      state,
+      dispatch: (tr: import("prosemirror-state").Transaction) => dispatched.push(tr),
+      serializeForClipboard: (slice: Slice) => ({
+        dom: createDiv(),
+        text: "",
+        slice,
+      }),
+    } as unknown as EditorView;
+    expect(cutCellSelection(view)).toBe(true);
+    await flush();
+    expect(dispatched).toHaveLength(0);
+    // Nothing was removed.
+    expect(cellTexts(state.doc, 1)).toEqual(cellTexts(state.doc, 1));
+    expect(cellTexts(view.state.doc, 1)).toEqual(["B00", "B01", "B10", "B11"]);
+  });
+
+  it("does not touch a plain caret cut", () => {
+    const doc = twoTablesDoc();
+    const state = stateWithSelection(doc, TextSelection.create(doc, 6));
+    const view = fakeView(state, () => {
+      throw new Error("must not dispatch");
+    });
+    expect(cutCellSelection(view)).toBe(false);
+  });
+});
+
+describe("toolbar clipboard buttons (caret 1×1 scope)", () => {
+  /** Stub navigator.clipboard; captures the written payload as strings. */
+  const stubClipboard = (captured: Record<string, string>) => {
+    (navigator as unknown as { clipboard: unknown }).clipboard = {
+      write: async (items: Array<{ types: string[]; getType: (t: string) => Promise<Blob> }>) => {
+        for (const item of items) {
+          for (const type of item.types) {
+            captured[type] = await (await item.getType(type)).text();
+          }
+        }
+      },
+      writeText: async (t: string) => {
+        captured["text/plain"] = t;
+      },
+      read: async () => [],
+      readText: async () => "",
+    };
+  };
+
+  const fakeView = (state: EditorState, dispatched: Array<import("prosemirror-state").Transaction>) =>
+    ({
+      state,
+      dispatch: (tr: import("prosemirror-state").Transaction) => dispatched.push(tr),
+      serializeForClipboard: (slice: Slice) => {
+        const dom = createDiv();
+        dom.appendChild(DOMSerializer.fromSchema(schema).serializeFragment(slice.content));
+        return { dom, text: slice.content.textBetween(0, slice.content.size, "\n\n"), slice };
+      },
+    }) as unknown as EditorView;
+
+  it("copyTableSelection copies the caret cell as a 1×1 table", async () => {
+    const captured: Record<string, string> = {};
+    stubClipboard(captured);
+    const doc = twoTablesDoc();
+    const [b0] = cellPositions(doc, 1);
+    const state = stateWithSelection(doc, TextSelection.create(doc, b0 + 1));
+    expect(copyTableSelection(fakeView(state, []))).toBe(true);
+    await Promise.resolve();
+    await Promise.resolve();
+    // jsdom has no ClipboardItem — the write degrades to plain text, which
+    // is exactly the fallback the production code promises.
+    expect(captured["text/plain"]).toContain("B00");
+  });
+
+  it("cutTableSelection clears the caret cell", async () => {
+    const captured: Record<string, string> = {};
+    stubClipboard(captured);
+    const doc = twoTablesDoc();
+    const [b0] = cellPositions(doc, 1);
+    const state = stateWithSelection(doc, TextSelection.create(doc, b0 + 1));
+    const dispatched: Array<import("prosemirror-state").Transaction> = [];
+    expect(await cutTableSelection(fakeView(state, dispatched))).toBe(true);
+    await new Promise((r) => window.setTimeout(r, 0));
+    expect(dispatched).toHaveLength(1);
+    const next = state.apply(dispatched[0]);
+    expect(cellTexts(next.doc, 1)[0]).toBe("");
+  });
+
+  it("both no-op outside a table", () => {
+    const state = stateWithSelection(twoTablesDoc(), TextSelection.create(twoTablesDoc(), 1));
+    const view = {
+      state,
+      dispatch: () => {},
+      serializeForClipboard: () => ({ dom: createDiv(), text: "", slice: null }),
+    } as unknown as EditorView;
+    expect(copyTableSelection(view)).toBe(false);
+    void cutTableSelection(view); // must not throw; result checked below
+    return cutTableSelection(view).then((r) => expect(r).toBe(false));
+  });
+});
diff --git a/src/texto/extensions/table/helpers/cellClipboard.ts b/src/texto/extensions/table/helpers/cellClipboard.ts
new file mode 100644
index 0000000..fefd015
--- /dev/null
+++ b/src/texto/extensions/table/helpers/cellClipboard.ts
@@ -0,0 +1,616 @@
+import { Fragment, Slice, type Node as ProseMirrorNode } from "prosemirror-model";
+import { Plugin, TextSelection, type EditorState, type Transaction } from "prosemirror-state";
+import type { EditorView } from "prosemirror-view";
+import {
+  addColumn,
+  CellSelection,
+  deleteRow,
+  deleteTable,
+  isInTable,
+  selectionCell,
+  selectedRect,
+  TableMap,
+  tableNodeTypes,
+  type TableRect,
+} from "prosemirror-tables";
+
+import { TextoCellSelection } from "./TextoCellSelection";
+
+/**
+ * Table clipboard semantics (owner decisions, issue table-clipboard):
+ *
+ * - Cmd+C — stock ProseMirror copy of the CellSelection content (works as is;
+ *   this module only makes sure the editor is focused after a cell drag, see
+ *   handleMouseDown.stop).
+ * - Cmd+V onto a cell selection — the copied cell block replaces the CONTENT
+ *   of the selected rectangle; target cell attributes (fill, widths, borders,
+ *   spans) are preserved, so the target table structure never changes. The
+ *   source grid tiles over a larger target rectangle (Excel behavior).
+ * - Cmd+V with a bare caret in a cell — a single copied cell replaces the
+ *   caret cell's content; several copied cells/rows are INSERTED as new rows
+ *   after the caret row, aligned to the target column count: extra source
+ *   columns are dropped, missing ones become empty cells.
+ * - Cmd+X — Excel semantics: a full-row selection removes those rows, a
+ *   partial rectangle clears the cell contents. Either way the copied block
+ *   goes to the system clipboard first.
+ *
+ * Without the paste override the table fragment raced past
+ * prosemirror-tables' pastedCells (its shape assumptions are stricter than
+ * what our clipboard round-trip produces) and ended up as a nested table
+ * inside a cell.
+ */
+
+function isCellLike(node: ProseMirrorNode): boolean {
+  // .spec is untyped (any) in prosemirror-model — cast explicitly.
+  const role = node.type.spec.tableRole as string | undefined;
+  return role === "cell" || role === "header_cell";
+}
+
+/** Attrs for a cell created from a clipboard-parsed source node. Parsed
+ *  attrs are untrusted: dataColor can be a non-string (the parseHTML quirk
+ *  of the data-color dataset) and only a well-formed color may reach
+ *  renderHTML's safeColorValue. */
+function insertedCellAttrs(source: ProseMirrorNode, span: number): Record<string, unknown> {
+  const attrs = source.attrs as Record<string, unknown>;
+  const dataColor = attrs.dataColor;
+  return {
+    ...attrs,
+    colspan: span,
+    rowspan: 1,
+    dataColor: typeof dataColor === "string" ? dataColor : null,
+  };
+}
+
+/**
+ * The rectangular cell grid carried by a clipboard slice: an array of rows,
+ * each an array of cell nodes. Accepts the shapes a table copy produces —
+ * bare rows, a whole table node, or a run of cells (a single-cell copy with
+ * open depths). Returns null for plain (non-table) content. The unwrap is an
+ * unconditional single-child walk: a chain of nested tables of any depth
+ * bottoms out at its innermost content.
+ */
+export function extractCellGrid(slice: Slice): Array<Array<ProseMirrorNode>> | null {
+  let content = slice.content;
+  while (content.childCount === 1) {
+    // .spec is untyped (any) in prosemirror-model — cast explicitly.
+    if ((content.child(0).type.spec.tableRole as string | undefined) !== "table") {
+      break;
+    }
+    content = content.child(0).content;
+  }
+
+  const rows: Array<Array<ProseMirrorNode>> = [];
+  let cellRun: Array<ProseMirrorNode> = [];
+  const flushRun = () => {
+    if (cellRun.length) {
+      rows.push(cellRun);
+      cellRun = [];
+    }
+  };
+
+  for (let i = 0; i < content.childCount; i += 1) {
+    const child = content.child(i);
+    const role = child.type.spec.tableRole as string | undefined;
+    if (role === "row") {
+      flushRun();
+      const cells: Array<ProseMirrorNode> = [];
+      for (let c = 0; c < child.childCount; c += 1) {
+        if (isCellLike(child.child(c))) {
+          cells.push(child.child(c));
+        }
+      }
+      if (cells.length) {
+        rows.push(cells);
+      }
+    } else if (isCellLike(child)) {
+      cellRun.push(child);
+    } else {
+      return null;
+    }
+  }
+  flushRun();
+
+  return rows.length ? rows : null;
+}
+
+/** Offset of the start of the row with the given index, in table content
+ *  coordinates (TableMap.positionAt targets a cell column, not a row edge). */
+function rowStartOffset(table: ProseMirrorNode, rowIndex: number): number {
+  let offset = 0;
+  for (let i = 0; i < rowIndex; i += 1) {
+    offset += table.child(i).nodeSize;
+  }
+  return offset;
+}
+
+/** Replace the content of the selected rectangle with the copied grid.
+ *  Target cell nodes survive with their attributes; only the content is
+ *  swapped, so spans, widths, fill and borders come from the target. Cells
+ *  outside the rectangle (in the same rows) are kept unchanged. */
+function replaceRectWithGrid(
+  state: EditorState,
+  dispatch: (tr: Transaction) => void,
+  rect: TableRect,
+  grid: Array<Array<ProseMirrorNode>>,
+): void {
+  const { map, table, tableStart } = rect;
+  const gridH = grid.length;
+  const gridW = Math.max(...grid.map((row) => row.length));
+
+  const newRows: Array<ProseMirrorNode> = [];
+  for (let row = rect.top; row < rect.bottom; row += 1) {
+    const rowNode = table.child(row);
+    const rowStart = rowStartOffset(table, row);
+    const rowEnd = rowStart + rowNode.nodeSize;
+    const gridRow = grid[(row - rect.top) % gridH];
+    const cells: Array<ProseMirrorNode> = [];
+    const seenOffsets = new Set<number>();
+    // Source placements consume the SOURCE grid by PHYSICAL cells (one per
+    // placement): gridRow holds nodes, so a colspan on a source node must
+    // not advance the cursor past its neighbours.
+    let srcIdx = 0;
+    for (let col = 0; col < map.width; col += 1) {
+      const offset = map.map[row * map.width + col];
+      if (seenOffsets.has(offset)) {
+        continue; // colspan continuation — the cell is already built
+      }
+      seenOffsets.add(offset);
+      if (offset < rowStart || offset >= rowEnd) {
+        continue; // rowspan continuation — nothing in this row node
+      }
+      const target = table.nodeAt(offset);
+      if (!target) {
+        continue;
+      }
+      const span = target.attrs.colspan as number;
+      const insideRect = col >= rect.left && col + span <= rect.right;
+      const source = insideRect ? gridRow[srcIdx % gridW] : null;
+      if (insideRect && source) {
+        cells.push(target.type.create(target.attrs, source.content));
+        srcIdx += 1;
+      } else {
+        cells.push(target);
+      }
+    }
+    newRows.push(rowNode.copy(Fragment.fromArray(cells)));
+  }
+
+  let replacedSize = 0;
+  for (let row = rect.top; row < rect.bottom; row += 1) {
+    replacedSize += table.child(row).nodeSize;
+  }
+  const from = tableStart + rowStartOffset(table, rect.top);
+
+  const tr = state.tr;
+  tr.replace(from, from + replacedSize, new Slice(Fragment.fromArray(newRows), 0, 0));
+
+  // Restore the rectangle selection in the new document. Content sizes
+  // changed, so old positions are useless here: the structure (rows, spans)
+  // did not change, so the same rect indexes address the same cells in the
+  // new table. cellsInRect skips span continuations — its ends are the
+  // visible corner cells.
+  const newTable = tr.doc.nodeAt(tableStart - 1);
+  if (!newTable) {
+    dispatch(tr);
+    return;
+  }
+  const rectCells = TableMap.get(newTable).cellsInRect(rect);
+  const selection = new TextoCellSelection(
+    tr.doc.resolve(tableStart + rectCells[0]),
+    tr.doc.resolve(tableStart + rectCells[rectCells.length - 1]),
+  );
+  tr.setSelection(selection).scrollIntoView();
+  dispatch(tr);
+}
+
+/** Insert the copied rows as new rows after the caret row, aligned to the
+ *  target column count (extra source columns dropped, missing ones become
+ *  empty cells). Columns continuing a rowspan from above are no place for a
+ *  new cell: the crossing merges extend by the number of inserted rows and
+ *  the new rows carry cells at the free columns only — the same convention
+ *  as prosemirror-tables' own addRow. Cell types mirror the caret row. */
+function insertRowsAfterCaret(
+  state: EditorState,
+  dispatch: (tr: Transaction) => void,
+  grid: Array<Array<ProseMirrorNode>>,
+): boolean {
+  const $cell = selectionCell(state);
+  const table = $cell.node(-1);
+  const tableStart = $cell.start(-1);
+  const map = TableMap.get(table);
+  const targetWidth = map.width;
+  const cursorRect = map.findCell($cell.pos - tableStart);
+  const insertAfterRow = cursorRect.bottom; // the row below the caret row
+  const fallbackType = tableNodeTypes(state.schema).cell;
+  // Column type reference: the caret row's cell at the same column.
+  const typeAt = (col: number): ProseMirrorNode["type"] => {
+    if (insertAfterRow > 0) {
+      const node = table.nodeAt(map.map[(insertAfterRow - 1) * targetWidth + col]);
+      if (node) {
+        return node.type;
+      }
+    }
+    return fallbackType;
+  };
+  // Free columns of the insertion point vs columns continuing a rowspan.
+  const covered = new Set<number>(); // cell offsets in table content coords
+  const freeCols: number[] = [];
+  if (insertAfterRow < map.height) {
+    for (let col = 0; col < targetWidth; col += 1) {
+      const index = insertAfterRow * targetWidth + col;
+      if (map.map[index] === map.map[index - targetWidth]) {
+        covered.add(map.map[index]);
+      } else {
+        freeCols.push(col);
+      }
+    }
+  } else {
+    for (let col = 0; col < targetWidth; col += 1) {
+      freeCols.push(col);
+    }
+  }
+
+  const newRows: Array<ProseMirrorNode> = [];
+  for (const sourceRow of grid) {
+    if (!sourceRow.length) {
+      return false;
+    }
+    const cells: Array<ProseMirrorNode> = [];
+    let srcIdx = 0;
+    let i = 0;
+    while (i < freeCols.length) {
+      const col = freeCols[i];
+      // A pasted cell cannot span across a column covered by a merge.
+      let run = 1;
+      while (i + run < freeCols.length && freeCols[i + run] === col + run) {
+        run += 1;
+      }
+      if (srcIdx < sourceRow.length) {
+        const sourceCell = sourceRow[srcIdx];
+        const span = Math.min(sourceCell.attrs.colspan as number, run);
+        cells.push(typeAt(col).create(insertedCellAttrs(sourceCell, span), sourceCell.content));
+        srcIdx += 1;
+        i += span;
+      } else {
+        // Source columns exhausted — the rest are empty cells (owner
+        // decision); the source grid never recycles here.
+        const empty = typeAt(col).createAndFill();
+        if (!empty) {
+          return false;
+        }
+        cells.push(empty);
+        i += 1;
+      }
+    }
+    newRows.push(state.schema.nodes.tableRow.createChecked(null, cells));
+  }
+
+  const tr = state.tr;
+  // Extend the vertical merges crossing the insertion point.
+  for (const offset of covered) {
+    const node = table.nodeAt(offset);
+    if (!node) {
+      continue;
+    }
+    tr.setNodeMarkup(tableStart + offset, null, {
+      ...node.attrs,
+      rowspan: ((node.attrs.rowspan as number) || 1) + grid.length,
+    });
+  }
+  const pos = tableStart + rowStartOffset(table, insertAfterRow);
+  tr.insert(pos, Fragment.fromArray(newRows));
+  tr.setSelection(TextSelection.near(tr.doc.resolve(tr.mapping.map(pos + 1))));
+  tr.scrollIntoView();
+  dispatch(tr);
+  return true;
+}
+
+/** Paste a copied column at a caret: a new column is inserted right of the
+ *  caret's column (the addColumn conventions — merges crossing it extend)
+ *  and filled with the copied cells row by row, table top down. Rows below
+ *  the copied grid stay empty; extra copied rows are dropped. */
+function insertColumnAfterCaret(
+  state: EditorState,
+  dispatch: (tr: Transaction) => void,
+  grid: Array<Array<ProseMirrorNode>>,
+): boolean {
+  const $cell = selectionCell(state);
+  const table = $cell.node(-1);
+  const tableStart = $cell.start(-1);
+  const map = TableMap.get(table);
+  const cursorRect = map.findCell($cell.pos - tableStart);
+  const insertAt = cursorRect.right; // 0-based index of the new column
+
+  const tr = state.tr;
+  // addColumn's JS implementation only destructures {map, tableStart, table}
+  // — the TableRect type demands the rect fields the code never reads.
+  addColumn(tr, { map, tableStart, table } as unknown as TableRect, insertAt);
+
+  // Fill the new column's cells with the copied contents. Every position is
+  // computed against the post-addColumn document; the fills run bottom-up so
+  // an earlier (upper) position stays valid after a lower edit. addColumn
+  // creates plain body cells at the right edge — the header row gets a
+  // header cell instead (the row's own type wins).
+  const filled = tr.doc.nodeAt(tableStart - 1);
+  if (!filled) {
+    return false;
+  }
+  const filledMap = TableMap.get(filled);
+  const rowsToFill = Math.min(filledMap.height, grid.length);
+  for (let row = rowsToFill - 1; row >= 0; row -= 1) {
+    const index = row * filledMap.width + insertAt;
+    // A slot covered by a rowspan from above belongs to the extended merge
+    // — it has no own cell to fill; filling it would clobber the merge.
+    if (row > 0 && filledMap.map[index] === filledMap.map[index - filledMap.width]) {
+      continue;
+    }
+    const cellPos = tableStart + filledMap.map[index];
+    const target = tr.doc.nodeAt(cellPos);
+    const rowType = filled.child(row).child(0)?.type ?? target?.type;
+    const source = grid[row][0];
+    if (!target || !rowType || !source) {
+      continue;
+    }
+    const newCell = rowType.create(target.attrs, source.content);
+    tr.replace(cellPos, cellPos + target.nodeSize, new Slice(Fragment.from(newCell), 0, 0));
+  }
+
+  // Caret into the new column at the caret row (recomputed — the fills
+  // shifted the lower rows).
+  const finalTable = tr.doc.nodeAt(tableStart - 1);
+  if (finalTable) {
+    const finalMap = TableMap.get(finalTable);
+    const caretRow = Math.min(cursorRect.top, finalMap.height - 1);
+    const selOffset = finalMap.map[caretRow * finalMap.width + insertAt];
+    tr.setSelection(TextSelection.near(tr.doc.resolve(tableStart + selOffset + 1)));
+  }
+  tr.scrollIntoView();
+  dispatch(tr);
+  return true;
+}
+
+/** Paste handling for table fragments (owner semantics above). Returns false
+ *  for non-table content so the default paste path takes over. */
+function handleCellPaste(view: EditorView, slice: Slice): boolean {
+  const { state } = view;
+  const grid = extractCellGrid(slice);
+  if (!grid) {
+    return false;
+  }
+  const dispatch = view.dispatch.bind(view);
+  const { selection } = state;
+  if (selection instanceof CellSelection) {
+    replaceRectWithGrid(state, dispatch, selectedRect(state), grid);
+    return true;
+  }
+  if (!isInTable(state)) {
+    return false;
+  }
+  // A single-cell-wide, multi-row copy is a column (Excel semantics):
+  // pasting it at a caret inserts a new column, it does not insert rows.
+  if (grid.length > 1 && grid.every((sourceRow) => sourceRow.length === 1)) {
+    return insertColumnAfterCaret(state, dispatch, grid);
+  }
+  // Excel: a single copied cell pasted at a caret replaces the caret cell's
+  // content (target attributes preserved), it does not insert a row.
+  if (grid.length === 1 && grid[0].length === 1) {
+    const $cell = selectionCell(state);
+    const table = $cell.node(-1);
+    const tableStart = $cell.start(-1);
+    const map = TableMap.get(table);
+    const cellOffset = $cell.pos - tableStart;
+    const cellPos = tableStart + map.map[map.findCell(cellOffset).top * map.width + map.colCount(cellOffset)];
+    const target = state.doc.nodeAt(cellPos);
+    if (!target) {
+      return false;
+    }
+    const tr = state.tr;
+    tr.replace(
+      tr.mapping.map(cellPos + 1),
+      tr.mapping.map(cellPos + target.nodeSize - 1),
+      new Slice(grid[0][0].content, 0, 0),
+    );
+    tr.setSelection(TextSelection.near(tr.doc.resolve(tr.mapping.map(cellPos + 1))));
+    tr.scrollIntoView();
+    dispatch(tr);
+    return true;
+  }
+  return insertRowsAfterCaret(state, dispatch, grid);
+}
+
+/**
+ * Cmd+X for a cell selection: the copied block goes to the system clipboard,
+ * then Excel semantics — full rows are removed, a partial rectangle only
+ * clears cell contents. Returns false outside a cell selection (normal cut).
+ */
+export function cutCellSelection(view: EditorView): boolean {
+  const { state } = view;
+  const { selection } = state;
+  // Every CellSelection gets the Excel treatment, including a 1×1 one
+  // (copy + clear). Do NOT use CellSelection.empty here: from/to bound the
+  // head cell's content range, so `empty` is true for any rect whose head
+  // cell happens to be empty.
+  if (!(selection instanceof CellSelection) || !isInTable(state)) {
+    return false;
+  }
+
+  const content = selection.content();
+  const { dom, text } = view.serializeForClipboard(content);
+  // The delete happens only after the clipboard write CONFIRMED: a denied
+  // clipboard must not remove content the user believes is copied.
+  void copyToSystemClipboard(dom.innerHTML, text).then((ok) => {
+    if (!ok) {
+      return;
+    }
+    const rect = selectedRect(view.state);
+    const fullRows = rect.left === 0 && rect.right === rect.map.width;
+    if (fullRows) {
+      // deleteRow refuses to remove every row of a table; cutting all rows
+      // removes the table itself — an empty table is not a valid document
+      // node (mirrors deleteTableWhenAllCellsSelected for Backspace).
+      const wholeTable = rect.top === 0 && rect.bottom === rect.map.height;
+      (wholeTable ? deleteTable : deleteRow)(view.state, view.dispatch.bind(view));
+    } else {
+      view.dispatch(view.state.tr.deleteSelection().scrollIntoView());
+    }
+  });
+  return true;
+}
+
+/** The clipboard scope of a cell-level copy/cut/paste: a cell selection, or
+ *  — when the caret stands in a cell — that single cell (1×1). The toolbar
+ *  buttons work in both cases; on desktop the caret in a cell is the only
+ *  single-cell affordance once the circle is gone. */
+function clipboardSlice(view: EditorView): { slice: Slice; caretCellPos: number | null } | null {
+  const { state } = view;
+  const { selection } = state;
+  if (selection instanceof CellSelection) {
+    if (!isInTable(state)) return null;
+    return { slice: selection.content(), caretCellPos: null };
+  }
+  if (!isInTable(state)) return null;
+  const $cell = selectionCell(state);
+  const table = $cell.node(-1);
+  const tableStart = $cell.start(-1);
+  const map = TableMap.get(table);
+  const cellOffset = $cell.pos - tableStart;
+  const cellPos = tableStart + map.map[map.findCell(cellOffset).top * map.width + map.colCount(cellOffset)];
+  const cell = state.doc.nodeAt(cellPos);
+  if (!cell) return null;
+  return { slice: new Slice(Fragment.from(cell), 1, 1), caretCellPos: cellPos };
+}
+
+/** Copy for the toolbar buttons: a cell selection or the caret cell (1×1)
+ *  goes to the system clipboard as a table. Returns false when the state
+ *  offers no cell scope. */
+export function copyTableSelection(view: EditorView): boolean {
+  const scope = clipboardSlice(view);
+  if (!scope) {
+    return false;
+  }
+  const { dom, text } = view.serializeForClipboard(scope.slice);
+  void copyToSystemClipboard(dom.innerHTML, text);
+  return true;
+}
+
+/** Cut for the toolbar buttons: copy (above), then Excel semantics for a
+ *  cell selection; a bare caret cell only has its content cleared. The
+ *  removal happens only after the clipboard write CONFIRMED — a failed
+ *  clipboard must not destroy content the user believes is copied. */
+export async function cutTableSelection(view: EditorView): Promise<boolean> {
+  const { state } = view;
+  const scope = clipboardSlice(view);
+  if (!scope) {
+    return false;
+  }
+  const { dom, text } = view.serializeForClipboard(scope.slice);
+  const written = await copyToSystemClipboard(dom.innerHTML, text);
+  if (!written) {
+    return false;
+  }
+  const dispatch = view.dispatch.bind(view);
+  const { selection } = state;
+  if (selection instanceof CellSelection) {
+    const rect = selectedRect(state);
+    const fullRows = rect.left === 0 && rect.right === rect.map.width;
+    if (fullRows) {
+      const wholeTable = rect.top === 0 && rect.bottom === rect.map.height;
+      (wholeTable ? deleteTable : deleteRow)(state, dispatch);
+    } else {
+      view.dispatch(state.tr.deleteSelection().scrollIntoView());
+    }
+    return true;
+  }
+  const cellPos = scope.caretCellPos;
+  if (cellPos == null) {
+    return false;
+  }
+  const cell = state.doc.nodeAt(cellPos);
+  if (!cell) {
+    return false;
+  }
+  const tr = state.tr;
+  tr.replace(cellPos + 1, cellPos + cell.nodeSize - 1, Slice.empty);
+  view.dispatch(tr.scrollIntoView());
+  return true;
+}
+
+/** Paste for the toolbar buttons: read the system clipboard and feed it
+ *  through the editor's own paste pipeline (a synthetic paste event — the
+ *  same event the system paste dispatches). Degrades to plain text when the
+ *  rich read is unavailable. Must run inside the click's user gesture. */
+export async function pasteFromSystemClipboard(view: EditorView): Promise<boolean> {
+  let html: string | null = null;
+  let text: string | null = null;
+  try {
+    if (navigator.clipboard?.read) {
+      const items = await navigator.clipboard.read();
+      for (const item of items) {
+        if (html == null && item.types.includes("text/html")) {
+          html = await (await item.getType("text/html")).text();
+        }
+        if (text == null && item.types.includes("text/plain")) {
+          text = await (await item.getType("text/plain")).text();
+        }
+      }
+    }
+  } catch {
+    // rich read denied/unavailable — fall through to plain text
+  }
+  if (html == null && text == null) {
+    try {
+      text = await navigator.clipboard.readText();
+    } catch {
+      return false;
+    }
+  }
+  const dt = new DataTransfer();
+  if (html != null) dt.setData("text/html", html);
+  if (text != null) dt.setData("text/plain", text);
+  view.focus();
+  view.dom.dispatchEvent(
+    new ClipboardEvent("paste", { clipboardData: dt, bubbles: true, cancelable: true }),
+  );
+  return true;
+}
+
+/** Write the payload to the system clipboard; true when any write landed.
+ *  Cut flows gate their removal on this — a failed copy must not destroy
+ *  content. */
+async function copyToSystemClipboard(html: string, text: string): Promise<boolean> {
+  try {
+    if (typeof ClipboardItem !== "undefined" && navigator.clipboard?.write) {
+      await navigator.clipboard.write([
+        new ClipboardItem({
+          "text/html": new Blob([html], { type: "text/html" }),
+          "text/plain": new Blob([text], { type: "text/plain" }),
+        }),
+      ]);
+      return true;
+    }
+  } catch {
+    // fall through to the plain-text path
+  }
+  try {
+    await navigator.clipboard.writeText(text);
+    return true;
+  } catch {
+    // no clipboard access — nothing was written
+    return false;
+  }
+}
+
+export function cellClipboardPlugin(): Plugin {
+  return new Plugin({
+    props: {
+      // Registered before tableEditing: returning false falls through to its
+      // handlePaste and then to the default paste handling.
+      handlePaste: (view, _event, slice) => {
+        if (!isInTable(view.state)) {
+          return false;
+        }
+        return handleCellPaste(view, slice);
+      },
+    },
+  });
+}
diff --git a/src/texto/extensions/table/helpers/cellColorAttrs.test.ts b/src/texto/extensions/table/helpers/cellColorAttrs.test.ts
new file mode 100644
index 0000000..4569c3c
--- /dev/null
+++ b/src/texto/extensions/table/helpers/cellColorAttrs.test.ts
@@ -0,0 +1,68 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  hasCellColorAttrQuirk,
+  normalizeCellColorAttrsJSON,
+} from "./cellColorAttrs";
+
+type Json = Record<string, unknown>;
+
+const cell = (attrs: Json, text = "x"): Json => ({
+  type: "tableCell",
+  attrs,
+  content: [{ type: "paragraph", content: [{ type: "text", text }] }],
+});
+
+const doc = (cells: Json[]): Json => ({
+  type: "noteDoc",
+  content: [
+    {
+      type: "table",
+      content: cells.map((c) => ({ type: "tableRow", content: [c] })),
+    },
+  ],
+});
+
+describe("hasCellColorAttrQuirk", () => {
+  it("detects the clipboard-parse array in dataColor", () => {
+    expect(hasCellColorAttrQuirk(doc([cell({ dataColor: [] })]))).toBe(true);
+  });
+
+  it("detects a non-string backgroundColor", () => {
+    expect(hasCellColorAttrQuirk(doc([cell({ backgroundColor: 5 })]))).toBe(true);
+  });
+
+  it("accepts strings, null and absent attrs", () => {
+    expect(
+      hasCellColorAttrQuirk(
+        doc([cell({ dataColor: "#ff0000", backgroundColor: null })]),
+      ),
+    ).toBe(false);
+    expect(hasCellColorAttrQuirk(doc([cell({})]))).toBe(false);
+  });
+});
+
+describe("normalizeCellColorAttrsJSON", () => {
+  it("nulls the broken attrs and keeps well-formed colors", () => {
+    const document = doc([
+      cell({ dataColor: [], backgroundColor: "#00ff00", colwidth: [50] }),
+      cell({ dataColor: "#112233" }),
+    ]);
+    normalizeCellColorAttrsJSON(document as never);
+    // doc() gives every cell its own row
+    const rows = (((document.content as Json[])[0].content ?? []) as Json[]);
+    const cellAt = (row: number) =>
+      (((rows[row].content ?? []) as Json[])[0].attrs ?? {}) as Json;
+    expect(cellAt(0).dataColor).toBeNull();
+    expect(cellAt(0).backgroundColor).toBe("#00ff00");
+    expect(cellAt(0).colwidth).toEqual([50]);
+    expect(cellAt(1).dataColor).toBe("#112233");
+  });
+
+  it("leaves documents without the quirk untouched (in place, no throw)", () => {
+    const document = doc([cell({ dataColor: "#112233" })]);
+    expect(() => normalizeCellColorAttrsJSON(document as never)).not.toThrow();
+    const table = (document.content as Json[])[0];
+    expect(Array.isArray(table.content)).toBe(true);
+  });
+});
diff --git a/src/texto/extensions/table/helpers/cellColorAttrs.ts b/src/texto/extensions/table/helpers/cellColorAttrs.ts
new file mode 100644
index 0000000..e666eff
--- /dev/null
+++ b/src/texto/extensions/table/helpers/cellColorAttrs.ts
@@ -0,0 +1,63 @@
+/**
+ * Read-time repair for table cell color attributes (JSON level, same layer
+ * as ensureCellTrailingParagraphJSON).
+ *
+ * tableCell/tableHeader parseHTML used to emit `dataColor: []` (an array)
+ * for every cell parsed from clipboard HTML. Cells inserted from a paste
+ * carried that array into saved documents, and the color rendering
+ * (safeColorValue → .trim) crashed the editor on the next open of the note.
+ * The render side now guards on the type (safeColorValue, renderHTML), and
+ * this repair strips the broken values from already-saved files on read —
+ * the next autosave persists the normalized document.
+ */
+
+type JsonNode = { type?: string; attrs?: Record<string, unknown>; content?: JsonNode[] };
+
+const CELL_TYPES = new Set(["tableCell", "tableHeader"]);
+
+function colorAttrIsBroken(value: unknown): boolean {
+  return value != null && typeof value !== "string";
+}
+
+/** True when any table cell carries a non-string color attr — the quirk
+ *  `normalizeCellColorAttrsJSON` repairs. Pure check for callers that need
+ *  to know whether the repair changed anything (the repair mutates in
+ *  place), mirroring hasCellTrailingImage. */
+export function hasCellColorAttrQuirk(doc: JsonNode | null): boolean {
+  if (doc == null) return false;
+  const content = doc.content;
+  if (!Array.isArray(content)) return false;
+  if (CELL_TYPES.has(doc.type ?? "")) {
+    const attrs = doc.attrs;
+    if (attrs != null && (colorAttrIsBroken(attrs.dataColor) || colorAttrIsBroken(attrs.backgroundColor))) {
+      return true;
+    }
+  }
+  for (const child of content) {
+    if (child != null && hasCellColorAttrQuirk(child)) return true;
+  }
+  return false;
+}
+
+/** Normalize cell color attrs in place: a non-string dataColor or
+ *  backgroundColor becomes null. Well-formed strings are kept untouched —
+ *  render-side sanitization (safeColorValue) stays the authority on what
+ *  may reach an inline style. */
+export function normalizeCellColorAttrsJSON<T extends JsonNode>(doc: T): void {
+  const walk = (node: JsonNode): void => {
+    if (CELL_TYPES.has(node.type ?? "") && node.attrs != null) {
+      if (colorAttrIsBroken(node.attrs.dataColor)) {
+        node.attrs.dataColor = null;
+      }
+      if (colorAttrIsBroken(node.attrs.backgroundColor)) {
+        node.attrs.backgroundColor = null;
+      }
+    }
+    if (Array.isArray(node.content)) {
+      for (const child of node.content) {
+        if (child != null) walk(child);
+      }
+    }
+  };
+  if (doc != null) walk(doc);
+}
diff --git a/src/texto/extensions/table/helpers/cellDragFreeze.ts b/src/texto/extensions/table/helpers/cellDragFreeze.ts
index 591d8da..8020b0e 100644
--- a/src/texto/extensions/table/helpers/cellDragFreeze.ts
+++ b/src/texto/extensions/table/helpers/cellDragFreeze.ts
@@ -1,18 +1,3 @@
-import type { EditorState } from "prosemirror-state";
-import type { Decoration } from "prosemirror-view";
-
-import { buildSelectionOverlayDecoration, overlayTableKey } from "./overlay";
-
-// The last overlay decoration handed out by overlayForDraw.
-let lastOverlay: Decoration | null = null;
-
-// The table node the last overlay belongs to (compared by identity). A frozen
-// overlay is only reused while the selection stays within the same table — a
-// long-press may start in a different table than the one the caret was in, and
-// the overlay element must live inside that table's DOM for absolute
-// positioning to work.
-let lastOverlayTableKey: object | null = null;
-
 let dragActive = false;
 
 /**
@@ -80,34 +65,6 @@ export function consumeTouchCompatMouse(): void {
   touchCompatSuppressUntil = Date.now() + TOUCH_COMPAT_GRACE_MS;
 }
 
-/**
- * The overlay decoration for the current draw.
- *
- * Why the freeze: during a drag the selection changes on every touchmove, and
- * without this trick ProseMirror would recreate the widget decoration and the
- * circle DOM node (the touch target). Removing the touch target in the middle
- * of a touch makes the browser cancel the gesture (touchcancel) — the smooth
- * drag died after its first move. By returning the frozen (same) instance the
- * circle DOM node stays alive for the whole gesture; its position is updated
- * in place by refreshOverlayPosition.
- *
- * The frozen instance is only reused while the selection stays within the
- * same table (see lastOverlayTableKey); otherwise a fresh overlay is built.
- */
-export function overlayForDraw(state: EditorState): Decoration | null {
-  if (
-    dragActive &&
-    lastOverlay &&
-    lastOverlayTableKey === overlayTableKey(state)
-  ) {
-    return lastOverlay;
-  }
-
-  lastOverlay = buildSelectionOverlayDecoration(state);
-  lastOverlayTableKey = overlayTableKey(state);
-  return lastOverlay;
-}
-
 /**
  * Hook for cancelling a pending (not yet activated) long-press cell gesture.
  *
diff --git a/src/texto/extensions/table/helpers/handleCellSelection.ts b/src/texto/extensions/table/helpers/handleCellSelection.ts
index 61f1de1..79cec74 100644
--- a/src/texto/extensions/table/helpers/handleCellSelection.ts
+++ b/src/texto/extensions/table/helpers/handleCellSelection.ts
@@ -1,3 +1,4 @@
+import type { ResolvedPos } from "prosemirror-model";
 import { EditorState, Plugin } from "prosemirror-state";
 import {
   cellAround,
@@ -18,13 +19,14 @@ import {
   isCellDragActive,
   isTouchCompatMouseSuppressed,
   consumeTouchCompatMouse,
-  overlayForDraw,
 } from "./cellDragFreeze";
-import { handleMouseDown } from "./handleMouseDown";
+import { cellAtPoint, handleMouseDown } from "./handleMouseDown";
 import {
   handlePointerDown,
   handleTouchMoveDuringDrag,
   handleTouchStart,
+  LONG_PRESS_MS,
+  LONG_PRESS_SLOP,
 } from "./handleTouchStart";
 import { TextoCellSelection } from "./TextoCellSelection";
 
@@ -88,18 +90,21 @@ export function drawCellSelection(
   state: EditorState,
   isMobileView: boolean,
 ): DecorationSource | null {
-  // While a drag is active, overlayForDraw returns the SAME instance as in
-  // the previous frame — ProseMirror reuses the circle's DOM node, so the
-  // touch target is not removed (otherwise the browser cancels the gesture,
-  // see cellDragFreeze.ts).
-  const overlay = overlayForDraw(state);
-  const decorations: Decoration[] = overlay ? [overlay] : [];
-
-  // Mobile view: a column resize handle next to the current cell (the cell
-  // under the cursor or the head cell of the selection). During a selection
-  // drag the handles are not needed and recreating them repaints the table
-  // subtree, removing the circle (the touch target) — so they are skipped.
-  if (isMobileView && !isCellDragActive()) {
+  // The selection circle is gone on BOTH platforms (issue
+  // table-selection-native-drag): desktop selects with the native mouse
+  // drag, mobile with the long-press drag — the picked-cell highlight of
+  // that gesture is its own direct-DOM rectangle (handleTouchStart.ts), and
+  // the selected cells are highlighted by tableEditing's .selectedCell
+  // decorations. Mobile keeps the column resize handles.
+  if (!isMobileView) {
+    return null;
+  }
+
+  const decorations: Decoration[] = [];
+
+  // During a selection drag the handles are not needed: recreating them
+  // repaints the table subtree mid-gesture.
+  if (!isCellDragActive()) {
     const { selection } = state;
     const cellPos =
       selection instanceof CellSelection
@@ -152,6 +157,15 @@ export function handleCellSelection(isMobileView: boolean) {
               document.body.classList.add("texto-table__cell-dragging");
             }
           });
+          // Desktop: native selection — a click places the caret, an
+          // immediate drag builds the cell rectangle (prosemirror-tables'
+          // own handler), and holding the button still selects the cell
+          // under it (the mouse long-press, the desktop twin of the mobile
+          // long-press).
+          if (!isMobileView) {
+            startDesktopLongPress(view, event);
+            return false;
+          }
           return handleMouseDown(view, event);
         },
         // Swallow the synthetic compatibility mouse events (mouseup/click)
@@ -253,3 +267,83 @@ export function handleCellSelection(isMobileView: boolean) {
     },
   });
 }
+
+/**
+ * Desktop long-press (issue table-selection-native-drag): holding the mouse
+ * button still on a cell for a moment selects that cell — the mouse twin of
+ * the mobile long-press, and the only single-cell affordance once the
+ * circle is gone. A plain click (release before the timer, or moving out of
+ * the slop) stays untouched: the caret was already placed by the default
+ * mousedown handling and an immediate drag builds the rectangle natively.
+ *
+ * While the selection is active, moving extends the rectangle and the
+ * moves are preventDefault-ed so the native text-selection drag does not
+ * fight the dispatched cell selection.
+ */
+function startDesktopLongPress(view: EditorView, startEvent: MouseEvent): void {
+  const startX = startEvent.clientX;
+  const startY = startEvent.clientY;
+  const doc = view.dom.ownerDocument;
+  let timer = 0;
+  let active = false;
+  let anchor: ResolvedPos | null = null;
+
+  const stop = (): void => {
+    doc.removeEventListener("mousemove", onMove);
+    doc.removeEventListener("mouseup", onUp);
+    window.clearTimeout(timer);
+    if (active && !view.isDestroyed && view.state.selection instanceof TextoCellSelection) {
+      view.focus();
+    }
+  };
+
+  const dispatchSelection = ($head: ResolvedPos): void => {
+    if (!anchor || $head.pos === anchor.pos) {
+      return;
+    }
+    // NO tableEditingKey meta here: prosemirror-tables' own mouse-drag
+    // tracking is still active (our mousedown did not preventDefault) and
+    // reads that state as a numeric anchor — a selection object in it
+    // crashes its move handler. The two dispatches agree on the rectangle.
+    view.dispatch(view.state.tr.setSelection(new TextoCellSelection(anchor, $head)));
+  };
+
+  const onMove = (event: MouseEvent): void => {
+    const dx = event.clientX - startX;
+    const dy = event.clientY - startY;
+    if (!active) {
+      // Moved out of the slop before the timer: an ordinary drag — the
+      // native rectangle selection handles it, the long-press is off.
+      if (dx * dx + dy * dy > LONG_PRESS_SLOP * LONG_PRESS_SLOP) {
+        stop();
+      }
+      return;
+    }
+    event.preventDefault();
+    const $head = cellAtPoint(view, event.clientX, event.clientY);
+    // The rectangle must not cross a table boundary: a head from another
+    // table would build a selection with endpoints in different tables.
+    if (!$head || !anchor || $head.node(-1) !== anchor.node(-1)) {
+      return;
+    }
+    dispatchSelection($head);
+  };
+
+  const onUp = (): void => {
+    stop();
+  };
+
+  timer = window.setTimeout(() => {
+    active = true;
+    const $cell = cellAtPoint(view, startX, startY);
+    if (!$cell) {
+      stop();
+      return;
+    }
+    anchor = $cell;
+    view.dispatch(view.state.tr.setSelection(new TextoCellSelection($cell)));
+  }, LONG_PRESS_MS);
+
+  doc.addEventListener("mousemove", onMove);
+  doc.addEventListener("mouseup", onUp);
+}
diff --git a/src/texto/extensions/table/helpers/handleMouseDown.ts b/src/texto/extensions/table/helpers/handleMouseDown.ts
index 28a6d7d..e15cf8b 100644
--- a/src/texto/extensions/table/helpers/handleMouseDown.ts
+++ b/src/texto/extensions/table/helpers/handleMouseDown.ts
@@ -1,15 +1,13 @@
-import type { ResolvedPos } from "prosemirror-model";
 import type { EditorView } from "prosemirror-view";
-import { tableEditingKey, TableMap } from "prosemirror-tables";
+import { tableEditingKey } from "prosemirror-tables";
+import type { ResolvedPos } from "prosemirror-model";
 
 import {
-  beginCellDrag,
   cancelPendingCellGesture,
   consumeTouchCompatMouse,
   endCellDrag,
   isTouchCompatMouseSuppressed,
 } from "./cellDragFreeze";
-import { scheduleOverlayRefresh } from "./overlay";
 import { TextoCellSelection } from "./TextoCellSelection";
 
 /**
@@ -21,60 +19,29 @@ import { TextoCellSelection } from "./TextoCellSelection";
  *
  * On narrow columns (phone) a fixed shift can throw the point outside the
  * cell, so the point is taken with a progressively decreasing shift — until
- * the first hit inside a cell (see cellAtPoint).
+ * the first hit inside a cell (see the CLEARANCE_STEPS loop).
  */
-const CIRCLE_CLEARANCE = 18;
-
-/** Fractions of the clearance tried in cellAtPoint. */
-const CLEARANCE_STEPS = [1, 0.66, 0.33, 0] as const;
-
-/**
- * The cell containing the position (including the cell level itself).
- *
- * Unlike cellAround from prosemirror-tables, which starts walking up from
- * depth − 1, this also takes the cell level itself into account: posAtCoords
- * may return a position exactly on the border of the cell content — for
- * example, the position of the resize-handle widget (on the phone the handles
- * overlap parts of the cells).
- */
-function cellContaining($pos: ResolvedPos): ResolvedPos | null {
-  for (let depth = $pos.depth; depth > 0; depth -= 1) {
-    // .spec is untyped (any) in prosemirror-model — cast explicitly.
-    const role = $pos.node(depth).type.spec.tableRole as string | undefined;
-    if (role === "cell" || role === "header_cell") {
-      return $pos.doc.resolve($pos.before(depth));
-    }
-  }
-  return null;
-}
+const CELL_AT_POINT_STEPS = [1, 0.66, 0.33, 0] as const;
 
 /**
  * Finds the cell under the given screen point.
  *
- * `offset` shifts the point up-left: used on the first move of a drag,
- * when the pointer stands on the selection circle (in the corner of a cell)
- * and must be moved inside the anchor cell. If the full shift throws the
- * point outside the cell (narrow column on the phone), the shift decreases
- * step by step.
+ * `offset` shifts the point up-left. On the mobile long-press drag the
+ * first move stands where the finger landed — no shift is needed there, but
+ * the parameter is kept for callers that resolve a point on a gesture
+ * overlay.
  */
 export function cellAtPoint(
   view: EditorView,
   clientX: number,
   clientY: number,
   offset = 0,
-) {
-  for (const step of CLEARANCE_STEPS) {
+): ResolvedPos | null {
+  for (const step of CELL_AT_POINT_STEPS) {
     const shift = Math.round(offset * step);
     const x = clientX - shift;
     const y = clientY - shift;
 
-    // Points on the selection overlay (the circle and its enlarged touch
-    // zone) are not resolved: posAtCoords would return the widget position,
-    // which collapses head into the anchor cell and blocks the growth of
-    // the selection rect.
-    const hit = view.dom.ownerDocument.elementFromPoint(x, y);
-    if (hit?.closest(".texto-table__overlay")) continue;
-
     const pos = view.posAtCoords({ left: x, top: y });
     if (!pos) continue;
 
@@ -88,82 +55,11 @@ export function cellAtPoint(
 
     // posAtCoords usually points inside the paragraph text or on the border
     // of the cell content — walk up the hierarchy to the cell.
-    const around = cellContaining($pos);
-    if (around) return around;
-  }
-  return null;
-}
-
-/**
- * The cell of the anchor cell's table whose rect contains the point.
- *
- * The rect-based DOM lookup does not use elementFromPoint, so it works even
- * when workspace-drawer-backdrop (the mobile drawer backdrop of Obsidian)
- * intercepts hit-testing and posAtCoords degrades. Used as a fallback for
- * the head cell during drag selection.
- */
-export function cellInTableAtPoint(
-  view: EditorView,
-  anchorCellPos: number,
-  clientX: number,
-  clientY: number,
-): ResolvedPos | null {
-  const $anchor = view.state.doc.resolve(anchorCellPos);
-  const table = $anchor.node(-1);
-  if (table?.type.spec.tableRole !== "table") {
-    return null;
-  }
-
-  const start = $anchor.start(-1);
-  const map = TableMap.get(table);
-
-  for (let row = 0; row < map.height; row += 1) {
-    for (let col = 0; col < map.width; col += 1) {
-      const index = row * map.width + col;
-      // Skip a cell stretched from the previous row (rowspan).
-      if (row > 0 && map.map[index] === map.map[index - map.width]) {
-        continue;
-      }
-
-      const cellOffset = map.map[index];
-      const node = table.nodeAt(cellOffset);
-      if (
-        !node ||
-        (node.type.name !== "tableCell" && node.type.name !== "tableHeader")
-      ) {
-        continue;
-      }
-
-      const cellPos = start + cellOffset;
-      // Take the DOM of the cell itself (td/th), not of its first child
-      // paragraph: its rect is smaller than the cell (does not account for
-      // the inner padding), so a point in the cell padding did not hit the
-      // rect and head was not updated — the selection did not grow toward
-      // the side where the finger hovered over the overlay and cellAtPoint
-      // fell back here. nodeDOM returns the whole cell node element, so its
-      // rect covers the entire cell.
-      const cellEl =
-        (view.nodeDOM(cellPos) as HTMLElement | null) ??
-        (() => {
-          const dom = view.domAtPos(cellPos);
-          return (
-            dom.node.nodeType === 1
-              ? dom.node.childNodes[dom.offset]
-              : dom.node.parentElement
-          ) as HTMLElement | null;
-        })();
-      if (!cellEl?.getBoundingClientRect) {
-        continue;
-      }
-
-      const rect = cellEl.getBoundingClientRect();
-      if (
-        clientX >= rect.left &&
-        clientX <= rect.right &&
-        clientY >= rect.top &&
-        clientY <= rect.bottom
-      ) {
-        return view.state.doc.resolve(cellPos);
+    for (let depth = $pos.depth; depth > 0; depth -= 1) {
+      // .spec is untyped (any) in prosemirror-model — cast explicitly.
+      const role = $pos.node(depth).type.spec.tableRole as string | undefined;
+      if (role === "cell" || role === "header_cell") {
+        return $pos.doc.resolve($pos.before(depth));
       }
     }
   }
@@ -171,21 +67,24 @@ export function cellInTableAtPoint(
 }
 
 /**
- * `mousedown` handler for table cell selection.
+ * The desktop/mobile compatibility-mousedown guard (issue
+ * table-selection-native-drag, ex circle selection).
  *
- * If the click hit the selection circle (`.texto-table__overlay_overlay-circle`),
- * starts a drag selection: mouse movement builds a `TextoCellSelection` from
- * the anchor cell to the cell under the cursor. Regular clicks inside cells
- * pass through (cursor placement / editing).
+ * After a touch cell drag Android dispatches synthetic mouse events; the
+ * mousedown would collapse the freshly built TextoCellSelection back to a
+ * text cursor, and a pending long-press can no longer be (the finger has
+ * lifted). This handler swallows that mousedown and ends the drag so the
+ * column-resize handles reappear.
+ *
+ * Everything else returns false: the native mouse handling takes over —
+ * a click places the caret, a drag builds the cell rectangle, holding
+ * still selects the cell (the desktop long-press lives in
+ * handleCellSelection.ts).
  */
 export function handleMouseDown(
   view: EditorView,
   startEvent: MouseEvent,
 ): boolean {
-  // The synthetic compatibility mousedown that Android dispatches right after
-  // a touch cell drag would collapse the freshly built TextoCellSelection
-  // back to a text cursor. Swallow it while the cell selection is still
-  // active and end the drag so the column-resize handles reappear.
   if (
     isTouchCompatMouseSuppressed() &&
     view.state.selection instanceof TextoCellSelection
@@ -202,83 +101,5 @@ export function handleMouseDown(
   // A mousedown proves the finger has lifted (compat mouse events are only
   // dispatched after the touch ends) — a pending long-press can no longer be.
   cancelPendingCellGesture();
-  const target = startEvent.target as HTMLElement;
-  // classList instead of an exact className match: Obsidian may add its own
-  // classes to the element (e.g. mobile-tap).
-  if (!target?.classList?.contains("texto-table__overlay_overlay-circle")) {
-    return false;
-  }
-
-  // Freeze the overlay decoration for the duration of the drag so the circle
-  // (touch/pointer target) is not recreated on every dispatch, which would
-  // cancel the gesture.
-  beginCellDrag();
-
-  // The anchor cell position is recorded by the decoration in the circle's
-  // data-cell-pos — this is more reliable than geometry: posAtCoords can
-  // degrade on mobile (workspace-drawer-backdrop).
-  let topLeftAnchor = Number(target.dataset.cellPos) || null;
-  let isFirstMove = true;
-
-  function setCellSelection($anchor: ResolvedPos | null, event: MouseEvent) {
-    if (!$anchor) return;
-
-    const $head =
-      cellAtPoint(
-        view,
-        event.clientX,
-        event.clientY,
-        isFirstMove ? CIRCLE_CLEARANCE : 0,
-      ) ??
-      // Without a recorded anchor the fallback cannot resolve a table —
-      // doc.resolve(null) would throw, so skip it instead.
-      (topLeftAnchor == null
-        ? null
-        : cellInTableAtPoint(
-            view,
-            topLeftAnchor,
-            event.clientX,
-            event.clientY,
-          ));
-    isFirstMove = false;
-    if (!$head) return;
-
-    if (topLeftAnchor == null) {
-      topLeftAnchor = $anchor.pos;
-    }
-
-    const selection = new TextoCellSelection($anchor, $head);
-    view.dispatch(
-      view.state.tr.setSelection(selection).setMeta(tableEditingKey, selection),
-    );
-    scheduleOverlayRefresh(view);
-  }
-
-  function stop() {
-    endCellDrag();
-    win.removeEventListener("mousemove", move);
-    win.removeEventListener("mouseup", stop);
-    if (tableEditingKey.getState(view.state) != null) {
-      view.dispatch(view.state.tr.setMeta(tableEditingKey, -1));
-    }
-  }
-
-  function move(event: MouseEvent) {
-    const $anchor =
-      topLeftAnchor != null
-        ? view.state.doc.resolve(topLeftAnchor)
-        : cellAtPoint(
-            view,
-            startEvent.clientX,
-            startEvent.clientY,
-            isFirstMove ? CIRCLE_CLEARANCE : 0,
-          );
-    setCellSelection($anchor, event);
-  }
-
-  const win = view.dom.ownerDocument.defaultView ?? window;
-  win.addEventListener("mousemove", move);
-  win.addEventListener("mouseup", stop);
-  startEvent.preventDefault();
-  return true;
+  return false;
 }
diff --git a/src/texto/extensions/table/helpers/handleTouchStart.ts b/src/texto/extensions/table/helpers/handleTouchStart.ts
index 897aa92..e6c4367 100644
--- a/src/texto/extensions/table/helpers/handleTouchStart.ts
+++ b/src/texto/extensions/table/helpers/handleTouchStart.ts
@@ -9,18 +9,13 @@ import {
   setPendingCellGestureCancel,
 } from "./cellDragFreeze";
 import { startColumnTouchResize } from "./columnTouchResize";
-import { cellAtPoint, cellInTableAtPoint } from "./handleMouseDown";
-import { scheduleOverlayRefresh } from "./overlay";
 import { TextoCellSelection } from "./TextoCellSelection";
 
-/** Clearance for the first move of a circle drag — see handleMouseDown.ts. */
-const CIRCLE_CLEARANCE = 18;
-
 /** How long a finger must rest on a cell before cell selection starts. */
-const LONG_PRESS_MS = 450;
+export const LONG_PRESS_MS = 450;
 
 /** Max finger movement (px) during the long-press that still counts as a press. */
-const LONG_PRESS_SLOP = 10;
+export const LONG_PRESS_SLOP = 10;
 
 /**
  * Body class added while a finger is down on a table cell. It disables
@@ -46,13 +41,13 @@ const PICKING_RECT_CLASS = "texto-table__cell-picking-rect";
 
 /**
  * Touch handler for tables on mobile (and touchscreens on desktop):
- * - touch on the selection circle (`.texto-table__overlay_overlay-circle`) —
- *   drag cell selection, the touch counterpart of the mouse gesture;
  * - touch on a resize handle (`.texto-table__resize-handle`) — column
  *   width drag-resize.
  *
- * Long-press on a table cell is handled separately in handlePointerDown:
- * see there for why it must run on Pointer Events instead of touch events.
+ * Cell selection is the long-press gesture (startLongPressCellSelection,
+ * below) — handled separately in handlePointerDown: see there for why it
+ * runs on Pointer Events instead of touch events. The old circle drag this
+ * file used to carry is gone (issue table-selection-native-drag).
  *
  * All other touches pass through (cursor placement / editing via compat
  * mouse events).
@@ -70,35 +65,6 @@ export function handleTouchStart(
     return startColumnTouchResize(view, startEvent, target);
   }
 
-  // The touch zone is the outer circle element, but the finger can land on
-  // the inner visual dot (.texto-table__overlay_circle) — resolve the touch
-  // zone through the overlay.
-  const overlay = target.closest(".texto-table__overlay");
-  const circle =
-    (overlay?.querySelector(
-      ".texto-table__overlay_overlay-circle",
-    ) as HTMLElement | null) ??
-    target.closest(".texto-table__overlay_overlay-circle");
-  if (circle) {
-    if (startEvent.touches.length !== 1) {
-      return false;
-    }
-
-    beginCellDrag();
-
-    // The anchor cell position is recorded by the decoration in the
-    // circle's data-cell-pos — this is more reliable than geometry:
-    // posAtCoords can degrade on mobile (workspace-drawer-backdrop).
-    runCellDrag(
-      view,
-      startEvent,
-      Number(circle.dataset.cellPos) || null,
-      CIRCLE_CLEARANCE,
-    );
-    startEvent.preventDefault();
-    return true;
-  }
-
   return false;
 }
 
@@ -124,11 +90,8 @@ export function handlePointerDown(
     return false;
   }
 
-  // The circle and the resize handles have their own touch-based gestures.
-  if (
-    target.classList.contains("texto-table__resize-handle") ||
-    target.closest(".texto-table__overlay")
-  ) {
+  // The resize handles have their own touch-based gesture.
+  if (target.classList.contains("texto-table__resize-handle")) {
     return false;
   }
 
@@ -140,54 +103,6 @@ export function handlePointerDown(
   return startLongPressCellSelection(view, event, startCellEl as HTMLElement);
 }
 
-/**
- * Resolves the drag endpoints for the circle drag: the anchor cell (from the
- * gesture start point or a recorded position) and the head cell under the
- * current point.
- *
- * `clearance` shifts the head point up-left on the first move of a circle
- * drag, where the pointer stands on the circle in the cell corner.
- */
-function dragToCellHead(
-  view: EditorView,
-  topLeftAnchor: number | null,
-  anchorX: number,
-  anchorY: number,
-  headX: number,
-  headY: number,
-  isFirstMove: boolean,
-  clearance: number,
-): { anchor: ResolvedPos; head: ResolvedPos; topLeft: number } | null {
-  const $anchor =
-    topLeftAnchor != null
-      ? view.state.doc.resolve(topLeftAnchor)
-      : cellAtPoint(view, anchorX, anchorY, isFirstMove ? clearance : 0);
-  if (!$anchor) {
-    return null;
-  }
-
-  const $head =
-    cellAtPoint(view, headX, headY, isFirstMove ? clearance : 0) ??
-    cellInTableAtPoint(view, topLeftAnchor ?? $anchor.pos, headX, headY);
-  if (!$head) {
-    return null;
-  }
-
-  return {
-    anchor: $anchor,
-    head: $head,
-    topLeft: topLeftAnchor ?? $anchor.pos,
-  };
-}
-
-/**
- * The ProseMirror position of the cell node for a td/th element.
- *
- * Uses view.posAtDOM (a direct DOM→doc mapping) instead of posAtCoords:
- * posAtCoords is hit-test based and degrades on mobile (it can resolve the
- * same screen point to different cells between gestures), while posAtDOM is
- * exact for a node we already hold.
- */
 function cellPosFromDom(
   view: EditorView,
   cellEl: HTMLElement,
@@ -216,85 +131,8 @@ function dispatchCellSelection(
   view.dispatch(
     view.state.tr.setSelection(selection).setMeta(tableEditingKey, selection),
   );
-  scheduleOverlayRefresh(view);
 }
 
-/**
- * Touch drag for the selection circle: touchmove builds a TextoCellSelection
- * from the anchor cell to the cell under the finger.
- *
- * The overlay decoration is frozen for the whole gesture (beginCellDrag) so
- * ProseMirror reuses the circle DOM node instead of recreating it — removing
- * the touch target mid-gesture makes the browser cancel the touch
- * (touchcancel), which killed the drag after its first move. Unlike the
- * long-press gesture this path is safe on touch events: the circle is a
- * widget whose node survives the re-render (the freeze), and preventDefault
- * on touchstart suppresses the compatibility mouse events entirely.
- */
-function runCellDrag(
-  view: EditorView,
-  startEvent: TouchEvent,
-  anchorPos: number | null,
-  clearance: number,
-): void {
-  let topLeftAnchor = anchorPos;
-  let isFirstMove = true;
-
-  function point(event: TouchEvent) {
-    return event.touches[0] ?? event.changedTouches[0];
-  }
-
-  function stop(event: TouchEvent) {
-    endCellDrag();
-    root.removeEventListener("touchmove", move);
-    root.removeEventListener("touchend", end);
-    root.removeEventListener("touchcancel", stop);
-    document.body.classList.remove(CELL_SELECTING_CLASS);
-    // Suppress the synthetic click: it would collapse the freshly built
-    // cell selection back to a text cursor.
-    event.preventDefault();
-    if (tableEditingKey.getState(view.state) != null) {
-      view.dispatch(view.state.tr.setMeta(tableEditingKey, -1));
-    }
-  }
-
-  function end(event: TouchEvent) {
-    stop(event);
-  }
-
-  function move(event: TouchEvent) {
-    // Keep the drag from turning into document scrolling.
-    event.preventDefault();
-
-    const start = point(startEvent);
-    const current = point(event);
-    const drag = dragToCellHead(
-      view,
-      topLeftAnchor,
-      start.clientX,
-      start.clientY,
-      current.clientX,
-      current.clientY,
-      isFirstMove,
-      clearance,
-    );
-    isFirstMove = false;
-    if (!drag) return;
-
-    topLeftAnchor = drag.topLeft;
-    dispatchCellSelection(view, drag.anchor, drag.head);
-  }
-
-  const root = view.dom.ownerDocument;
-  root.addEventListener("touchmove", move, { passive: false });
-  root.addEventListener("touchend", end);
-  root.addEventListener("touchcancel", stop);
-}
-
-/**
- * The table element the given cell belongs to (visible one — the geometry of
- * hidden duplicate leaves is all zeros).
- */
 function cellTable(cell: HTMLElement): HTMLTableElement | null {
   const wrapper = cell.closest(".table-wrapper");
   const table = wrapper?.querySelector("table") ?? cell.closest("table");
diff --git a/src/texto/extensions/table/helpers/overlay.ts b/src/texto/extensions/table/helpers/overlay.ts
deleted file mode 100644
index 25435f5..0000000
--- a/src/texto/extensions/table/helpers/overlay.ts
+++ /dev/null
@@ -1,179 +0,0 @@
-import type { EditorState } from "prosemirror-state";
-import type { EditorView } from "prosemirror-view";
-import { cellAround, CellSelection, isInTable } from "prosemirror-tables";
-import { Decoration } from "prosemirror-view";
-
-import { TEXTO_ERROR, TextoError } from "../../../core";
-import { findTableAnchor } from "./findTableAnchor";
-import { getSelectedTableRect } from "./getTableRect";
-
-// The current overlay DOM node and the view that owns it. The cache lets us
-// update the overlay position in place (refreshOverlayPosition) between
-// redraws instead of recreating the node.
-let overlayNode: HTMLElement | null = null;
-let overlayView: EditorView | null = null;
-
-function createOverlayElement(anchorCellPos: number) {
-  const element = createDiv();
-  const overlayCircle = createDiv();
-  const circle = createDiv();
-  element.className = "texto-table__overlay";
-  overlayCircle.className = "texto-table__overlay_overlay-circle";
-  circle.className = "texto-table__overlay_circle";
-
-  // The anchor cell position is recorded by the touch/mouse handlers here
-  // instead of relying on posAtCoords, which can degrade on mobile because
-  // of the workspace-drawer-backdrop. See handleTouchStart.
-  overlayCircle.dataset.cellPos = String(anchorCellPos);
-
-  overlayCircle.appendChild(circle);
-  element.appendChild(overlayCircle);
-  return element;
-}
-
-/**
- * Recomputes the rect of the current selection and applies it to the cached
- * overlay node (position + anchor cell in data-cell-pos).
- *
- * IMPORTANT: called only AFTER the render has finished (requestAnimationFrame),
- * when the DOM is up to date. This used to be view.updateState() called from
- * inside toDOM — a full docView re-render that destroyed every widget node,
- * including the selection circle (the touch target), which made the browser
- * cancel the gesture (touchcancel) and killed the smooth cell drag after its
- * first move.
- */
-export function refreshOverlayPosition(view: EditorView): void {
-  const node = overlayNode;
-  if (!node || !node.isConnected || overlayView !== view) {
-    return;
-  }
-
-  const { selection } = view.state;
-
-  let cellSelection: CellSelection | null = null;
-  if (selection instanceof CellSelection) {
-    cellSelection = selection;
-  } else if (isInTable(view.state)) {
-    const anchor = findTableAnchor(view.state, -1);
-    cellSelection = anchor ? new CellSelection(anchor) : null;
-  }
-
-  if (!cellSelection) {
-    return;
-  }
-
-  try {
-    const rect = getSelectedTableRect(view, cellSelection);
-    node.setAttribute(
-      "style",
-      `top: ${rect.top.toFixed(2)}px; left: ${rect.left.toFixed(2)}px; width: ${rect.width.toFixed(
-        2,
-      )}px; height: ${rect.height.toFixed(2)}px;`,
-    );
-    const circle = node.querySelector(".texto-table__overlay_overlay-circle");
-    if (circle) {
-      (circle as HTMLElement).dataset.cellPos = String(
-        cellSelection.$anchorCell.pos,
-      );
-    }
-  } catch {
-    // The geometry may be gone (cell removed, etc.) — skip silently.
-  }
-}
-
-/** Schedule an overlay position update for after the current frame (rAF). */
-export function scheduleOverlayRefresh(view: EditorView): void {
-  window.requestAnimationFrame(() => {
-    refreshOverlayPosition(view);
-  });
-}
-
-/**
- * The table node the current selection belongs to. Used as the identity of
- * the cached overlay: a frozen overlay is only reused while the selection
- * stays within the same table. Node objects are immutable, so comparing
- * them by identity is stable as long as the document does not change (it
- * does not during a drag).
- */
-export function overlayTableKey(state: EditorState): object | null {
-  if (state.selection instanceof CellSelection) {
-    return state.selection.$anchorCell.node(-1);
-  }
-  if (isInTable(state)) {
-    return findTableAnchor(state)?.node() ?? null;
-  }
-  return null;
-}
-
-function getMoreCellsSelectingDecoration(state: EditorState) {
-  if (!(state.selection instanceof CellSelection)) {
-    return null;
-  }
-
-  const selection = state.selection;
-  const tableStart = state.selection.$anchorCell.start(-1);
-  return Decoration.widget(tableStart, (view) => {
-    try {
-      const element = createOverlayElement(selection.$anchorCell.pos);
-      overlayNode = element;
-      overlayView = view;
-      scheduleOverlayRefresh(view);
-      return element;
-    } catch {
-      return createDiv();
-    }
-  });
-}
-
-function getOneCellSelectingDecoration(state: EditorState) {
-  if (state.selection instanceof CellSelection || !isInTable(state)) {
-    return null;
-  }
-
-  const cell = cellAround(state.selection.$anchor);
-
-  if (!cell) {
-    return null;
-  }
-
-  const start = findTableAnchor(state);
-  if (!start) {
-    return null;
-  }
-
-  return Decoration.widget(start.pos - start.parentOffset, (view) => {
-    try {
-      const anchor = findTableAnchor(view.state, -1);
-      if (!anchor) {
-        throw new TextoError(
-          TEXTO_ERROR.KNOWN_ERROR,
-          "[Table Error] The table anchor was not found",
-        );
-      }
-      const element = createOverlayElement(anchor.pos);
-      overlayNode = element;
-      overlayView = view;
-      scheduleOverlayRefresh(view);
-      return element;
-    } catch {
-      return createDiv();
-    }
-  });
-}
-
-/**
- * The selection overlay (frame + circle) for the current state.
- *
- * The rect is NOT computed here: geometry is read in refreshOverlayPosition
- * after the render. Reading DOM geometry inside toDOM requires
- * view.updateState (the old hack from getSelectedTableRect), which recreates
- * the circle DOM node and kills an active touch gesture.
- */
-export function buildSelectionOverlayDecoration(
-  state: EditorState,
-): Decoration | null {
-  return (
-    getMoreCellsSelectingDecoration(state) ??
-    getOneCellSelectingDecoration(state)
-  );
-}
diff --git a/src/texto/extensions/table/helpers/safeStyle.test.ts b/src/texto/extensions/table/helpers/safeStyle.test.ts
index e091658..701fa05 100644
--- a/src/texto/extensions/table/helpers/safeStyle.test.ts
+++ b/src/texto/extensions/table/helpers/safeStyle.test.ts
@@ -20,6 +20,12 @@ describe("safeColorValue (inline-style injection guard)", () => {
     expect(safeColorValue("#b3a3f7; color: red")).toBeNull();
     expect(safeColorValue("")).toBeNull();
   });
+
+  it("rejects non-strings (clipboard-parsed cells used to carry [])", () => {
+    expect(safeColorValue([] as never)).toBeNull();
+    expect(safeColorValue(undefined as never)).toBeNull();
+    expect(safeColorValue({} as never)).toBeNull();
+  });
 });
 
 describe("bordersToStyle injection guard", () => {
diff --git a/src/texto/extensions/table/helpers/safeStyle.ts b/src/texto/extensions/table/helpers/safeStyle.ts
index 227e7cd..1fb3721 100644
--- a/src/texto/extensions/table/helpers/safeStyle.ts
+++ b/src/texto/extensions/table/helpers/safeStyle.ts
@@ -16,8 +16,13 @@ export const SAFE_HEX_COLOR = /^#(?:[0-9a-f]{3}|[0-9a-f]{6})$/i;
 export const SAFE_RGB_COLOR =
   /^rgba?\(\s*[0-9.]+\s*,\s*[0-9.]+\s*,\s*[0-9.]+\s*(?:,\s*[0-9.]+\s*)?\)$/i;
 
-/** A color value safe for inline-style interpolation, or null. */
+/** A color value safe for inline-style interpolation, or null. Stored attrs
+ *  are untrusted: a non-string (e.g. the [] that tableCell.parseHTML used to
+ *  emit for cells parsed from clipboard HTML) must not reach .trim(). */
 export function safeColorValue(value: string): string | null {
+  if (typeof value !== "string") {
+    return null;
+  }
   const v = value.trim();
   if (SAFE_HEX_COLOR.test(v) || SAFE_RGB_COLOR.test(v)) {
     return v;
diff --git a/src/texto/extensions/table/style.css b/src/texto/extensions/table/style.css
index 5a8de4c..44af258 100644
--- a/src/texto/extensions/table/style.css
+++ b/src/texto/extensions/table/style.css
@@ -85,61 +85,6 @@
   background: #15151a;
 }
 
-/* ─── Overlay (selection frame + resize) ───
-   The frame color is the plugin's accent (same as .selectedCell), not the
-   near-black table border: the selection rectangle must read as selection,
-   not as a table grid line. */
-.ProseMirror .table-wrapper .texto-table__overlay {
-  border-radius: 4px;
-  border: 1.5px solid
-    color-mix(in srgb, var(--interactive-accent, #7c6af7) 85%, transparent);
-  box-sizing: border-box;
-  position: absolute;
-  z-index: 1;
-  pointer-events: none;
-}
-
-.ProseMirror .table-wrapper .texto-table__overlay_overlay-circle {
-  position: absolute;
-  width: 14px;
-  height: 14px;
-  /* Keep the circle inside the corner of the selection: it must not go
-     beyond the table, otherwise .table-wrapper (overflow) clips it in the
-     last column/row and it disappears when scrolling a wide table
-     horizontally. */
-  right: 0;
-  bottom: 0;
-  cursor: nwse-resize;
-  pointer-events: all;
-  display: flex;
-  justify-content: center;
-  align-items: center;
-}
-
-.ProseMirror .table-wrapper .texto-table__overlay_circle {
-  border: 1.5px solid
-    color-mix(in srgb, var(--interactive-accent, #7c6af7) 85%, transparent);
-  box-sizing: border-box;
-  border-radius: 8px;
-  width: 8px;
-  height: 8px;
-  background-color: white;
-  pointer-events: none;
-}
-
-/* Hide the selection overlay while a column resize drag is running: the
-   frame would float over the moving column edge. The `texto-table__cell-dragging`
-   class is added on `document.body` (by the mousemove guard below for the
-   desktop columnResizing drag and by columnTouchResize for touch), so the
-   selector must start at body — NOT inside .table-wrapper (the old selector
-   never matched, and the frame stayed visible during a resize). */
-body.texto-table__cell-dragging
-  .ProseMirror
-  .table-wrapper
-  .texto-table__overlay {
-  visibility: hidden;
-}
-
 /* ═══════════════════════════════════════════════════════════════
    Light theme
    ═══════════════════════════════════════════════════════════════ */
diff --git a/src/texto/extensions/table/table.ts b/src/texto/extensions/table/table.ts
index 54b3b90..95a0fbf 100644
--- a/src/texto/extensions/table/table.ts
+++ b/src/texto/extensions/table/table.ts
@@ -11,6 +11,7 @@ import { NodeView } from "prosemirror-view";
 
 import { addCommands } from "./commands";
 import { deleteTableWhenAllCellsSelected } from "./helpers";
+import { cellClipboardPlugin, cutCellSelection } from "./helpers/cellClipboard";
 import { cellTrailingParagraphPlugin } from "./helpers/cellTrailingParagraph";
 import { createColGroup } from "./helpers/createColGroup";
 import { handleCellSelection } from "./helpers/handleCellSelection";
@@ -132,6 +133,9 @@ export const Table = Node.create<TableOptions, AnyObject>({
       "Mod-Backspace": deleteTableWhenAllCellsSelected,
       Delete: deleteTableWhenAllCellsSelected,
       "Mod-Delete": deleteTableWhenAllCellsSelected,
+      // Excel cut semantics for cell selections (rows are removed, partial
+      // rectangles are cleared); the block is copied to the clipboard first.
+      "Mod-x": () => cutCellSelection(this.editor.view),
     };
   },
 
@@ -145,6 +149,9 @@ export const Table = Node.create<TableOptions, AnyObject>({
       // whose last block is a cursor-hostile atom (cell-level twin of the
       // note trailing-paragraph invariant).
       cellTrailingParagraphPlugin(),
+      // Table clipboard semantics (cell-rect paste, row insert, Excel cut);
+      // before tableEditing, whose handlePaste it replaces for table content.
+      cellClipboardPlugin(),
       ...(isResizable
         ? [
             columnResizing({
diff --git a/tests/e2e/table-toolbar.spec.ts b/tests/e2e/table-toolbar.spec.ts
index 9198788..c4959d2 100644
--- a/tests/e2e/table-toolbar.spec.ts
+++ b/tests/e2e/table-toolbar.spec.ts
@@ -160,10 +160,20 @@ test.describe("table toolbar dock + cells bubble", () => {
     await clickInsideNotepadText(page, cellA2.locator("p"), "A2");
 
     // The table bar is docked into the toolbar; the typography groups are gone.
+    // 17 buttons: row/col add + duplicate ×2 + clipboard ×3 + merge/split +
+    // delete ×2 + header + fill + borders + delete table (see the bar's render).
     await expect(page.locator(".note-toolbar__table-bar")).toBeVisible();
     await expect(
       page.locator(".note-toolbar__table-bar .bubble-menu-table-bar button"),
-    ).toHaveCount(12);
+    ).toHaveCount(17);
+    // The clipboard buttons of issue table-clipboard-buttons are in the bar.
+    for (const tip of ["Copy cells", "Cut cells", "Paste cells"]) {
+      await expect(
+        page.locator(
+          `.note-toolbar__table-bar .bubble-menu-table-bar button[data-tip="${tip}"]`,
+        ),
+      ).toBeVisible();
+    }
     await expect(page.locator(".note-toolbar .note-toolbar__btn")).toHaveCount(
       0,
     );