@@ -0,0 +1,113 @@
+import type { Page } from '@playwright/test';
+import { expect, test } from '../fixtures/muya';
+import { getMarkdown } from '../helpers/api';
+import { metaKey } from '../helpers/keyboard';
+import { editor } from '../helpers/selectors';
+
+/**
+ * Cross-cell table selection (Phase G restoration of the legacy
+ * `tableSelectCellsCtrl`). Dragging a rectangle of cells highlights them
+ * (`.mu-table-cell-selected`) and makes copy/cut operate on just that
+ * sub-range: copy yields a sub-table's markdown, cut empties those cells.
+ *
+ * The drag and clipboard round-trip need a real pointer + real OS clipboard,
+ * so this runs on bundled Chromium only (same constraint as
+ * `editing/clipboard.spec.ts`); Firefox/WebKit headless clipboard is tracked
+ * in BACKLOG Phase 3.
+ */
+
+const TABLE_MD = [
+    '| a1 | b1 | c1 |',
+    '| --- | --- | --- |',
+    '| a2 | b2 | c2 |',
+    '| a3 | b3 | c3 |',
+    '',
+].join('\n');
+
+async function seedTable(page: Page): Promise<void> {
+    await page.evaluate(md => window.muya!.setContent(md), TABLE_MD);
+    await expect(page.locator(editor.table).first()).toBeVisible();
+}
+
+// Centre point of the cell at (row, column), both zero-based, for page.mouse.
+async function cellCenter(page: Page, row: number, column: number) {
+    const cell = page.locator(editor.table).first()
+        .locator('tr').nth(row)
+        .locator('td').nth(column);
+    const box = await cell.boundingBox();
+    if (!box)
+        throw new Error(`cell (${row}, ${column}) has no bounding box`);
+    return { x: box.x + box.width / 2, y: box.y + box.height / 2 };
+}
+
+async function dragSelect(
+    page: Page,
+    from: { row: number; column: number },
+    to: { row: number; column: number },
+): Promise<void> {
+    const start = await cellCenter(page, from.row, from.column);
+    const end = await cellCenter(page, to.row, to.column);
+    await page.mouse.move(start.x, start.y);
+    await page.mouse.down();
+    // Intermediate steps so the move handler sees the displacement and arms.
+    await page.mouse.move((start.x + end.x) / 2, (start.y + end.y) / 2, { steps: 4 });
+    await page.mouse.move(end.x, end.y, { steps: 4 });
+    await page.mouse.up();
+}
+
+function selectedCount(page: Page) {
+    return page.locator(`${editor.table} td.mu-table-cell-selected`).count();
+}
+
+test.describe('cross-cell table selection', () => {
+    test('dragging across cells highlights the rectangle', async ({ page }) => {
+        await seedTable(page);
+        await dragSelect(page, { row: 0, column: 0 }, { row: 1, column: 1 });
+
+        await expect.poll(() => selectedCount(page), {
+            timeout: 5_000,
+            intervals: [50, 100, 250, 500],
+        }).toBe(4);
+    });
+
+    test('copy yields only the selected sub-rectangle as a GFM table', async ({ browserName, context, page }) => {
+        test.skip(browserName !== 'chromium', 'clipboard read unreliable on Firefox/WebKit headless — BACKLOG Phase 3.');
+        await context.grantPermissions(['clipboard-read', 'clipboard-write']);
+        await seedTable(page);
+
+        await dragSelect(page, { row: 0, column: 0 }, { row: 1, column: 1 });
+        await expect.poll(() => selectedCount(page)).toBe(4);
+
+        await page.keyboard.press(`${metaKey()}+c`);
+
+        const copied = await page.evaluate(() => navigator.clipboard.readText());
+        // a1/b1 + a2/b2 only — the un-selected column/row are excluded.
+        expect(copied).toContain('a1');
+        expect(copied).toContain('b2');
+        expect(copied).not.toContain('c1');
+        expect(copied).not.toContain('a3');
+        // It is a real GFM table (header separator row).
+        expect(copied).toMatch(/\|\s*-+/);
+    });
+
+    test('cut empties only the selected cells', async ({ browserName, context, page }) => {
+        test.skip(browserName !== 'chromium', 'clipboard unreliable on Firefox/WebKit headless — BACKLOG Phase 3.');
+        await context.grantPermissions(['clipboard-read', 'clipboard-write']);
+        await seedTable(page);
+
+        await dragSelect(page, { row: 0, column: 0 }, { row: 1, column: 1 });
+        await expect.poll(() => selectedCount(page)).toBe(4);
+
+        await page.keyboard.press(`${metaKey()}+x`);
+
+        await expect.poll(() => getMarkdown(page), {
+            timeout: 5_000,
+            intervals: [50, 100, 250, 500],
+        }).not.toMatch(/\ba1\b/);
+
+        const md = await getMarkdown(page);
+        expect(md).not.toMatch(/\bb2\b/); // selected cells cleared
+        expect(md).toContain('c1'); // un-selected survive
+        expect(md).toContain('a3');
+    });
+});
@@ -560,6 +560,17 @@ li.mu-task-list-item > span.mu-checkbox-checked::before {
     margin-bottom: 0;
 }
 
