@rowsncolumns/spreadsheet-state 28.0.76 → 29.1.0

package/dist/esm/hooks/use-on-paste.js

@@ -1,18 +1,25 @@
 import { isStaticNode } from "@rowsncolumns/dag";
-import { areaIntersects, isAreasEqual } from "@rowsncolumns/grid";
+import { areaInsideArea, areaIntersects, isAreasEqual } from "@rowsncolumns/grid";
 import { selectionFromActiveCell } from "@rowsncolumns/grid";
 import { DEFAULT_COLUMN_COUNT, DEFAULT_ROW_COUNT, findActiveTableWithinCell, loadWebFont, MAX_COLUMN_COUNT, MAX_ROW_COUNT, useFocusEmbedOrChart, useGetFinalRowHeight, useRedrawGrid, } from "@rowsncolumns/spreadsheet";
 import { isSelectionACell, useGetEffectiveValuesFromRange, } from "@rowsncolumns/spreadsheet";
 import { error, getCellFormattedValue, getCellUserEnteredFormat, getCellUserEnteredValue, getExtendedValueBool, getExtendedValueFormula, getExtendedValueNumber, getExtendedValueString, isNil, iterateCellsInRange, uuidString, } from "@rowsncolumns/utils";
 import { produceWithPatches } from "immer";
 import { useCallback } from "react";
+import { moveChartsOnRangeMove } from "../api/anchored-objects";
 import { processSideEffectDependentCells } from "../api/dependency";
 import { createSheetCellIdentifier } from "../api/formula";
 import { createSheetDraft } from "../api/immer-utils";
+import { findPartiallyCoveredMerge, MERGED_CELL_MOVE_ERROR } from "../api/merges";
+import { moveRange } from "../api/selection";
+import { useShowError } from "../atoms/error-state.atom";
 import { applyPasteOperation, isBlankClipboardCell, resolvePasteSpecialOptions, } from "../api/paste-special";
-import { findAdjacentTable, findTableColumnIndex } from "../api/table";
-import { addCalculatedColumnsForRowExpansion } from "../interface/change-table-column";
+import { getMoveRangeRefusal } from "../api/structural-guards";
+import { renameHeaderCellsInFormulas } from "../api/structural-table-refs";
+import { findAdjacentTable } from "../api/table";
+import { getNextTableTitle } from "../helpers";
 import { collectDataValidationTarget, extendDataValidationRanges, } from "../interface/data-validation-utils";
+import { planHeaderCellRenames } from "../interface/change-table-column";
 import { SheetCell } from "../sheet-cell";
 import { extractFontFamily, generateDataFromClipboard, pickFormatting, pickFormula, pickValue, transpose, } from "./../api/copy-paste";
 import { useCalculationQueue } from "./use-calculation-queue";
@@ -33,8 +40,9 @@ export const buildDestinationRowAssignments = (sheetId, startRowIndex, endRowInd
     }
     return assignments;
 };