+/* Cross-cell drag selection (port of marktext's `.ag-cell-selected`): the
+   rectangle of cells the user dragged across is tinted via the per-cell
+   `::before` overlay so it reads as one contiguous selection. Every cell
+   (header included) renders as a `td`, and the overlay already paints the cell
+   border, so a translucent accent fill is enough. */
+.mu-table-inner tr td.mu-table-cell-selected::before {
+    z-index: 1;
+
+    background: var(--selection-color);
+}
+
 .mu-table-inner td[data-align='left'] {
     text-align: left;
 }
 
@@ -0,0 +1,120 @@
+// @vitest-environment happy-dom
+
+import type Table from '..';
+import type { ITableState } from '../../../../state/types';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { Muya } from '../../../../muya';
+
+// Unit coverage for the cross-cell selection building blocks added for the
+// Phase G table-selection restoration: `Table.cellAt` (resolve a body cell by
+// row/column offsets) and `Table.getSubTableState` (extract a rectangular block
+// of cells as an `ITableState` so the clipboard can serialise just that range).
+
+const bootedHosts: HTMLElement[] = [];
+let hadVersion = false;
+let originalVersion: string | undefined;
+
+beforeEach(() => {
+    hadVersion = 'MUYA_VERSION' in window;
+    originalVersion = window.MUYA_VERSION;
+    window.MUYA_VERSION = 'test';
+});
+
+afterEach(() => {
+    while (bootedHosts.length) {
+        const host = bootedHosts.pop()!;
+        host.remove();
+    }
+    if (hadVersion)
+        window.MUYA_VERSION = originalVersion as string;
+    else
+        delete (window as Partial<Window>).MUYA_VERSION;
+});
+
+// A 3-row × 3-column table: header (a1/b1/c1) plus two body rows.
+const TABLE_MD = [
+    '| a1 | b1 | c1 |',
+    '| --- | --- | --- |',
+    '| a2 | b2 | c2 |',
+    '| a3 | b3 | c3 |',
+    '',
+].join('\n');
+
+function bootMuya(markdown: string): Muya {
+    const host = document.createElement('div');
+    document.body.appendChild(host);
+    const muya = new Muya(host, { markdown } as ConstructorParameters<typeof Muya>[1]);
+    muya.init();
+    bootedHosts.push(muya.domNode);
+    return muya;
+}
+
+function firstTable(muya: Muya): Table {
+    const block = muya.editor.scrollPage!.firstContentInDescendant()!.closestBlock('table');
+    return block as Table;
+}
+
+function cellTexts(state: ITableState): string[][] {
+    return state.children.map(row => row.children.map(cell => cell.text));
+}
+
+describe('table.cellAt', () => {
+    it('resolves a body cell by (row, column) offsets', () => {
+        const table = firstTable(bootMuya(TABLE_MD));
+        const cell = table.cellAt(2, 1); // 3rd row, 2nd column => "b3"
+        expect(cell).not.toBeNull();
+        expect(cell!.getState().text).toBe('b3');
+    });
+
+    it('returns null for an out-of-range row or column', () => {
+        const table = firstTable(bootMuya(TABLE_MD));
+        expect(table.cellAt(9, 0)).toBeNull();
+        expect(table.cellAt(0, 9)).toBeNull();
+    });
+});
+
+describe('table.getSubTableState', () => {
+    it('extracts the rectangle between two corners (header becomes the sub-table header)', () => {
+        const table = firstTable(bootMuya(TABLE_MD));
+        // Rows 0..1, columns 0..1 => a1/b1 + a2/b2.
+        const state = table.getSubTableState(0, 0, 1, 1);
+        expect(cellTexts(state)).toEqual([
+            ['a1', 'b1'],
+            ['a2', 'b2'],
+        ]);
+    });
+
+    it('normalises reversed bounds (focus before anchor)', () => {
+        const table = firstTable(bootMuya(TABLE_MD));
+        // Same rectangle, corners passed bottom-right -> top-left.
+        const state = table.getSubTableState(2, 2, 1, 1);
+        expect(cellTexts(state)).toEqual([
+            ['b2', 'c2'],
+            ['b3', 'c3'],
+        ]);
+    });
+
+    it('clamps bounds that exceed the table dimensions', () => {
+        const table = firstTable(bootMuya(TABLE_MD));
+        const state = table.getSubTableState(0, 0, 99, 99);
+        // The full 3x3 table is returned, not a ragged/oversized one.
+        expect(cellTexts(state)).toEqual([
+            ['a1', 'b1', 'c1'],
+            ['a2', 'b2', 'c2'],
+            ['a3', 'b3', 'c3'],
+        ]);
+    });
+
+    it('preserves per-column alignment in the extracted cells', () => {
+        const aligned = [
+            '| h1 | h2 |',
+            '| :--- | ---: |',
+            '| x | y |',
+            '',
+        ].join('\n');
+        const table = firstTable(bootMuya(aligned));
+        const state = table.getSubTableState(0, 0, 1, 1);
+        expect(state.children[0].children[0].meta.align).toBe('left');
+        expect(state.children[0].children[1].meta.align).toBe('right');
+    });
+});
@@ -1,5 +1,5 @@
 import type { Muya } from '../../../muya';
-import type { ITableState } from '../../../state/types';
+import type { ITableRowState, ITableState } from '../../../state/types';
 import type { Nullable } from '../../../types';
 import type Content from '../../base/content';
 import type TableCellContent from '../../content/tableCell';
@@ -271,6 +271,54 @@ class Table extends Parent {
         });
     }
 
+    /**
+     * Resolve a body cell by its (row, column) offsets, both zero-based. Returns
+     * `null` when either index is out of range. Used by the cross-cell selection
+     * controller to walk the rectangle between an anchor and focus cell.
+     */
+    cellAt(row: number, column: number): Nullable<TableBodyCell> {
+        const rowBlock = (this.firstChild as TableInner).find(row) as TableRow | undefined;
+        if (rowBlock == null)
+            return null;
+
+        return (rowBlock.find(column) as TableBodyCell | undefined) ?? null;
+    }
+
+    /**
+     * Build an `ITableState` for the rectangular block of cells bounded by
+     * (`startRow`, `startColumn`) and (`endRow`, `endColumn`) inclusive. The
+     * bounds may be passed in any order — they are normalised — and are clamped
+     * to the table's dimensions. Mirrors legacy `tableSelectCellsCtrl`'s
+     * sub-table extraction so a copied cell rectangle round-trips to GFM table
+     * markdown via `StateToMarkdown`. The first selected row becomes the header
+     * row of the resulting sub-table, preserving each cell's alignment.
+     */
+    getSubTableState(
+        startRow: number,
+        startColumn: number,
+        endRow: number,
+        endColumn: number,
+    ): ITableState {
+        const { rowCount, columnCount } = this;
+        const minRow = Math.max(0, Math.min(startRow, endRow));
+        const maxRow = Math.min(rowCount - 1, Math.max(startRow, endRow));
+        const minColumn = Math.max(0, Math.min(startColumn, endColumn));
+        const maxColumn = Math.min(columnCount - 1, Math.max(startColumn, endColumn));
+
+        const children: ITableState['children'] = [];
+        for (let r = minRow; r <= maxRow; r++) {
+            const cells: ITableRowState['children'] = [];
+            for (let c = minColumn; c <= maxColumn; c++) {
+                const cell = this.cellAt(r, c);
+                if (cell)
+                    cells.push(cell.getState());
+            }
+            children.push({ name: 'table.row', children: cells });
+        }
+
+        return { name: 'table', children };
+    }
+
     override getState(): ITableState {
         return (this.firstChild as TableInner).getState();
     }