-export const useOnPaste = ({ rowCount, columnCount, locale, sheetData, tables: currentTables, maxRowCount = MAX_ROW_COUNT, maxColumnCount = MAX_COLUMN_COUNT, isHiddenByFilterRow, onRequestFonts, idCreationStrategy, createHistory, enqueueCalculation, enqueueStructureChange, enqueueGraphOperation, onChangeSheetData, onChangeSheets, onChangeTables, onChangeEmbeds, onChangeSelections, onChangeActiveCell, getDependents, getActiveCell, getUserEnteredValue, onChangeDataValidations, preserveFormatting = true, cellXfsRegistry, sharedStringRegistry, getDataValidationById, getSheetName, onError, citations, onChangeCitations, sanitizeHtml, onCommand, generatedNames, }) => {
+export const useOnPaste = ({ rowCount, columnCount, locale, sheetData, tables: currentTables, maxRowCount = MAX_ROW_COUNT, maxColumnCount = MAX_COLUMN_COUNT, isHiddenByFilterRow, onRequestFonts, idCreationStrategy, createHistory, enqueueCalculation, enqueueStructureChange, enqueueGraphOperation, onChangeSheetData, onChangeSheets, onChangeTables, onChangeEmbeds, onChangeSelections, onChangeActiveCell, getDependents, getActiveCell, getUserEnteredValue, onChangeDataValidations, onChangeNamedRanges, onChangeCharts, getSheetMerges, preserveFormatting = true, cellXfsRegistry, sharedStringRegistry, getDataValidationById, getSheetName, onError, citations, onChangeCitations, sanitizeHtml, onCommand, generatedNames, batchHistory = (action) => action(), autoExpandTables = true, autoCalculatedColumns = true, }) => {
     const canEditCellRange = useCanEditCellRange();
+    const showError = useShowError();
     // Allowed values
     const getEffectiveValuesFromRange = useGetEffectiveValuesFromRange();
     const focusEmbedOrChart = useFocusEmbedOrChart();
@@ -47,6 +55,7 @@ export const useOnPaste = ({ rowCount, columnCount, locale, sheetData, tables: c
         onChangeTables,
         getSheetName,
         onCommand,
+        autoCalculatedColumns,
     });
     const onChangeTableColumn = useOnChangeTableColumn({
         locale,
@@ -55,9 +64,11 @@ export const useOnPaste = ({ rowCount, columnCount, locale, sheetData, tables: c
         enqueueGraphOperation,
         onChangeSheetData,
         onChangeTables,
+        onChangeCharts,
         getDependents,
         onCommand,
         generatedNames,
+        tables: currentTables,
     });
     const redrawGrid = useRedrawGrid();
     const getFinalRowHeight = useGetFinalRowHeight();
@@ -97,7 +108,7 @@ export const useOnPaste = ({ rowCount, columnCount, locale, sheetData, tables: c
             }
         }
         else {
-            const pasteResults = await generateDataFromClipboard(e, activeCell, destinationSheetId, activeSheetName, preserveFormatting, locale, idCreationStrategy, forcePlainText, sanitizeHtml, generatedNames);
+            const pasteResults = await generateDataFromClipboard(e, activeCell, destinationSheetId, activeSheetName, preserveFormatting, locale, idCreationStrategy, forcePlainText, sanitizeHtml);
             selectedRowValues = pasteResults?.results ?? [];
             merges = pasteResults?.merges;
             embeds = pasteResults?.embeds;
@@ -121,8 +132,6 @@ export const useOnPaste = ({ rowCount, columnCount, locale, sheetData, tables: c
         else if (pasteMode === "values") {
             selectedRowValues = pickValue(selectedRowValues, destinationSheetId, locale);
         }
-        const saveHistory = createHistory();
-        const dataValidationTargets = new Map();
         const fontFamilies = extractFontFamily(selectedRowValues);
         // Wait for fonts to load
         if (fontFamilies.length && preserveFormatting) {
@@ -142,721 +151,887 @@ export const useOnPaste = ({ rowCount, columnCount, locale, sheetData, tables: c
                 error("Error loading webfonts", fontFamilies, err);
             }
         }
-        const [rowSpan, colSpan] = [
-            selectedRowValues?.length ?? 0,
-            // For cut operations, use range dimensions since data may be sparse
-            isCutOperation && from
-                ? from.range.endColumnIndex - from.range.startColumnIndex + 1
-                : selectedRowValues[0]?.length ?? 0,
-        ];
-        const to = selections?.[selections?.length - 1] ??
-            selectionFromActiveCell(activeCell)[0];
-        const rowDelta = from && to ? to.range.startRowIndex - from.range.startRowIndex : -1;
-        const columnDelta = from && to
-            ? to.range.startColumnIndex - from.range.startColumnIndex
-            : -1;
-        // When user enters a value in the last row of a
-        // table and if the entire row is empty
-        const [adjacentTable, isRowExpansion, isColumnExpansion] = findAdjacentTable(destinationSheetId, activeCell, currentTables, getUserEnteredValue);
-        const currentTable = isColumnExpansion && adjacentTable
-            ? adjacentTable
-            : findActiveTableWithinCell(destinationSheetId, activeCell, currentTables);
-        // Next selections
-        const nextSelections = finalSelections?.length ? finalSelections : [to];
-        // Update range based on length of data
-        to.range.endRowIndex = Math.min(maxRowCount, Math.max(to.range.endRowIndex, to.range.startRowIndex + rowSpan - 1));
-        to.range.endColumnIndex = Math.min(maxColumnCount, Math.max(to.range.endColumnIndex, to.range.startColumnIndex + colSpan - 1));
-        // Check for protected range
-        if (!canEditCellRange(destinationSheetId, to.range)) {
-            console.debug("Protected range, You cannot paste on to protected cells.");
-            return;
-        }
-        // Check if pasting a table would overlap with an existing table
-        if (tables?.length) {
-            const existingTable = currentTables?.find((table) => table.sheetId === destinationSheetId &&
-                areaIntersects(to.range, table.range));
-            if (existingTable) {
-                onError?.("Cannot paste a table over another table. The paste range overlaps with an existing table.");
+        // From here on the paste is synchronous: its writes and the table growth / calculated-column
+        // fill they trigger open ONE undo entry.
+        batchHistory(() => {
+            const saveHistory = createHistory();
+            const dataValidationTargets = new Map();
+            const [rowSpan, colSpan] = [
+                selectedRowValues?.length ?? 0,
+                // For cut operations, use range dimensions since data may be sparse
+                isCutOperation && from
+                    ? from.range.endColumnIndex - from.range.startColumnIndex + 1
+                    : selectedRowValues[0]?.length ?? 0,
+            ];
+            const to = selections?.[selections?.length - 1] ??
+                selectionFromActiveCell(activeCell)[0];
+            const rowDelta = from && to ? to.range.startRowIndex - from.range.startRowIndex : -1;
+            const columnDelta = from && to
+                ? to.range.startColumnIndex - from.range.startColumnIndex
+                : -1;
+            // A cut is a move: a table the cut block covers whole travels with it (Excel; the rnc
+            // engine's `move-range` does the same), so it is neither the table the paste writes into
+            // nor one the paste grows.
+            const movedTables = isCutOperation && from && !isNil(sourceSheetId)
+                ? currentTables?.filter((table) => table.sheetId === sourceSheetId &&
+                    areaInsideArea(table.range, from.range)) ?? []
+                : [];
+            const stayingTables = movedTables.length
+                ? currentTables?.filter((table) => !movedTables.includes(table))
+                : currentTables;
+            // When user enters a value in the last row of a
+            // table and if the entire row is empty
+            const [adjacentTable, isRowExpansion, isColumnExpansion] = autoExpandTables
+                ? findAdjacentTable(destinationSheetId, activeCell, stayingTables, getUserEnteredValue)
+                : [undefined, false, false];
+            const currentTable = isColumnExpansion && adjacentTable
+                ? adjacentTable
+                : findActiveTableWithinCell(destinationSheetId, activeCell, stayingTables);
+            // Next selections
+            const nextSelections = finalSelections?.length ? finalSelections : [to];
+            // Update range based on length of data
+            to.range.endRowIndex = Math.min(maxRowCount, Math.max(to.range.endRowIndex, to.range.startRowIndex + rowSpan - 1));
+            to.range.endColumnIndex = Math.min(maxColumnCount, Math.max(to.range.endColumnIndex, to.range.startColumnIndex + colSpan - 1));
+            // Check for protected range
+            if (!canEditCellRange(destinationSheetId, to.range)) {
+                console.debug("Protected range, You cannot paste on to protected cells.");
                 return;
             }
-        }
-        const destinationRows = buildDestinationRowAssignments(destinationSheetId, to.range.startRowIndex, to.range.endRowIndex, rowSpan, isHiddenByFilterRow);
-        if (!destinationRows.length) {
-            return;
-        }
-        // Paste writes through `onChangeSheetData` directly, so the
-        // calculator's per-cell invalidation never fires for the
-        // destination cells. Invalidate the destination rect — and the
-        // source on cut, since those cells are cleared too.
-        enqueueStructureChange?.({
-            kind: "invalidate-range",
-            sheetId: destinationSheetId,
-            startRowIndex: to.range.startRowIndex,
-            endRowIndex: to.range.endRowIndex,
-            startColumnIndex: to.range.startColumnIndex,
-            endColumnIndex: to.range.endColumnIndex,
-        });
-        if (isCutOperation && from && !isNil(sourceSheetId)) {
+            // A cut is a move: Excel refuses it when the destination (or the source) covers a merged
+            // cell only partially — writing into a non-anchor cell of a merge would tear it.
+            if (isCutOperation &&
+                from &&
+                !isNil(sourceSheetId) &&
+                (findPartiallyCoveredMerge(to.range, getSheetMerges?.(destinationSheetId)) ||
+                    findPartiallyCoveredMerge(from.range, getSheetMerges?.(sourceSheetId)))) {
+                showError({ message: MERGED_CELL_MOVE_ERROR });
+                return;
+            }
+            // …and Excel never moves PART of a table, nor lands a block on another table's cells — the
+            // drag-move refusals (T-46) apply to a cut + paste too, across sheets (T-79).
+            if (isCutOperation && from && !isNil(sourceSheetId)) {
+                const tableRefusal = getMoveRangeRefusal({
+                    sheetId: sourceSheetId,
+                    from: from.range,
+                    to: to.range,
+                    toSheetId: destinationSheetId,
+                    tables: currentTables,
+                });
+                if (tableRefusal) {
+                    showError({ title: tableRefusal.title, message: tableRefusal.message });
+                    return;
+                }
+            }
+            // Check if pasting a table would overlap with an existing table
+            if (tables?.length) {
+                const existingTable = currentTables?.find((table) => table.sheetId === destinationSheetId &&
+                    areaIntersects(to.range, table.range));
+                if (existingTable) {
+                    onError?.("Cannot paste a table over another table. The paste range overlaps with an existing table.");
+                    return;
+                }
+            }
+            const destinationRows = buildDestinationRowAssignments(destinationSheetId, to.range.startRowIndex, to.range.endRowIndex, rowSpan, isHiddenByFilterRow);
+            if (!destinationRows.length) {
+                return;
+            }
+            // Paste writes through `onChangeSheetData` directly, so the
+            // calculator's per-cell invalidation never fires for the
+            // destination cells. Invalidate the destination rect — and the
+            // source on cut, since those cells are cleared too.
             enqueueStructureChange?.({
                 kind: "invalidate-range",
-                sheetId: sourceSheetId,
-                startRowIndex: from.range.startRowIndex,
-                endRowIndex: from.range.endRowIndex,
-                startColumnIndex: from.range.startColumnIndex,
-                endColumnIndex: from.range.endColumnIndex,
+                sheetId: destinationSheetId,
+                startRowIndex: to.range.startRowIndex,
+                endRowIndex: to.range.endRowIndex,
+                startColumnIndex: to.range.startColumnIndex,
+                endColumnIndex: to.range.endColumnIndex,
             });
-        }
-        const visibleRowIndexes = destinationRows.map(({ rowIndex }) => rowIndex);
-        // Check if the user is editing a table column
-        const tableHeaderColumnIndex = findTableColumnIndex(destinationSheetId, activeCell, currentTables);
-        // Adds new column to table and cell to sheet
-        const cellValue = selectedRowValues?.[0]?.[0];
-        const formattedValue = getCellFormattedValue(cellValue);
-        const sharedStrings = sharedStringRegistry?.getSharedStrings();
-        const sharedStringValue = cellValue?.ss == null || !sharedStrings
-            ? undefined
-            : sharedStrings.get(String(cellValue.ss));
-        const activeCellValue = typeof formattedValue === "string"
-            ? formattedValue
-            : typeof sharedStringValue === "string"
-                ? sharedStringValue
+            if (isCutOperation && from && !isNil(sourceSheetId)) {
+                enqueueStructureChange?.({
+                    kind: "invalidate-range",
+                    sheetId: sourceSheetId,
+                    startRowIndex: from.range.startRowIndex,
+                    endRowIndex: from.range.endRowIndex,
+                    startColumnIndex: from.range.startColumnIndex,
+                    endColumnIndex: from.range.endColumnIndex,
+                });
+            }
+            const visibleRowIndexes = destinationRows.map(({ rowIndex }) => rowIndex);
+            // Adds new column to table and cell to sheet
+            const sharedStrings = sharedStringRegistry?.getSharedStrings();
+            const pastedCellText = (cellValue) => {
+                const formattedValue = getCellFormattedValue(cellValue);
+                const sharedStringValue = cellValue?.ss == null || !sharedStrings
+                    ? undefined
+                    : sharedStrings.get(String(cellValue.ss));
+                return typeof formattedValue === "string"
+                    ? formattedValue
+                    : typeof sharedStringValue === "string"
+                        ? sharedStringValue
+                        : undefined;
+            };
+            const activeCellValue = pastedCellText(selectedRowValues?.[0]?.[0]);
+            // A block pasted right of the table names every new column from its own header cell.
+            const pastedHeaderValues = isColumnExpansion &&
+                adjacentTable &&
+                activeCell.rowIndex === adjacentTable.range.startRowIndex
+                ? selectedRowValues?.[0]?.map(pastedCellText)
                 : undefined;
-        // We need to track this for history. Precedent cells
-        const recalcCells = new Map();
-        // Expand table if user is pasting
-        // table data
-        // Same undo history
-        if (!isNil(currentTable) && !isRowExpansion) {
-            const newEndRowIndex = Math.max(currentTable.range.endRowIndex, activeCell.rowIndex + rowSpan - 1 + (currentTable.totalRow ? 1 : 0));
-            // Update table range
-            onChangeTables?.((prevTableData) => {
-                const [nextState, patches, inversePatches] = produceWithPatches(prevTableData, (draft) => {
-                    const table = draft.find((table) => currentTable?.id === table.id);
-                    if (table) {
-                        table.range.endRowIndex = newEndRowIndex;
-                        // Update table name
-                        if (!isNil(tableHeaderColumnIndex)) {
-                            if (table.columns?.length) {
-                                if (!table.columns[tableHeaderColumnIndex]) {
-                                    table.columns[tableHeaderColumnIndex] = {
-                                        name: String(activeCellValue),
-                                    };
-                                }
-                                else {
-                                    // Update name
-                                    table.columns[tableHeaderColumnIndex].name =
-                                        String(activeCellValue);
-                                }
-                            }
-                        }
+            // Header cells of existing tables the paste lands on take the typed-header
+            // rule (text, de-duplicated, structured references following); a cut moves
+            // cells as they are and a formats-only paste writes no values.
+            const headerRenames = !isCutOperation && pasteMode !== "formats"
+                ? planHeaderCellRenames({
+                    sheetId: destinationSheetId,
+                    tables: stayingTables,
+                    generatedNames,
+                    cells: destinationRows.flatMap(({ rowIndex, dataRowIndex }) => Array.from({
+                        length: to.range.endColumnIndex - to.range.startColumnIndex + 1,
+                    }, (_, cursor) => ({
+                        rowIndex,
+                        columnIndex: to.range.startColumnIndex + cursor,
+                        value: pastedCellText(selectedRowValues[dataRowIndex]?.[colSpan > 0 ? cursor % colSpan : 0]),
+                    }))),
+                })
+                : [];
+            const headerRenameAt = new Map(headerRenames.map((rename) => [
+                `${rename.rowIndex}:${rename.columnIndex}`,
+                rename,
+            ]));
+            // We need to track this for history. Precedent cells
+            const recalcCells = new Map();
+            // Expand table if user is pasting
+            // table data
+            // Same undo history
+            if (!isNil(currentTable) && !isRowExpansion) {
+                // The overflow grows the table row by row and stops at the first row another table
+                // occupies (Excel; same rule as the adjacent-row growth in `changeTableColumn`). Cells
+                // pasted past that row stay plain cells.
+                let newEndRowIndex = currentTable.range.endRowIndex;
+                const lastOverflowRowIndex = activeCell.rowIndex + rowSpan - 1 + (currentTable.totalRow ? 1 : 0);
+                for (let rowIndex = currentTable.range.endRowIndex + 1; rowIndex <= lastOverflowRowIndex; rowIndex++) {
+                    const line = {
+                        ...currentTable.range,
+                        startRowIndex: rowIndex,
+                        endRowIndex: rowIndex,
+                    };
+                    if (stayingTables?.some((other) => other.id !== currentTable.id &&
+                        other.sheetId === destinationSheetId &&
+                        areaIntersects(other.range, line))) {
+                        break;
                     }
-                });
-                saveHistory({
-                    tables: { patches, inversePatches },
-                });
-                return nextState;
-            });
-        }
-        // Update sheetdata
-        // Capture the produced state so we can stream the exact written cells to an engine
-        // consumer afterwards (branch-agnostic across cut / pure-paste / paste-special).
-        let pastedSheetData;
-        if (selectedRowValues.length) {
-            onChangeSheetData?.((prevSheetData) => {
-                const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
-                    // For cut operation
-                    const movedKeys = new Set();
-                    /**
-                     * If user is deleting source cells,
-                     * let update its dependents and mark it as dirty
-                     */
-                    if (isCutOperation && from && to && !isNil(sourceSheetId)) {
-                        const sheetId = sourceSheetId;
-                        for (const [rowIndex, columnIndex] of iterateCellsInRange(from.range)) {
-                            // Process dependents
-                            processSideEffectDependentCells({
-                                draft,
-                                rowIndex,
-                                columnIndex,
-                                sheetId,
-                                destinationSheetId,
-                                columnDelta,
-                                enqueueGraphOperation,
-                                enqueueCalculation: enqueue,
-                                getDependents,
-                                recalcCells,
-                                rowDelta,
-                                sourceRange: from.range,
-                                movedKeys,
-                                locale,
-                                rowCount,
-                                columnCount,
-                            });
-                        }
-                        // Snapshot source after dependent/formula rewrites, before
-                        // clearing it. The pre-cut clipboard snapshot still contains
-                        // stale formulas, so writing that snapshot would discard the
-                        // reference updates performed above.
-                        const movedRowValues = [];
-                        const sourceStartColumn = from.range.startColumnIndex;
-                        const sourceEndColumn = from.range.endColumnIndex + 1;
-                        for (let rowIndex = from.range.startRowIndex; rowIndex <= from.range.endRowIndex; rowIndex++) {
-                            movedRowValues.push((draft[sheetId]?.[rowIndex]?.values?.slice(sourceStartColumn, sourceEndColumn) ?? []));
+                    newEndRowIndex = rowIndex;
+                }
+                // Update table range
+                onChangeTables?.((prevTableData) => {
+                    const [nextState, patches, inversePatches] = produceWithPatches(prevTableData, (draft) => {
+                        const table = draft.find((table) => currentTable?.id === table.id);
+                        if (table) {
+                            table.range.endRowIndex = newEndRowIndex;
                         }
-                        // Delete source if required
-                        // Move values
-                        for (let rowIndex = from.range.startRowIndex; rowIndex <= from.range.endRowIndex; rowIndex++) {
-                            for (let columnIndex = from.range.startColumnIndex; columnIndex <= from.range.endColumnIndex; columnIndex++) {
-                                if (!draft[sheetId][rowIndex]?.values?.[columnIndex]) {
-                                    continue;
-                                }
-                                draft[sheetId][rowIndex].values[columnIndex] =
-                                    {};
+                    });
+                    saveHistory({
+                        tables: { patches, inversePatches },
+                    });
+                    return nextState;
+                });
+            }
+            if (headerRenames.length) {
+                onChangeTables?.((prevTables) => {
+                    const [nextState, patches, inversePatches] = produceWithPatches(prevTables, (draft) => {
+                        for (const { table, dimensionIndex, newName } of headerRenames) {
+                            const current = draft.find((candidate) => candidate.id === table.id);
+                            if (!current)
+                                continue;
+                            current.columns ??= [];
+                            if (current.columns[dimensionIndex]) {
+                                current.columns[dimensionIndex].name = newName;
+                            }
+                            else {
+                                current.columns[dimensionIndex] = { name: newName };
                             }
                         }
-                        for (const { rowIndex, dataRowIndex } of destinationRows) {
-                            const currentSheet = createSheetDraft(draft, destinationSheetId, rowIndex);
-                            let columnCursor = 0;
-                            for (let columnIndex = to.range.startColumnIndex; columnIndex <= to.range.endColumnIndex; columnIndex++, columnCursor++) {
-                                const dataColumnIndex = colSpan > 0 ? columnCursor % colSpan : 0;
-                                currentSheet[rowIndex].values[columnIndex] =
-                                    movedRowValues[dataRowIndex]?.[dataColumnIndex];
-                                for (const dependent of getDependents({
+                    });
+                    saveHistory({ tables: { patches, inversePatches } });
+                    return nextState;
+                });
+            }
+            // Update sheetdata
+            // Capture the produced state so we can stream the exact written cells to an engine
+            // consumer afterwards (branch-agnostic across cut / pure-paste / paste-special).
+            let pastedSheetData;
+            if (selectedRowValues.length) {
+                onChangeSheetData?.((prevSheetData) => {
+                    const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                        // For cut operation
+                        const movedKeys = new Set();
+                        /**
+                         * If user is deleting source cells,
+                         * let update its dependents and mark it as dirty
+                         */
+                        if (isCutOperation && from && to && !isNil(sourceSheetId)) {
+                            const sheetId = sourceSheetId;
+                            for (const [rowIndex, columnIndex] of iterateCellsInRange(from.range)) {
+                                // Process dependents
+                                processSideEffectDependentCells({
+                                    draft,
                                     rowIndex,
                                     columnIndex,
-                                    sheetId: destinationSheetId,
-                                })) {
-                                    if (isStaticNode(dependent)) {
+                                    sheetId,
+                                    destinationSheetId,
+                                    columnDelta,
+                                    enqueueGraphOperation,
+                                    enqueueCalculation: enqueue,
+                                    getDependents,
+                                    recalcCells,
+                                    rowDelta,
+                                    sourceRange: from.range,
+                                    movedKeys,
+                                    locale,
+                                    rowCount,
+                                    columnCount,
+                                });
+                            }
+                            // Snapshot source after dependent/formula rewrites, before
+                            // clearing it. The pre-cut clipboard snapshot still contains
+                            // stale formulas, so writing that snapshot would discard the
+                            // reference updates performed above.
+                            const movedRowValues = [];
+                            const sourceStartColumn = from.range.startColumnIndex;
+                            const sourceEndColumn = from.range.endColumnIndex + 1;
+                            for (let rowIndex = from.range.startRowIndex; rowIndex <= from.range.endRowIndex; rowIndex++) {
+                                movedRowValues.push((draft[sheetId]?.[rowIndex]?.values?.slice(sourceStartColumn, sourceEndColumn) ?? []));
+                            }
+                            // Delete source if required
+                            // Move values
+                            for (let rowIndex = from.range.startRowIndex; rowIndex <= from.range.endRowIndex; rowIndex++) {
+                                for (let columnIndex = from.range.startColumnIndex; columnIndex <= from.range.endColumnIndex; columnIndex++) {
+                                    if (!draft[sheetId][rowIndex]?.values?.[columnIndex]) {
                                         continue;
                                     }
-                                    const { position } = dependent;
-                                    enqueue({
-                                        type: "add",
-                                        position,
-                                        force: true,
-                                    });
-                                    recalcCells.set(createSheetCellIdentifier(position.sheetId, position.rowIndex, position.columnIndex), position);
+                                    draft[sheetId][rowIndex].values[columnIndex] =
+                                        {};
                                 }
-                                collectDataValidationTarget(dataValidationTargets, destinationSheetId, rowIndex, columnIndex, currentSheet[rowIndex].values[columnIndex]);
                             }
-                        }
-                    }
-                    if (currentTable && !isRowExpansion) {
-                        addCalculatedColumnsForRowExpansion({
-                            sheetId: destinationSheetId,
-                            currentTable,
-                            draft,
-                            enqueueCalculation: enqueue,
-                            recalcCells,
-                            locale,
-                            range: to.range,
-                            getDependents,
-                        });
-                    }
-                    // TBD: Move totalrow for tables
-                    // We are doing pure paste operation
-                    if (!isCutOperation) {
-                        const sheetCell = new SheetCell();
-                        const sourceCell = {
-                            rowIndex: to.range.startRowIndex,
-                            columnIndex: to.range.startColumnIndex,
-                        };
-                        for (const { rowIndex, dataRowIndex } of destinationRows) {
-                            const currentSheet = createSheetDraft(draft, destinationSheetId, rowIndex);
-                            let columnCursor = 0;
-                            for (let columnIndex = to.range.startColumnIndex; columnIndex <= to.range.endColumnIndex; columnIndex++, columnCursor++) {
-                                const dataColumnIndex = colSpan > 0 ? columnCursor % colSpan : 0;
-                                let cellValue = selectedRowValues[dataRowIndex]?.[dataColumnIndex];
-                                // Skip blanks: an empty clipboard cell leaves the
-                                // destination (value and format) untouched.
-                                if (pasteSpecial.skipBlanks &&
-                                    isBlankClipboardCell(cellValue)) {
-                                    continue;
-                                }
-                                // Operation: combine the pasted cell with the cell it
-                                // lands on. The clipboard is anchored at the FIRST tile,
-                                // so a source formula is relocated to the tile it lands
-                                // on first (the same `moveFormula` shift the plain paste
-                                // applies below); the composed `=(dest)op(source)` is
-                                // then anchored at the destination and must not be moved
-                                // again (that would shift the destination fragment too).
-                                if (pasteOperation) {
-                                    const sourceFormula = getExtendedValueFormula(getCellUserEnteredValue(cellValue));
-                                    if (!isNil(sourceFormula) &&
-                                        dataRowIndex === 0 &&
-                                        dataColumnIndex === 0 &&
-                                        (rowIndex !== sourceCell.rowIndex ||
-                                            columnIndex !== sourceCell.columnIndex)) {
-                                        const tileCell = new SheetCell();
-                                        tileCell.setLocale(locale);
-                                        tileCell.assign(destinationSheetId, sourceCell, cellValue);
-                                        tileCell.moveFormula(sourceCell, { rowIndex, columnIndex }, activeSheetName, { preserveAbsolutes: true });
-                                        cellValue = {
-                                            ...cellValue,
-                                            ue: { ...cellValue?.ue, fv: tileCell.formula },
-                                        };
+                            for (const { rowIndex, dataRowIndex } of destinationRows) {
+                                const currentSheet = createSheetDraft(draft, destinationSheetId, rowIndex);
+                                let columnCursor = 0;
+                                for (let columnIndex = to.range.startColumnIndex; columnIndex <= to.range.endColumnIndex; columnIndex++, columnCursor++) {
+                                    const dataColumnIndex = colSpan > 0 ? columnCursor % colSpan : 0;
+                                    currentSheet[rowIndex].values[columnIndex] =
+                                        movedRowValues[dataRowIndex]?.[dataColumnIndex];
+                                    for (const dependent of getDependents({
+                                        rowIndex,
+                                        columnIndex,
+                                        sheetId: destinationSheetId,
+                                    })) {
+                                        if (isStaticNode(dependent)) {
+                                            continue;
+                                        }
+                                        const { position } = dependent;
+                                        enqueue({
+                                            type: "add",
+                                            position,
+                                            force: true,
+                                        });
+                                        recalcCells.set(createSheetCellIdentifier(position.sheetId, position.rowIndex, position.columnIndex), position);
                                     }
-                                    cellValue = applyPasteOperation(cellValue, prevSheetData[destinationSheetId]?.[rowIndex]?.values?.[columnIndex], pasteOperation, destinationSheetId, locale);
-                                }
-                                if (pasteMode === "formats") {
-                                    const existingCellData = prevSheetData[destinationSheetId]?.[rowIndex]?.values?.[columnIndex];
-                                    cellValue = { ...existingCellData, ...cellValue };
-                                    sheetCell.extendCellData(cellValue);
+                                    collectDataValidationTarget(dataValidationTargets, destinationSheetId, rowIndex, columnIndex, currentSheet[rowIndex].values[columnIndex]);
                                 }
-                                if (pasteMode === "values" || forcePlainText) {
-                                    const existingCellData = prevSheetData[destinationSheetId]?.[rowIndex]?.values?.[columnIndex];
-                                    // Remove ss from existingCellData since we're replacing the value
-                                    const { ss: _ss, ...existingWithoutSs } = existingCellData ?? {};
-                                    cellValue = { ...existingWithoutSs, ...cellValue };
-                                    sheetCell.extendCellData(cellValue);
-                                }
-                                if (pasteSpecial.transpose && pasteMode === "all") {
-                                    sheetCell.assign(destinationSheetId, { rowIndex, columnIndex }, prevSheetData[destinationSheetId]?.[rowIndex]?.values?.[columnIndex], {
-                                        locale,
-                                        cellXfsRegistry,
-                                        getDataValidationById,
-                                        sharedStringRegistry,
-                                    });
-                                    const existingCellData = sheetCell.getUserCellData();
-                                    cellValue = { ...existingCellData, ...cellValue };
-                                    sheetCell.extendCellData(cellValue);
-                                }
-                                else {
-                                    sheetCell.assign(destinationSheetId, { rowIndex, columnIndex }, typeof cellValue === "object"
-                                        ? cellValue
-                                        : undefined, {
-                                        getRangeValues: getEffectiveValuesFromRange,
-                                        locale,
-                                        cellXfsRegistry,
-                                        getDataValidationById,
-                                        sharedStringRegistry,
-                                    });
-                                }
-                                if (pasteMode === "formats") {
-                                    sheetCell.refreshFormattedValue();
-                                }
-                                if (sheetCell.isFormula()) {
-                                    if (dataRowIndex === 0 &&
-                                        dataColumnIndex === 0 &&
-                                        !pasteOperation) {
-                                        sheetCell.moveFormula(sourceCell, {
-                                            rowIndex,
-                                            columnIndex,
-                                        }, activeSheetName, { preserveAbsolutes: true });
+                            }
+                        }
+                        // TBD: Move totalrow for tables
+                        // We are doing pure paste operation
+                        if (!isCutOperation) {
+                            renameHeaderCellsInFormulas({
+                                draft,
+                                headerRenames,
+                                enqueueCalculation: enqueue,
+                                enqueueGraphOperation,
+                                recalcCells,
+                                locale,
+                                cellXfsRegistry,
+                                sharedStringRegistry,
+                            });
+                            const sheetCell = new SheetCell();
+                            const sourceCell = {
+                                rowIndex: to.range.startRowIndex,
+                                columnIndex: to.range.startColumnIndex,
+                            };
+                            for (const { rowIndex, dataRowIndex } of destinationRows) {
+                                const currentSheet = createSheetDraft(draft, destinationSheetId, rowIndex);
+                                let columnCursor = 0;
+                                for (let columnIndex = to.range.startColumnIndex; columnIndex <= to.range.endColumnIndex; columnIndex++, columnCursor++) {
+                                    const dataColumnIndex = colSpan > 0 ? columnCursor % colSpan : 0;
+                                    let cellValue = selectedRowValues[dataRowIndex]?.[dataColumnIndex];
+                                    // Skip blanks: an empty clipboard cell leaves the
+                                    // destination (value and format) untouched.
+                                    if (pasteSpecial.skipBlanks &&
+                                        isBlankClipboardCell(cellValue)) {
+                                        continue;
                                     }
-                                    sheetCell.setLoading();
-                                    enqueue({
-                                        type: "add",
-                                        position: {
+                                    // Operation: combine the pasted cell with the cell it
+                                    // lands on. The clipboard is anchored at the FIRST tile,
+                                    // so a source formula is relocated to the tile it lands
+                                    // on first (the same `moveFormula` shift the plain paste
+                                    // applies below); the composed `=(dest)op(source)` is
+                                    // then anchored at the destination and must not be moved
+                                    // again (that would shift the destination fragment too).
+                                    if (pasteOperation) {
+                                        const sourceFormula = getExtendedValueFormula(getCellUserEnteredValue(cellValue));
+                                        if (!isNil(sourceFormula) &&
+                                            dataRowIndex === 0 &&
+                                            dataColumnIndex === 0 &&
+                                            (rowIndex !== sourceCell.rowIndex ||
+                                                columnIndex !== sourceCell.columnIndex)) {
+                                            const tileCell = new SheetCell();
+                                            tileCell.setLocale(locale);
+                                            tileCell.assign(destinationSheetId, sourceCell, cellValue);
+                                            tileCell.moveFormula(sourceCell, { rowIndex, columnIndex }, activeSheetName, { preserveAbsolutes: true });
+                                            cellValue = {
+                                                ...cellValue,
+                                                ue: { ...cellValue?.ue, fv: tileCell.formula },
+                                            };
+                                        }
+                                        cellValue = applyPasteOperation(cellValue, prevSheetData[destinationSheetId]?.[rowIndex]?.values?.[columnIndex], pasteOperation, destinationSheetId, locale);
+                                    }
+                                    if (pasteMode === "formats") {
+                                        const existingCellData = prevSheetData[destinationSheetId]?.[rowIndex]?.values?.[columnIndex];
+                                        cellValue = { ...existingCellData, ...cellValue };
+                                        sheetCell.extendCellData(cellValue);
+                                    }
+                                    if (pasteMode === "values" || forcePlainText) {
+                                        const existingCellData = prevSheetData[destinationSheetId]?.[rowIndex]?.values?.[columnIndex];
+                                        // Remove ss from existingCellData since we're replacing the value
+                                        const { ss: _ss, ...existingWithoutSs } = existingCellData ?? {};
+                                        cellValue = { ...existingWithoutSs, ...cellValue };
+                                        sheetCell.extendCellData(cellValue);
+                                    }
+                                    if (pasteSpecial.transpose && pasteMode === "all") {
+                                        sheetCell.assign(destinationSheetId, { rowIndex, columnIndex }, prevSheetData[destinationSheetId]?.[rowIndex]?.values?.[columnIndex], {
+                                            locale,
+                                            cellXfsRegistry,
+                                            getDataValidationById,
+                                            sharedStringRegistry,
+                                        });
+                                        const existingCellData = sheetCell.getUserCellData();
+                                        cellValue = { ...existingCellData, ...cellValue };
+                                        sheetCell.extendCellData(cellValue);
+                                    }
+                                    else {
+                                        sheetCell.assign(destinationSheetId, { rowIndex, columnIndex }, typeof cellValue === "object"
+                                            ? cellValue
+                                            : undefined, {
+                                            getRangeValues: getEffectiveValuesFromRange,
+                                            locale,
+                                            cellXfsRegistry,
+                                            getDataValidationById,
+                                            sharedStringRegistry,
+                                        });
+                                    }
+                                    if (pasteMode === "formats") {
+                                        sheetCell.refreshFormattedValue();
+                                    }
+                                    if (sheetCell.isFormula()) {
+                                        if (dataRowIndex === 0 &&
+                                            dataColumnIndex === 0 &&
+                                            !pasteOperation) {
+                                            sheetCell.moveFormula(sourceCell, {
+                                                rowIndex,
+                                                columnIndex,
+                                            }, activeSheetName, { preserveAbsolutes: true });
+                                        }
+                                        sheetCell.setLoading();
+                                        enqueue({
+                                            type: "add",
+                                            position: {
+                                                rowIndex,
+                                                columnIndex,
+                                                sheetId: destinationSheetId,
+                                            },
+                                            force: true,
+                                        });
+                                        recalcCells.set(createSheetCellIdentifier(destinationSheetId, rowIndex, columnIndex), {
                                             rowIndex,
                                             columnIndex,
                                             sheetId: destinationSheetId,
-                                        },
-                                        force: true,
-                                    });
-                                    recalcCells.set(createSheetCellIdentifier(destinationSheetId, rowIndex, columnIndex), {
+                                        });
+                                    }
+                                    for (const dependent of getDependents({
                                         rowIndex,
                                         columnIndex,
                                         sheetId: destinationSheetId,
-                                    });
-                                }
-                                for (const dependent of getDependents({
-                                    rowIndex,
-                                    columnIndex,
-                                    sheetId: destinationSheetId,
-                                })) {
-                                    if (isStaticNode(dependent)) {
-                                        continue;
+                                    })) {
+                                        if (isStaticNode(dependent)) {
+                                            continue;
+                                        }
+                                        const { position } = dependent;
+                                        enqueue({
+                                            type: "add",
+                                            position,
+                                            force: true,
+                                        });
+                                        recalcCells.set(createSheetCellIdentifier(position.sheetId, position.rowIndex, position.columnIndex), position);
                                     }
-                                    const { position } = dependent;
-                                    enqueue({
-                                        type: "add",
-                                        position,
-                                        force: true,
-                                    });
-                                    recalcCells.set(createSheetCellIdentifier(position.sheetId, position.rowIndex, position.columnIndex), position);
+                                    const headerRename = headerRenameAt.get(`${rowIndex}:${columnIndex}`);
+                                    if (headerRename) {
+                                        // A table header cell holds its column name as text.
+                                        sheetCell.setUserEnteredValue(headerRename.newName, undefined, { disableTypeInference: true });
+                                    }
+                                    sharedStringRegistry?.registerCell(sheetCell);
+                                    currentSheet[rowIndex].values[columnIndex] =
+                                        sheetCell.getCellData();
+                                    collectDataValidationTarget(dataValidationTargets, destinationSheetId, rowIndex, columnIndex, currentSheet[rowIndex].values[columnIndex]);
+                                    cellXfsRegistry?.registerCellXfs(sheetCell);
                                 }
-                                sharedStringRegistry?.registerCell(sheetCell);
-                                currentSheet[rowIndex].values[columnIndex] =
-                                    sheetCell.getCellData();
-                                collectDataValidationTarget(dataValidationTargets, destinationSheetId, rowIndex, columnIndex, currentSheet[rowIndex].values[columnIndex]);
-                                cellXfsRegistry?.registerCellXfs(sheetCell);
                             }
                         }
-                    }
-                });
-                saveHistory({
-                    sheetData: { patches, inversePatches },
-                    recalcCells: { undo: recalcCells, redo: recalcCells },
-                    activeCell: {
-                        undo: getActiveCell(),
-                        redo: getActiveCell(),
-                    },
-                    selections: {
-                        undo: undefined,
-                        redo: isSelectionACell(nextSelections) ? undefined : [to],
-                    },
+                    });
+                    saveHistory({
+                        sheetData: { patches, inversePatches },
+                        recalcCells: { undo: recalcCells, redo: recalcCells },
+                        activeCell: {
+                            undo: getActiveCell(),
+                            redo: getActiveCell(),
+                        },
+                        selections: {
+                            undo: undefined,
+                            redo: isSelectionACell(nextSelections) ? undefined : [to],
+                        },
+                    });
+                    extendDataValidationRanges(dataValidationTargets, onChangeDataValidations, saveHistory);
+                    processQueue();
+                    pastedSheetData = nextState;
+                    return nextState;
                 });
-                extendDataValidationRanges(dataValidationTargets, onChangeDataValidations, saveHistory);
-                processQueue();
-                pastedSheetData = nextState;
-                return nextState;
-            });
-            // Save registries
-            cellXfsRegistry?.getPatches(saveHistory);
-            sharedStringRegistry?.getPatches(saveHistory);
-            // Update row or column count
-            // Change sheets
-            onChangeSheets?.((prevSheets) => {
-                const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
-                    const sheet = draft.find((sheet) => sheet.sheetId === destinationSheetId);
-                    if (sheet) {
-                        sheet.rowCount = Math.min(maxRowCount, Math.max(sheet.rowCount ?? DEFAULT_ROW_COUNT, to.range.endRowIndex));
-                        sheet.columnCount = Math.min(maxColumnCount, Math.max(sheet.columnCount ?? DEFAULT_COLUMN_COUNT, to.range.endColumnIndex));
-                        // Handle merges for cut operations
-                        let mergesToAdd = merges;
-                        if (isCutOperation && from && !isNil(sourceSheetId)) {
-                            const sourceSheet = prevSheets.find((s) => s.sheetId === sourceSheetId);
-                            if (sourceSheet?.merges) {
-                                // Extract merged cells from source range
-                                const cutMerges = [];
-                                for (const merge of sourceSheet.merges) {
-                                    // Check if merge intersects with the cut range
-                                    if (areaIntersects(merge, from.range)) {
-                                        // Calculate new merge coordinates relative to destination
-                                        cutMerges.push({
-                                            startRowIndex: merge.startRowIndex + rowDelta,
-                                            startColumnIndex: merge.startColumnIndex + columnDelta,
-                                            endRowIndex: merge.endRowIndex + rowDelta,
-                                            endColumnIndex: merge.endColumnIndex + columnDelta,
-                                        });
+                // Save registries
+                cellXfsRegistry?.getPatches(saveHistory);
+                sharedStringRegistry?.getPatches(saveHistory);
+                // Update row or column count
+                // Change sheets
+                onChangeSheets?.((prevSheets) => {
+                    const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
+                        const sheet = draft.find((sheet) => sheet.sheetId === destinationSheetId);
+                        if (sheet) {
+                            sheet.rowCount = Math.min(maxRowCount, Math.max(sheet.rowCount ?? DEFAULT_ROW_COUNT, to.range.endRowIndex));
+                            sheet.columnCount = Math.min(maxColumnCount, Math.max(sheet.columnCount ?? DEFAULT_COLUMN_COUNT, to.range.endColumnIndex));
+                            // Handle merges for cut operations
+                            let mergesToAdd = merges;
+                            if (isCutOperation && from && !isNil(sourceSheetId)) {
+                                const sourceSheet = prevSheets.find((s) => s.sheetId === sourceSheetId);
+                                if (sourceSheet?.merges) {
+                                    // Extract merged cells from source range
+                                    const cutMerges = [];
+                                    for (const merge of sourceSheet.merges) {
+                                        // Check if merge intersects with the cut range
+                                        if (areaIntersects(merge, from.range)) {
+                                            // Calculate new merge coordinates relative to destination
+                                            cutMerges.push({
+                                                startRowIndex: merge.startRowIndex + rowDelta,
+                                                startColumnIndex: merge.startColumnIndex + columnDelta,
+                                                endRowIndex: merge.endRowIndex + rowDelta,
+                                                endColumnIndex: merge.endColumnIndex + columnDelta,
+                                            });
+                                        }
+                                    }
+                                    if (cutMerges.length > 0) {
+                                        mergesToAdd = cutMerges;
+                                    }
+                                    // Remove merges from source sheet
+                                    const sourceSheetDraft = draft.find((s) => s.sheetId === sourceSheetId);
+                                    if (sourceSheetDraft?.merges) {
+                                        sourceSheetDraft.merges = sourceSheetDraft.merges.filter((merge) => !areaIntersects(merge, from.range));
                                     }
-                                }
-                                if (cutMerges.length > 0) {
-                                    mergesToAdd = cutMerges;
-                                }
-                                // Remove merges from source sheet
-                                const sourceSheetDraft = draft.find((s) => s.sheetId === sourceSheetId);
-                                if (sourceSheetDraft?.merges) {
-                                    sourceSheetDraft.merges = sourceSheetDraft.merges.filter((merge) => !areaIntersects(merge, from.range));
                                 }
                             }
-                        }
-                        // Update merges
-                        if (mergesToAdd) {
-                            sheet.merges = sheet.merges ?? [];
-                            for (const merge of mergesToAdd) {
-                                const exists = sheet.merges.find((range) => isAreasEqual(range, merge));
-                                if (!exists) {
-                                    sheet.merges.push(merge);
+                            // Update merges
+                            if (mergesToAdd) {
+                                sheet.merges = sheet.merges ?? [];
+                                for (const merge of mergesToAdd) {
+                                    const exists = sheet.merges.find((range) => isAreasEqual(range, merge));
+                                    if (!exists) {
+                                        sheet.merges.push(merge);
+                                    }
                                 }
                             }
-                        }
-                        // Row heights
-                        const clipboardSizedRows = new Set();
-                        if (rowHeights) {
-                            if (!sheet.rowMetadata) {
-                                sheet.rowMetadata = [];
-                            }
-                            for (let index = 0; index < rowHeights.length; index++) {
-                                const curHeight = rowHeights[index];
-                                if (isNil(curHeight) || curHeight === 0) {
-                                    continue;
-                                }
-                                const rowIndex = visibleRowIndexes[index];
-                                if (isNil(rowIndex)) {
-                                    break;
+                            // Row heights
+                            const clipboardSizedRows = new Set();
+                            if (rowHeights) {
+                                if (!sheet.rowMetadata) {
+                                    sheet.rowMetadata = [];
                                 }
-                                if (!sheet.rowMetadata[rowIndex]) {
-                                    sheet.rowMetadata[rowIndex] = {};
-                                }
-                                sheet.rowMetadata[rowIndex].size = curHeight;
-                                clipboardSizedRows.add(rowIndex);
-                            }
-                        }
-                        // Auto-resize rows whose pasted content needs more room
-                        // (multi-line text or wrap). Mirrors use-on-change's
-                        // adjustRowHeight, but batched into this immer pass so the
-                        // whole paste collapses to one undo entry. Skip conditions
-                        // make the common single-line-text paste do zero work.
-                        // Skipped for paste-special variants since the destination
-                        // cell ends up as a merge of existing + pasted data, not
-                        // the raw pasted value we can read from selectedRowValues.
-                        const skipAutoResize = pasteSpecial.isSpecial;
-                        if (!skipAutoResize &&
-                            getFinalRowHeight &&
-                            selectedRowValues.length &&
-                            colSpan > 0) {
-                            for (const { rowIndex, dataRowIndex } of destinationRows) {
-                                // Clipboard-provided row heights win.
-                                if (clipboardSizedRows.has(rowIndex))
-                                    continue;
-                                const rowData = selectedRowValues[dataRowIndex];
-                                if (!rowData)
-                                    continue;
-                                // Find the cell most likely to drive row height —
-                                // most lines first, then any wrap. If no cell in
-                                // the row needs more than one line and no cell is
-                                // wrapped, the row's existing height already fits.
-                                let bestLines = 1;
-                                let bestColumnIndex;
-                                let bestCell;
-                                let bestHasWrap = false;
-                                let columnCursor = 0;
-                                for (let columnIndex = to.range.startColumnIndex; columnIndex <= to.range.endColumnIndex; columnIndex++, columnCursor++) {
-                                    const dataColumnIndex = columnCursor % colSpan;
-                                    const cellValue = rowData[dataColumnIndex];
-                                    if (!cellValue || typeof cellValue !== "object")
+                                for (let index = 0; index < rowHeights.length; index++) {
+                                    const curHeight = rowHeights[index];
+                                    if (isNil(curHeight) || curHeight === 0) {
                                         continue;
-                                    const ue = getCellUserEnteredValue(cellValue);
-                                    const text = getExtendedValueString(ue);
-                                    const lines = typeof text === "string" && text.includes("\n")
-                                        ? text.split("\n").length
-                                        : 1;
-                                    const uf = getCellUserEnteredFormat(cellValue);
-                                    const wrap = uf
-                                        ?.wrapStrategy === "wrap";
-                                    if (lines > bestLines ||
-                                        (lines === bestLines && wrap && !bestHasWrap)) {
-                                        bestLines = lines;
-                                        bestCell = cellValue;
-                                        bestColumnIndex = columnIndex;
-                                        bestHasWrap = wrap;
                                     }
-                                }
-                                if (!bestCell ||
-                                    bestColumnIndex === undefined ||
-                                    (bestLines === 1 && !bestHasWrap)) {
-                                    continue;
-                                }
-                                const ue = getCellUserEnteredValue(bestCell);
-                                const overrideText = getExtendedValueString(ue) ?? "";
-                                const uf = getCellUserEnteredFormat(bestCell);
-                                const height = getFinalRowHeight(destinationSheetId, rowIndex, bestColumnIndex, {
-                                    textOverride: String(overrideText),
-                                    textFormatOverride: uf?.textFormat,
-                                    shouldWrapOverride: bestHasWrap,
-                                });
-                                if (typeof height === "number" && height > 0) {
-                                    if (!sheet.rowMetadata)
-                                        sheet.rowMetadata = [];
+                                    const rowIndex = visibleRowIndexes[index];
+                                    if (isNil(rowIndex)) {
+                                        break;
+                                    }
                                     if (!sheet.rowMetadata[rowIndex]) {
                                         sheet.rowMetadata[rowIndex] = {};
                                     }
-                                    sheet.rowMetadata[rowIndex].size = height;
-                                    sheet.rowMetadata[rowIndex].resizedByUser = false;
+                                    sheet.rowMetadata[rowIndex].size = curHeight;
+                                    clipboardSizedRows.add(rowIndex);
                                 }
                             }
-                        }
-                        // column widths
-                        if (columnWidths) {
-                            if (!sheet.columnMetadata) {
-                                sheet.columnMetadata = [];
+                            // Auto-resize rows whose pasted content needs more room
+                            // (multi-line text or wrap). Mirrors use-on-change's
+                            // adjustRowHeight, but batched into this immer pass so the
+                            // whole paste collapses to one undo entry. Skip conditions
+                            // make the common single-line-text paste do zero work.
+                            // Skipped for paste-special variants since the destination
+                            // cell ends up as a merge of existing + pasted data, not
+                            // the raw pasted value we can read from selectedRowValues.
+                            const skipAutoResize = pasteSpecial.isSpecial;
+                            if (!skipAutoResize &&
+                                getFinalRowHeight &&
+                                selectedRowValues.length &&
+                                colSpan > 0) {
+                                for (const { rowIndex, dataRowIndex } of destinationRows) {
+                                    // Clipboard-provided row heights win.
+                                    if (clipboardSizedRows.has(rowIndex))
+                                        continue;
+                                    const rowData = selectedRowValues[dataRowIndex];
+                                    if (!rowData)
+                                        continue;
+                                    // Find the cell most likely to drive row height —
+                                    // most lines first, then any wrap. If no cell in
+                                    // the row needs more than one line and no cell is
+                                    // wrapped, the row's existing height already fits.
+                                    let bestLines = 1;
+                                    let bestColumnIndex;
+                                    let bestCell;
+                                    let bestHasWrap = false;
+                                    let columnCursor = 0;
+                                    for (let columnIndex = to.range.startColumnIndex; columnIndex <= to.range.endColumnIndex; columnIndex++, columnCursor++) {
+                                        const dataColumnIndex = columnCursor % colSpan;
+                                        const cellValue = rowData[dataColumnIndex];
+                                        if (!cellValue || typeof cellValue !== "object")
+                                            continue;
+                                        const ue = getCellUserEnteredValue(cellValue);
+                                        const text = getExtendedValueString(ue);
+                                        const lines = typeof text === "string" && text.includes("\n")
+                                            ? text.split("\n").length
+                                            : 1;
+                                        const uf = getCellUserEnteredFormat(cellValue);
+                                        const wrap = uf
+                                            ?.wrapStrategy === "wrap";
+                                        if (lines > bestLines ||
+                                            (lines === bestLines && wrap && !bestHasWrap)) {
+                                            bestLines = lines;
+                                            bestCell = cellValue;
+                                            bestColumnIndex = columnIndex;
+                                            bestHasWrap = wrap;
+                                        }
+                                    }
+                                    if (!bestCell ||
+                                        bestColumnIndex === undefined ||
+                                        (bestLines === 1 && !bestHasWrap)) {
+                                        continue;
+                                    }
+                                    const ue = getCellUserEnteredValue(bestCell);
+                                    const overrideText = getExtendedValueString(ue) ?? "";
+                                    const uf = getCellUserEnteredFormat(bestCell);
+                                    const height = getFinalRowHeight(destinationSheetId, rowIndex, bestColumnIndex, {
+                                        textOverride: String(overrideText),
+                                        textFormatOverride: uf?.textFormat,
+                                        shouldWrapOverride: bestHasWrap,
+                                    });
+                                    if (typeof height === "number" && height > 0) {
+                                        if (!sheet.rowMetadata)
+                                            sheet.rowMetadata = [];
+                                        if (!sheet.rowMetadata[rowIndex]) {
+                                            sheet.rowMetadata[rowIndex] = {};
+                                        }
+                                        sheet.rowMetadata[rowIndex].size = height;
+                                        sheet.rowMetadata[rowIndex].resizedByUser = false;
+                                    }
+                                }
                             }
-                            for (let index = 0; index < columnWidths.length; index++) {
-                                const curWidth = columnWidths[index];
-                                if (isNil(curWidth) || curWidth === 0) {
-                                    continue;
+                            // column widths
+                            if (columnWidths) {
+                                if (!sheet.columnMetadata) {
+                                    sheet.columnMetadata = [];
                                 }
-                                const columnIndex = to.range.startColumnIndex + index;
-                                if (!sheet.columnMetadata?.[columnIndex]) {
-                                    sheet.columnMetadata[columnIndex] = {};
+                                for (let index = 0; index < columnWidths.length; index++) {
+                                    const curWidth = columnWidths[index];
+                                    if (isNil(curWidth) || curWidth === 0) {
+                                        continue;
+                                    }
+                                    const columnIndex = to.range.startColumnIndex + index;
+                                    if (!sheet.columnMetadata?.[columnIndex]) {
+                                        sheet.columnMetadata[columnIndex] = {};
+                                    }
+                                    sheet.columnMetadata[columnIndex].size =
+                                        columnWidths[index];
                                 }
-                                sheet.columnMetadata[columnIndex].size =
-                                    columnWidths[index];
                             }
                         }
-                    }
-                });
-                saveHistory({
-                    sheets: { patches, inversePatches },
+                    });
+                    saveHistory({
+                        sheets: { patches, inversePatches },
+                    });
+                    return nextState;
                 });
-                return nextState;
-            });
-            // For row expansions, add columns
-            onChangeTableColumn(destinationSheetId, activeCell, activeCellValue ?? undefined, adjacentTable, isRowExpansion, isColumnExpansion, to.range);
-            // Add calculated column
-            onChangeCalculatedColumn(destinationSheetId, activeCell, activeCellValue ?? undefined, currentTable);
-            // Update new selections
-            if (!isSelectionACell(nextSelections)) {
-                onChangeSelections?.(destinationSheetId, [to]);
-            }
-            // Update active cell
-            onChangeActiveCell(destinationSheetId, { ...getActiveCell() });
-            // Stream the paste to an engine consumer. The clipboard is a bounded payload (not
-            // windowed), so paste can resolve the destination cells UI-side; we read back the
-            // user-entered values the paste actually produced — relocated formulas, paste-special
-            // merges, shared-string text — and replay them as a `change-batch` the engine recomputes
-            // from. Reading the produced state (rather than re-deriving) keeps this correct across the
-            // cut / pure-paste / paste-special branches without duplicating their logic.
-            if (onCommand && pastedSheetData) {
-                const values = [];
-                for (let rowIndex = to.range.startRowIndex; rowIndex <= to.range.endRowIndex; rowIndex++) {
-                    const row = [];
-                    for (let columnIndex = to.range.startColumnIndex; columnIndex <= to.range.endColumnIndex; columnIndex++) {
-                        const cell = pastedSheetData[destinationSheetId]?.[rowIndex]?.values?.[columnIndex];
-                        const ue = cell ? getCellUserEnteredValue(cell) : undefined;
-                        // Formula text wins (e.g. "=SUM(A1:A2)"), else the literal string / number / bool.
-                        // `??` (not `||`) so 0 and false survive; `null` clears the cell.
-                        row.push(getExtendedValueFormula(ue) ??
-                            getExtendedValueString(ue) ??
-                            getExtendedValueNumber(ue) ??
-                            getExtendedValueBool(ue) ??
-                            null);
-                    }
-                    values.push(row);
+                // For row expansions, add columns
+                onChangeTableColumn(destinationSheetId, activeCell, activeCellValue ?? undefined, adjacentTable, isRowExpansion, isColumnExpansion, to.range, pastedHeaderValues);
+                // Add calculated column
+                onChangeCalculatedColumn(destinationSheetId, activeCell, activeCellValue ?? undefined, currentTable);
+                // Update new selections
+                if (!isSelectionACell(nextSelections)) {
+                    onChangeSelections?.(destinationSheetId, [to]);
                 }
-                onCommand({
-                    command: "change-batch",
-                    sheetId: destinationSheetId,
-                    ranges: to.range,
-                    values,
-                });
-                // On cut, the source cells were cleared — mirror that so the engine drops them too.
-                if (isCutOperation && from && !isNil(sourceSheetId)) {
+                // Update active cell
+                onChangeActiveCell(destinationSheetId, { ...getActiveCell() });
+                // Stream the paste to an engine consumer. The clipboard is a bounded payload (not
+                // windowed), so paste can resolve the destination cells UI-side; we read back the
+                // user-entered values the paste actually produced — relocated formulas, paste-special
+                // merges, shared-string text — and replay them as a `change-batch` the engine recomputes
+                // from. Reading the produced state (rather than re-deriving) keeps this correct across the
+                // cut / pure-paste / paste-special branches without duplicating their logic.
+                if (onCommand && pastedSheetData) {
+                    const values = [];
+                    for (let rowIndex = to.range.startRowIndex; rowIndex <= to.range.endRowIndex; rowIndex++) {
+                        const row = [];
+                        for (let columnIndex = to.range.startColumnIndex; columnIndex <= to.range.endColumnIndex; columnIndex++) {
+                            const cell = pastedSheetData[destinationSheetId]?.[rowIndex]?.values?.[columnIndex];
+                            const ue = cell ? getCellUserEnteredValue(cell) : undefined;
+                            // Formula text wins (e.g. "=SUM(A1:A2)"), else the literal string / number / bool.
+                            // `??` (not `||`) so 0 and false survive; `null` clears the cell.
+                            row.push(getExtendedValueFormula(ue) ??
+                                getExtendedValueString(ue) ??
+                                getExtendedValueNumber(ue) ??
+                                getExtendedValueBool(ue) ??
+                                null);
+                        }
+                        values.push(row);
+                    }
                     onCommand({
-                        command: "delete-cells",
-                        sheetId: sourceSheetId,
-                        activeCell: {
-                            rowIndex: from.range.startRowIndex,
-                            columnIndex: from.range.startColumnIndex,
-                        },
-                        selections: [{ range: from.range }],
+                        command: "change-batch",
+                        sheetId: destinationSheetId,
+                        ranges: to.range,
+                        values,
+                        ...(autoExpandTables ? {} : { autoExpandTables }),
+                        ...(autoCalculatedColumns ? {} : { autoCalculatedColumns }),
                     });
-                }
-            }
-        }
-        // Embeds
-        if (embeds?.length) {
-            const firstEmbedId = embeds[0].embedId;
-            onChangeEmbeds?.((prevEmbeds) => {
-                const [nextState, patches, inversePatches] = produceWithPatches(prevEmbeds, (draft) => {
-                    draft.push(...embeds);
-                });
-                saveHistory({
-                    embeds: { patches, inversePatches },
-                    selectedEmbedOrChart: { redo: firstEmbedId, undo: undefined },
-                });
-                return nextState;
-            });
-            // Selected first embed
-            focusEmbedOrChart(embeds[0].embedId);
-        }
-        // Tables
-        if (tables?.length) {
-            onChangeTables?.((prevTables) => {
-                const [nextState, patches, inversePatches] = produceWithPatches(prevTables, (draft) => {
-                    draft.push(...tables);
-                });
-                saveHistory({
-                    tables: { patches, inversePatches },
-                });
-                return nextState;
-            });
-        }
-        // Handle citations
-        if (selectedRowValues.length && onChangeCitations) {
-            // Collect citationIds from pasted cells
-            const citationIdMap = new Map();
-            for (let dataRowIndex = 0; dataRowIndex < rowSpan; dataRowIndex++) {
-                const rowData = selectedRowValues[dataRowIndex];
-                if (!rowData)
-                    continue;
-                for (let dataColumnIndex = 0; dataColumnIndex < colSpan; dataColumnIndex++) {
-                    const cellValue = rowData[dataColumnIndex];
-                    if (cellValue &&
-                        typeof cellValue === "object" &&
-                        "citationId" in cellValue &&
-                        cellValue.citationId) {
-                        citationIdMap.set(cellValue.citationId, {
-                            sourceRowIndex: dataRowIndex,
-                            sourceColumnIndex: dataColumnIndex,
+                    // On cut, the source cells were cleared — mirror that so the engine drops them too.
+                    if (isCutOperation && from && !isNil(sourceSheetId)) {
+                        onCommand({
+                            command: "delete-cells",
+                            sheetId: sourceSheetId,
+                            activeCell: {
+                                rowIndex: from.range.startRowIndex,
+                                columnIndex: from.range.startColumnIndex,
+                            },
+                            selections: [{ range: from.range }],
                         });
                     }
                 }
             }
-            if (citationIdMap.size > 0) {
-                if (isCutOperation && from && !isNil(sourceSheetId)) {
-                    // For cut operation: Move citations to new position
-                    onChangeCitations((prevCitations) => {
-                        const [nextState, patches, inversePatches] = produceWithPatches(prevCitations, (draft) => {
-                            for (const citationId of citationIdMap.keys()) {
-                                const citation = draft.find((c) => c.id === citationId);
-                                if (citation) {
-                                    // Update citation range to new position
-                                    citation.range.sheetId = destinationSheetId;
-                                    citation.range.startRowIndex += rowDelta;
-                                    citation.range.endRowIndex += rowDelta;
-                                    citation.range.startColumnIndex += columnDelta;
-                                    citation.range.endColumnIndex += columnDelta;
+            // Defined names wholly inside the cut block follow it (Excel move semantics); a name the
+            // block covers only partially keeps referring to its original area.
+            if (isCutOperation && from && !isNil(sourceSheetId)) {
+                onChangeNamedRanges?.((prevNamedRanges) => {
+                    const [nextState, patches, inversePatches] = produceWithPatches(prevNamedRanges, (draft) => {
+                        for (const namedRange of draft) {
+                            if (namedRange.range?.sheetId === sourceSheetId &&
+                                areaInsideArea(namedRange.range, from.range)) {
+                                namedRange.range = {
+                                    ...moveRange(namedRange.range, from.range, to.range),
+                                    sheetId: destinationSheetId,
+                                };
+                            }
+                        }
+                    });
+                    if (!patches.length) {
+                        return prevNamedRanges;
+                    }
+                    saveHistory({ namedRanges: { patches, inversePatches } });
+                    return nextState;
+                });
+                onChangeCharts?.((prevCharts) => {
+                    const [nextState, patches, inversePatches] = produceWithPatches(prevCharts, (draft) => {
+                        moveChartsOnRangeMove(draft, sourceSheetId, from.range, destinationSheetId, to.range);
+                    });
+                    if (!patches.length) {
+                        return prevCharts;
+                    }
+                    saveHistory({ charts: { patches, inversePatches } });
+                    return nextState;
+                });
+                // The tables the cut block covers whole move with their cells (same history step): the
+                // range lands at the destination — on another sheet too — and the column-indexed filter
+                // and sort specs follow it, so the table's filters and its structured references keep
+                // resolving there.
+                if (movedTables.length) {
+                    const columnDelta = to.range.startColumnIndex - from.range.startColumnIndex;
+                    onChangeTables?.((prevTables) => {
+                        const [nextState, patches, inversePatches] = produceWithPatches(prevTables, (draft) => {
+                            for (const table of draft) {
+                                if (!movedTables.some((moved) => moved.id === table.id)) {
+                                    continue;
+                                }
+                                table.sheetId = destinationSheetId;
+                                const range = moveRange(table.range, from.range, to.range);
+                                table.range =
+                                    "sheetId" in range
+                                        ? { ...range, sheetId: destinationSheetId }
+                                        : range;
+                                for (const spec of table.filterSpecs ?? []) {
+                                    spec.columnIndex += columnDelta;
+                                }
+                                for (const spec of table.sortSpecs ?? []) {
+                                    spec.dimensionIndex += columnDelta;
                                 }
                             }
                         });
-                        saveHistory({
-                            citations: { patches, inversePatches },
-                        });
+                        saveHistory({ tables: { patches, inversePatches } });
                         return nextState;
                     });
                 }
-                else if (!isCutOperation) {
-                    // For paste (copy) operation: Create new citations with new IDs
-                    const newCitations = [];
-                    const citationIdRemap = new Map();
-                    for (const [oldCitationId, { sourceRowIndex, sourceColumnIndex },] of citationIdMap.entries()) {
-                        const originalCitation = citations?.find((c) => c.id === oldCitationId);
-                        if (originalCitation) {
-                            const newId = uuidString();
-                            citationIdRemap.set(oldCitationId, newId);
-                            // Calculate the new range based on paste destination
-                            const newCitation = {
-                                ...originalCitation,
-                                id: newId,
-                                range: {
-                                    sheetId: destinationSheetId,
-                                    startRowIndex: to.range.startRowIndex + sourceRowIndex,
-                                    endRowIndex: to.range.startRowIndex + sourceRowIndex,
-                                    startColumnIndex: to.range.startColumnIndex + sourceColumnIndex,
-                                    endColumnIndex: to.range.startColumnIndex + sourceColumnIndex,
-                                },
-                            };
-                            newCitations.push(newCitation);
+            }
+            // Embeds
+            if (embeds?.length) {
+                const firstEmbedId = embeds[0].embedId;
+                onChangeEmbeds?.((prevEmbeds) => {
+                    const [nextState, patches, inversePatches] = produceWithPatches(prevEmbeds, (draft) => {
+                        draft.push(...embeds);
+                    });
+                    saveHistory({
+                        embeds: { patches, inversePatches },
+                        selectedEmbedOrChart: { redo: firstEmbedId, undo: undefined },
+                    });
+                    return nextState;
+                });
+                // Selected first embed
+                focusEmbedOrChart(embeds[0].embedId);
+            }
+            // Tables
+            if (tables?.length) {
+                onChangeTables?.((prevTables) => {
+                    const [nextState, patches, inversePatches] = produceWithPatches(prevTables, (draft) => {
+                        // Excel names a pasted table like a new one — the next free `TableN` — never
+                        // `Copy of <title>`, which is not a valid table name (it has a space).
+                        for (const table of tables) {
+                            draft.push({
+                                ...table,
+                                title: getNextTableTitle(draft, generatedNames),
+                            });
+                        }
+                    });
+                    saveHistory({
+                        tables: { patches, inversePatches },
+                    });
+                    return nextState;
+                });
+            }
+            // Handle citations
+            if (selectedRowValues.length && onChangeCitations) {
+                // Collect citationIds from pasted cells
+                const citationIdMap = new Map();
+                for (let dataRowIndex = 0; dataRowIndex < rowSpan; dataRowIndex++) {
+                    const rowData = selectedRowValues[dataRowIndex];
+                    if (!rowData)
+                        continue;
+                    for (let dataColumnIndex = 0; dataColumnIndex < colSpan; dataColumnIndex++) {
+                        const cellValue = rowData[dataColumnIndex];
+                        if (cellValue &&
+                            typeof cellValue === "object" &&
+                            "citationId" in cellValue &&
+                            cellValue.citationId) {
+                            citationIdMap.set(cellValue.citationId, {
+                                sourceRowIndex: dataRowIndex,
+                                sourceColumnIndex: dataColumnIndex,
+                            });
                         }
                     }
-                    if (newCitations.length > 0) {
-                        // Add new citations
+                }
+                if (citationIdMap.size > 0) {
+                    if (isCutOperation && from && !isNil(sourceSheetId)) {
+                        // For cut operation: Move citations to new position
                         onChangeCitations((prevCitations) => {
                             const [nextState, patches, inversePatches] = produceWithPatches(prevCitations, (draft) => {
-                                draft.push(...newCitations);
+                                for (const citationId of citationIdMap.keys()) {
+                                    const citation = draft.find((c) => c.id === citationId);
+                                    if (citation) {
+                                        // Update citation range to new position
+                                        citation.range.sheetId = destinationSheetId;
+                                        citation.range.startRowIndex += rowDelta;
+                                        citation.range.endRowIndex += rowDelta;
+                                        citation.range.startColumnIndex += columnDelta;
+                                        citation.range.endColumnIndex += columnDelta;
+                                    }
+                                }
                             });
                             saveHistory({
                                 citations: { patches, inversePatches },
                             });
                             return nextState;
                         });
-                        // Update cell citationIds to point to new citations
-                        onChangeSheetData?.((prevSheetData) => {
-                            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
-                                for (const { rowIndex } of destinationRows) {
-                                    for (let columnIndex = to.range.startColumnIndex; columnIndex <= to.range.endColumnIndex; columnIndex++) {
-                                        const cellData = draft[destinationSheetId]?.[rowIndex]?.values?.[columnIndex];
-                                        if (cellData?.citationId) {
-                                            const newCitationId = citationIdRemap.get(cellData.citationId);
-                                            if (newCitationId) {
-                                                cellData.citationId = newCitationId;
+                    }
+                    else if (!isCutOperation) {
+                        // For paste (copy) operation: Create new citations with new IDs
+                        const newCitations = [];
+                        const citationIdRemap = new Map();
+                        for (const [oldCitationId, { sourceRowIndex, sourceColumnIndex },] of citationIdMap.entries()) {
+                            const originalCitation = citations?.find((c) => c.id === oldCitationId);
+                            if (originalCitation) {
+                                const newId = uuidString();
+                                citationIdRemap.set(oldCitationId, newId);
+                                // Calculate the new range based on paste destination
+                                const newCitation = {
+                                    ...originalCitation,
+                                    id: newId,
+                                    range: {
+                                        sheetId: destinationSheetId,
+                                        startRowIndex: to.range.startRowIndex + sourceRowIndex,
+                                        endRowIndex: to.range.startRowIndex + sourceRowIndex,
+                                        startColumnIndex: to.range.startColumnIndex + sourceColumnIndex,
+                                        endColumnIndex: to.range.startColumnIndex + sourceColumnIndex,
+                                    },
+                                };
+                                newCitations.push(newCitation);
+                            }
+                        }
+                        if (newCitations.length > 0) {
+                            // Add new citations
+                            onChangeCitations((prevCitations) => {
+                                const [nextState, patches, inversePatches] = produceWithPatches(prevCitations, (draft) => {
+                                    draft.push(...newCitations);
+                                });
+                                saveHistory({
+                                    citations: { patches, inversePatches },
+                                });
+                                return nextState;
+                            });
+                            // Update cell citationIds to point to new citations
+                            onChangeSheetData?.((prevSheetData) => {
+                                const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                                    for (const { rowIndex } of destinationRows) {
+                                        for (let columnIndex = to.range.startColumnIndex; columnIndex <= to.range.endColumnIndex; columnIndex++) {
+                                            const cellData = draft[destinationSheetId]?.[rowIndex]?.values?.[columnIndex];
+                                            if (cellData?.citationId) {
+                                                const newCitationId = citationIdRemap.get(cellData.citationId);
+                                                if (newCitationId) {
+                                                    cellData.citationId = newCitationId;
+                                                }
                                             }
                                         }
                                     }
-                                }
-                            });
-                            saveHistory({
-                                sheetData: { patches, inversePatches },
+                                });
+                                saveHistory({
+                                    sheetData: { patches, inversePatches },
+                                });
+                                return nextState;
                             });
-                            return nextState;
-                        });
+                        }
                     }
                 }
             }
-        }
+        });
     }, [
         rowCount,
         columnCount,
@@ -873,6 +1048,9 @@ export const useOnPaste = ({ rowCount, columnCount, locale, sheetData, tables: c
         onRequestFonts,
         idCreationStrategy,
         createHistory,
+        batchHistory,
+        autoExpandTables,
+        autoCalculatedColumns,
         enqueueStructureChange,
         enqueueGraphOperation,
         onChangeCalculatedColumn,
@@ -899,5 +1077,9 @@ export const useOnPaste = ({ rowCount, columnCount, locale, sheetData, tables: c
         getFinalRowHeight,
         onCommand,
         generatedNames,
+        onChangeNamedRanges,
+        onChangeCharts,
+        getSheetMerges,
+        showError,
     ]);
 };