@rowsncolumns/y-spreadsheet 14.0.32

package/dist/cjs/helpers.js

@@ -0,0 +1,1635 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processSheetDataEventsV3 = exports.addSheetDataPatchesV3 = exports.getSheetDataV3 = exports.deleteSheetV3 = exports.deleteCellV3 = exports.setCellV3 = exports.getCellV3 = exports.sheetDataV3ToV2 = exports.sheetDataV2ToV3 = exports.createCellDataV3 = exports.parseCellKeyV3 = exports.createCellKeyV3 = exports.processSheetDataEvents = exports.applyMapPatches = exports.validateSheets = exports.updateArrayType = exports.mergeErrorEffectiveValueIntoCellData = exports.shouldPersistErrorCellPatch = exports.filterErrorCellPatches = exports.getCellDataErrorValue = exports.getCellDataFromYSheetData = exports.removeRowData = exports.setCellDataInRowData = exports.getRowDataFromSheet = exports.deleteSheetFromYSheetData = exports.getSheetFromYSheetData = exports.addSheetDataPatches = exports.applyPatchesToYDoc = void 0;
+var tslib_1 = require("tslib");
+var utils_1 = require("@rowsncolumns/utils");
+var Y = tslib_1.__importStar(require("yjs"));
+var cloneDeep_1 = tslib_1.__importDefault(require("lodash/cloneDeep"));
+var isEqual_1 = tslib_1.__importDefault(require("lodash/isEqual"));
+var set_1 = tslib_1.__importDefault(require("lodash/set"));
+var get_1 = tslib_1.__importDefault(require("lodash/get"));
+var unset_1 = tslib_1.__importDefault(require("lodash/unset"));
+/**
+ * Apply patches to yjs
+ * @param doc
+ * @param userId
+ * @param patches
+ * @param source
+ * @param sheetDataVersion - Version of sheet data format ("v2" or "v3"). Falls back to docMeta if undefined.
+ */
+var applyPatchesToYDoc = function (doc, userId, patches, source, sheetDataVersion) {
+    var e_1, _a;
+    var _b, _c;
+    var ySheetDataV2 = doc.getMap("sheetDataV2");
+    var ySheetDataV3 = doc.getMap("sheetDataV3");
+    var yDocMeta = doc.getMap("docMeta");
+    var yRecalcCells = doc.getArray("recalcCells");
+    var ySheets = doc.getArray("sheets");
+    var yTables = doc.getArray("tables");
+    var yEmbeds = doc.getArray("embeds");
+    var yCharts = doc.getArray("charts");
+    var yConditionalFormats = doc.getArray("conditionalFormats");
+    var yDataValidations = doc.getArray("dataValidations");
+    var yNamedRanges = doc.getArray("namedRanges");
+    var ySharedStringsMap = doc.getMap("sharedStringsMap");
+    var yProtectedRanges = doc.getArray("protectedRanges");
+    var yCellXfs = doc.getMap("cellXfs");
+    var yDisableRecalc = doc.getMap("disableRecalc");
+    // Check version flag to determine which sheet data format to use
+    // Use param if provided, otherwise fall back to docMeta for backwards compatibility
+    var resolvedVersion = sheetDataVersion !== null && sheetDataVersion !== void 0 ? sheetDataVersion : yDocMeta.get("sheetDataVersion");
+    var isV3 = resolvedVersion === "v3";
+    try {
+        for (var patches_1 = tslib_1.__values(patches), patches_1_1 = patches_1.next(); !patches_1_1.done; patches_1_1 = patches_1.next()) {
+            var _d = tslib_1.__read(patches_1_1.value, 2), patch = _d[0], _e = _d[1], type = _e === void 0 ? "redo" : _e;
+            type = type !== null && type !== void 0 ? type : "redo";
+            var patchKey = type === "redo" ? "patches" : "inversePatches";
+            if (patch.sheetData) {
+                var patches_2 = (_b = patch.sheetData) === null || _b === void 0 ? void 0 : _b[patchKey];
+                if (isV3) {
+                    (0, exports.addSheetDataPatchesV3)(ySheetDataV3, patches_2);
+                }
+                else {
+                    (0, exports.addSheetDataPatches)(ySheetDataV2, patches_2);
+                }
+            }
+            if (patch.sheets) {
+                var patches_3 = patch.sheets[patchKey];
+                (0, exports.updateArrayType)(ySheets, patches_3);
+            }
+            if (patch.tables) {
+                var patches_4 = patch.tables[patchKey];
+                (0, exports.updateArrayType)(yTables, patches_4);
+            }
+            if (patch.embeds) {
+                var patches_5 = patch.embeds[patchKey];
+                (0, exports.updateArrayType)(yEmbeds, patches_5);
+            }
+            if (patch.charts) {
+                var patches_6 = patch.charts[patchKey];
+                (0, exports.updateArrayType)(yCharts, patches_6);
+            }
+            if (patch.conditionalFormats) {
+                var patches_7 = patch.conditionalFormats[patchKey];
+                (0, exports.updateArrayType)(yConditionalFormats, patches_7);
+            }
+            if (patch.dataValidations) {
+                var patches_8 = patch.dataValidations[patchKey];
+                (0, exports.updateArrayType)(yDataValidations, patches_8);
+            }
+            if (patch.namedRanges) {
+                var patches_9 = patch.namedRanges[patchKey];
+                (0, exports.updateArrayType)(yNamedRanges, patches_9);
+            }
+            if (patch.sharedStrings) {
+                var patches_10 = patch.sharedStrings[patchKey];
+                // Always use Map for shared strings
+                (0, exports.applyMapPatches)(ySharedStringsMap, patches_10);
+            }
+            if (patch.protectedRanges) {
+                var patches_11 = patch.protectedRanges[patchKey];
+                (0, exports.updateArrayType)(yProtectedRanges, patches_11);
+            }
+            if (patch.cellXfs) {
+                var patches_12 = patch.cellXfs[patchKey];
+                (0, exports.applyMapPatches)(yCellXfs, patches_12);
+            }
+            // Recalc cells
+            if ((_c = patch.recalcCells) === null || _c === void 0 ? void 0 : _c[type]) {
+                // Removing this
+                // multiple calls to update_sheet_range deletes recalc cells
+                // yRecalcCells.delete(0, yRecalcCells.length);
+                yRecalcCells.push([
+                    {
+                        userId: userId,
+                        patches: Array.from(patch.recalcCells[type]).map(function (value) {
+                            return tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(value), false), [source !== null && source !== void 0 ? source : "agent"], false);
+                        }),
+                    },
+                ]);
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (patches_1_1 && !patches_1_1.done && (_a = patches_1.return)) _a.call(patches_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    // Set disable recalc flag (only if it's currently truthy, to avoid redundant Y.Map writes)
+    if (yDisableRecalc.get("disableRecalc") !== false) {
+        yDisableRecalc.set("disableRecalc", false);
+    }
+};
+exports.applyPatchesToYDoc = applyPatchesToYDoc;
+/**
+ * Add sheet data to a yjs map using immer patches
+ *
+ * Optimized for bulk operations (paste, import) by consolidating cell-level
+ * patches before applying to Y.js. This reduces overhead by:
+ * 1. Deduplicating patches targeting the same cell (later patches win)
+ * 2. Grouping updates by sheet/row for efficient batch application
+ */
+var addSheetDataPatches = function (ySheetData, patches) {
+    var e_2, _a, e_3, _b, e_4, _c, e_5, _d, e_6, _e;
+    // Optimization: Pre-process and consolidate cell-level patches
+    // For bulk operations like paste (10k+ rows), this dramatically reduces overhead
+    // Key format: "sheetId:rowIndex:columnIndex"
+    var cellUpdates = new Map();
+    var otherPatches = [];
+    try {
+        // First pass: categorize and consolidate patches
+        for (var patches_13 = tslib_1.__values(patches), patches_13_1 = patches_13.next(); !patches_13_1.done; patches_13_1 = patches_13.next()) {
+            var patch = patches_13_1.value;
+            var op = patch.op, path = patch.path, value = patch.value;
+            var _f = tslib_1.__read(path, 1), sheetIdRaw = _f[0];
+            // Handle undefined sheetId separately (full replace)
+            if (typeof sheetIdRaw === "undefined") {
+                otherPatches.push(patch);
+                continue;
+            }
+            // Use string representation for sheet ID to handle both string and numeric IDs
+            var sheetIdStr = String(sheetIdRaw);
+            if (op === "replace" || op === "add") {
+                // [sheetId, rowIndex, 'values', columnIndex] - Single cell update (most common in paste)
+                if (path.length === 4) {
+                    var _g = tslib_1.__read(path, 4), rowIndex = _g[1], columnIndex = _g[3];
+                    var rowIdx = Number(rowIndex);
+                    var colIdx = Number(columnIndex);
+                    var key = "".concat(sheetIdStr, ":").concat(rowIdx, ":").concat(colIdx);
+                    // Later patches override earlier ones for the same cell
+                    cellUpdates.set(key, { sheetIdStr: sheetIdStr, rowIdx: rowIdx, colIdx: colIdx, value: value });
+                }
+                else {
+                    // Row-level or sheet-level updates
+                    otherPatches.push(patch);
+                }
+            }
+            else if (op === "remove") {
+                if (path.length === 4) {
+                    var _h = tslib_1.__read(path, 4), rowIndex = _h[1], columnIndex = _h[3];
+                    var rowIdx = Number(rowIndex);
+                    var colIdx = Number(columnIndex);
+                    var key = "".concat(sheetIdStr, ":").concat(rowIdx, ":").concat(colIdx);
+                    cellUpdates.set(key, { sheetIdStr: sheetIdStr, rowIdx: rowIdx, colIdx: colIdx, value: null });
+                }
+                else {
+                    otherPatches.push(patch);
+                }
+            }
+            else {
+                otherPatches.push(patch);
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (patches_13_1 && !patches_13_1.done && (_a = patches_13.return)) _a.call(patches_13);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    // Second pass: Group cell updates by sheet and row for efficient batch application
+    // This minimizes Y.js operations by batching updates to the same row
+    var sheetRowUpdates = new Map();
+    try {
+        for (var cellUpdates_1 = tslib_1.__values(cellUpdates), cellUpdates_1_1 = cellUpdates_1.next(); !cellUpdates_1_1.done; cellUpdates_1_1 = cellUpdates_1.next()) {
+            var _j = tslib_1.__read(cellUpdates_1_1.value, 2), _k = _j[1], sheetIdStr = _k.sheetIdStr, rowIdx = _k.rowIdx, colIdx = _k.colIdx, value = _k.value;
+            if (!sheetRowUpdates.has(sheetIdStr)) {
+                sheetRowUpdates.set(sheetIdStr, new Map());
+            }
+            var rowUpdates = sheetRowUpdates.get(sheetIdStr);
+            if (!rowUpdates.has(rowIdx)) {
+                rowUpdates.set(rowIdx, new Map());
+            }
+            rowUpdates.get(rowIdx).set(colIdx, value);
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (cellUpdates_1_1 && !cellUpdates_1_1.done && (_b = cellUpdates_1.return)) _b.call(cellUpdates_1);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    try {
+        // Apply batched cell updates
+        for (var sheetRowUpdates_1 = tslib_1.__values(sheetRowUpdates), sheetRowUpdates_1_1 = sheetRowUpdates_1.next(); !sheetRowUpdates_1_1.done; sheetRowUpdates_1_1 = sheetRowUpdates_1.next()) {
+            var _l = tslib_1.__read(sheetRowUpdates_1_1.value, 2), sheetIdStr = _l[0], rowUpdates = _l[1];
+            var ysheet = (0, exports.getSheetFromYSheetData)(ySheetData, sheetIdStr);
+            try {
+                for (var rowUpdates_1 = (e_5 = void 0, tslib_1.__values(rowUpdates)), rowUpdates_1_1 = rowUpdates_1.next(); !rowUpdates_1_1.done; rowUpdates_1_1 = rowUpdates_1.next()) {
+                    var _m = tslib_1.__read(rowUpdates_1_1.value, 2), rowIdx = _m[0], colUpdates = _m[1];
+                    var rowData = (0, exports.getRowDataFromSheet)(ysheet, rowIdx);
+                    try {
+                        for (var colUpdates_1 = (e_6 = void 0, tslib_1.__values(colUpdates)), colUpdates_1_1 = colUpdates_1.next(); !colUpdates_1_1.done; colUpdates_1_1 = colUpdates_1.next()) {
+                            var _o = tslib_1.__read(colUpdates_1_1.value, 2), colIdx = _o[0], value = _o[1];
+                            (0, exports.setCellDataInRowData)(rowData, colIdx, value);
+                        }
+                    }
+                    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                    finally {
+                        try {
+                            if (colUpdates_1_1 && !colUpdates_1_1.done && (_e = colUpdates_1.return)) _e.call(colUpdates_1);
+                        }
+                        finally { if (e_6) throw e_6.error; }
+                    }
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (rowUpdates_1_1 && !rowUpdates_1_1.done && (_d = rowUpdates_1.return)) _d.call(rowUpdates_1);
+                }
+                finally { if (e_5) throw e_5.error; }
+            }
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (sheetRowUpdates_1_1 && !sheetRowUpdates_1_1.done && (_c = sheetRowUpdates_1.return)) _c.call(sheetRowUpdates_1);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    // Process non-cell-level patches using original logic
+    var processPatch = function (_a) {
+        var op = _a.op, path = _a.path, value = _a.value;
+        var _b = tslib_1.__read(path, 1), sheetId = _b[0];
+        if (typeof sheetId === "undefined") {
+            // Replace. User is replacing the entire data
+            if (op === "replace") {
+                // Remove all sheet data
+                ySheetData.clear();
+            }
+            // Assign values
+            for (var curSheetId in value) {
+                var sheetId_1 = Number(curSheetId);
+                processPatch({
+                    op: "replace",
+                    path: [sheetId_1],
+                    value: value[curSheetId],
+                });
+            }
+            return;
+        }
+        if (op === "replace" || op === "add") {
+            var ysheet_1 = (0, exports.getSheetFromYSheetData)(ySheetData, sheetId);
+            // Cell-level patches (path.length === 4) are already handled above via consolidation
+            // [sheetId, rowIndex, 'values'] - Replace values array directly
+            if (path.length === 3 && path[2] === "values") {
+                var _c = tslib_1.__read(path, 2), rowIndex = _c[1];
+                var rowData_1 = (0, exports.getRowDataFromSheet)(ysheet_1, rowIndex);
+                // Clear existing row data
+                rowData_1.delete(0, rowData_1.length);
+                if (Array.isArray(value)) {
+                    // Value is the values array directly
+                    // Sort keys to maintain order during insertion
+                    Object.entries(value)
+                        .sort(function (_a, _b) {
+                        var _c = tslib_1.__read(_a, 1), a = _c[0];
+                        var _d = tslib_1.__read(_b, 1), b = _d[0];
+                        return Number(a) - Number(b);
+                    })
+                        .forEach(function (_a) {
+                        var _b = tslib_1.__read(_a, 2), columnIndex = _b[0], cellData = _b[1];
+                        (0, exports.setCellDataInRowData)(rowData_1, Number(columnIndex), cellData);
+                    });
+                }
+            }
+            // [sheetId, rowIndex] - Entire row update
+            else if (path.length === 2) {
+                var _d = tslib_1.__read(path, 2), rowIndex = _d[1];
+                if (value === null || value === void 0 ? void 0 : value.values) {
+                    // Replace entire row with new values
+                    var rowData_2 = (0, exports.getRowDataFromSheet)(ysheet_1, rowIndex);
+                    // Clear existing row data
+                    rowData_2.delete(0, rowData_2.length);
+                    // Add new cell values
+                    // Sort keys to maintain order during insertion
+                    Object.entries(value.values)
+                        .sort(function (_a, _b) {
+                        var _c = tslib_1.__read(_a, 1), a = _c[0];
+                        var _d = tslib_1.__read(_b, 1), b = _d[0];
+                        return Number(a) - Number(b);
+                    })
+                        .forEach(function (_a) {
+                        var _b = tslib_1.__read(_a, 2), columnIndex = _b[0], cellData = _b[1];
+                        (0, exports.setCellDataInRowData)(rowData_2, Number(columnIndex), cellData);
+                    });
+                }
+                else {
+                    // Remove row if value is null/undefined
+                    (0, exports.removeRowData)(ysheet_1, rowIndex);
+                }
+            }
+            // [sheetId] - Entire sheet update
+            else if (path.length === 1) {
+                if (value) {
+                    // Clear entire sheet
+                    ysheet_1.delete(0, ysheet_1.length);
+                    // Add all new data
+                    Object.entries(value)
+                        .sort(function (_a, _b) {
+                        var _c = tslib_1.__read(_a, 1), a = _c[0];
+                        var _d = tslib_1.__read(_b, 1), b = _d[0];
+                        return Number(a) - Number(b);
+                    })
+                        .forEach(function (_a) {
+                        var _b = tslib_1.__read(_a, 2), rowIndex = _b[0], rowData = _b[1];
+                        if (rowData === null || rowData === void 0 ? void 0 : rowData.values) {
+                            var rowDataArray_1 = (0, exports.getRowDataFromSheet)(ysheet_1, Number(rowIndex));
+                            Object.entries(rowData.values)
+                                .sort(function (_a, _b) {
+                                var _c = tslib_1.__read(_a, 1), a = _c[0];
+                                var _d = tslib_1.__read(_b, 1), b = _d[0];
+                                return Number(a) - Number(b);
+                            })
+                                .forEach(function (_a) {
+                                var _b = tslib_1.__read(_a, 2), columnIndex = _b[0], cellData = _b[1];
+                                (0, exports.setCellDataInRowData)(rowDataArray_1, Number(columnIndex), cellData);
+                            });
+                        }
+                    });
+                }
+            }
+        }
+        else if (op === "remove") {
+            // Cell-level removes (path.length === 4) are already handled above via consolidation
+            // [sheetId, rowIndex] - Remove entire row
+            if (path.length === 2) {
+                var _e = tslib_1.__read(path, 2), rowIndex = _e[1];
+                var ysheet = (0, exports.getSheetFromYSheetData)(ySheetData, sheetId);
+                (0, exports.removeRowData)(ysheet, rowIndex);
+            }
+            // [sheetId] - Remove entire sheet
+            else if (path.length === 1) {
+                (0, exports.deleteSheetFromYSheetData)(ySheetData, sheetId);
+            }
+        }
+    };
+    // Only process non-cell-level patches (cell-level already handled via consolidation)
+    otherPatches.forEach(processPatch);
+};
+exports.addSheetDataPatches = addSheetDataPatches;
+var getSheetFromYSheetData = function (ySheetData, sheetId) {
+    var id = String(sheetId);
+    var sheet = ySheetData.get(id);
+    if (!sheet) {
+        sheet = new Y.Array();
+        ySheetData.set(id, sheet);
+    }
+    return sheet;
+};
+exports.getSheetFromYSheetData = getSheetFromYSheetData;
+var deleteSheetFromYSheetData = function (ySheetData, sheetId) {
+    var id = String(sheetId);
+    ySheetData.delete(id);
+};
+exports.deleteSheetFromYSheetData = deleteSheetFromYSheetData;
+var getRowDataFromSheet = function (ysheet, rowIndex) {
+    var index = Number(rowIndex);
+    if (index < 0) {
+        throw new Error("Row index cannot be negative");
+    }
+    // Extend array if needed
+    if (index >= ysheet.length) {
+        var padding = new Array(index - ysheet.length).fill(null);
+        ysheet.insert(ysheet.length, padding);
+        ysheet.insert(index, [null]); // Insert null first
+        // Create new row data
+        var newRowData = new Y.Map();
+        newRowData.set("values", new Y.Array());
+        // Replace the null
+        ysheet.insert(index, [newRowData]);
+        ysheet.delete(index + 1, 1);
+        // Delete the initially inserted null (wait, index shifts)
+        // index is target.
+        // Insert padding up to index. length = index.
+        // Insert null at index. length = index+1.
+        // Replace null at index.
+        // Insert newRowData at index. length = index+2.
+        // Delete at index+1. length = index+1.
+        // Correct.
+        return newRowData.get("values");
+    }
+    // Get or create existing row data
+    var rowData = ysheet.get(index);
+    if (!rowData || !rowData.get("values")) {
+        // Create new row data if it doesn't exist or is incomplete
+        var newRowData = new Y.Map();
+        newRowData.set("values", new Y.Array());
+        // Replace the existing item
+        ysheet.insert(index, [newRowData]);
+        ysheet.delete(index + 1, 1);
+        return newRowData.get("values");
+    }
+    return rowData.get("values");
+};
+exports.getRowDataFromSheet = getRowDataFromSheet;
+var setCellDataInRowData = function (rowData, columnIndex, cellData) {
+    if (cellData === void 0) { cellData = null; }
+    var index = Number(columnIndex);
+    // Extend array if needed
+    if (index >= rowData.length) {
+        var padding = new Array(index - rowData.length).fill(null);
+        if (padding.length > 0) {
+            rowData.insert(rowData.length, padding);
+        }
+    }
+    if (index === rowData.length) {
+        rowData.insert(index, [cellData]);
+    }
+    else {
+        // Replace cell data
+        rowData.insert(index, [cellData]);
+        rowData.delete(index + 1, 1);
+    }
+};
+exports.setCellDataInRowData = setCellDataInRowData;
+var removeRowData = function (ysheet, rowIndex) {
+    var index = Number(rowIndex);
+    // Only remove if index is valid
+    if (index >= 0 && index < ysheet.length) {
+        ysheet.insert(index, [null]);
+        ysheet.delete(index + 1, 1);
+    }
+};
+exports.removeRowData = removeRowData;
+/**
+ * Read a cell's data from the V2 Y.js structure without creating any
+ * missing sheet/row/values containers (unlike getSheetFromYSheetData /
+ * getRowDataFromSheet, which lazily create them).
+ */
+var getCellDataFromYSheetData = function (ySheetData, sheetId, rowIndex, columnIndex) {
+    var sheet = ySheetData.get(String(sheetId));
+    var rowIdx = Number(rowIndex);
+    if (!sheet || rowIdx < 0 || rowIdx >= sheet.length) {
+        return undefined;
+    }
+    var row = sheet.get(rowIdx);
+    var values = row === null || row === void 0 ? void 0 : row.get("values");
+    var colIdx = Number(columnIndex);
+    if (!values || colIdx < 0 || colIdx >= values.length) {
+        return undefined;
+    }
+    return values.get(colIdx);
+};
+exports.getCellDataFromYSheetData = getCellDataFromYSheetData;
+/**
+ * Extract the error effective value from cell data, if any.
+ * SheetCell.setErrorValue persists formula errors as
+ * `ev.ev = { type: "Error", name, message }` (legacy long form:
+ * `effectiveValue.errorValue`).
+ */
+var getCellDataErrorValue = function (cellData) {
+    return (0, utils_1.getExtendedValueError)((0, utils_1.getCellEffectiveValue)(cellData));
+};
+exports.getCellDataErrorValue = getCellDataErrorValue;
+/**
+ * Keep only the cell-level sheetData patches
+ * (`[sheetId, rowIndex, "values", columnIndex]`) whose new cell data carries
+ * an error effective value (#VALUE!, #NAME?, …). Used to let calc-result
+ * errors bypass the leader gate: errors must reach the Y.Doc even from
+ * non-leader clients, otherwise they render blank after reload.
+ */
+var filterErrorCellPatches = function (patches) {
+    return patches.filter(function (patch) {
+        return (patch.op === "add" || patch.op === "replace") &&
+            patch.path.length === 4 &&
+            patch.path[2] === "values" &&
+            Boolean((0, exports.getCellDataErrorValue)(patch.value));
+    });
+};
+exports.filterErrorCellPatches = filterErrorCellPatches;
+/**
+ * Normalize an extended value (short or legacy long keys) into the short-key
+ * shape so semantically identical values compare equal regardless of which
+ * key shape produced them.
+ */
+var normalizeExtendedValue = function (extValue) {
+    if (extValue === null || extValue === undefined) {
+        return undefined;
+    }
+    var normalized = {};
+    var numberValue = (0, utils_1.getExtendedValueNumber)(extValue);
+    if (numberValue !== undefined) {
+        normalized.nv = numberValue;
+    }
+    var stringValue = (0, utils_1.getExtendedValueString)(extValue);
+    if (stringValue !== undefined) {
+        normalized.sv = stringValue;
+    }
+    var boolValue = (0, utils_1.getExtendedValueBool)(extValue);
+    if (boolValue !== undefined) {
+        normalized.bv = boolValue;
+    }
+    var formulaValue = (0, utils_1.getExtendedValueFormula)(extValue);
+    if (formulaValue !== undefined) {
+        normalized.fv = formulaValue;
+    }
+    var errorValue = (0, utils_1.getExtendedValueError)(extValue);
+    if (errorValue !== undefined) {
+        normalized.ev = errorValue;
+    }
+    return normalized;
+};
+/**
+ * Containment guard for the non-leader error-persistence path
+ * (use-yspreadsheet-v2 onBroadcastPatch, gated disableRecalc branch).
+ * A gated error cell patch may be written ONLY when all of these hold:
+ *
+ * 1. The incoming cell data carries an error effective value.
+ * 2. The current doc cell holds no effective value at all (the
+ *    blank-after-reload case) or its effective value is itself an error.
+ *    A non-error result (number/string/bool/formula result) is never
+ *    overwritten — a stale non-leader error must not clobber a newer
+ *    leader-written success.
+ * 3. If the doc cell exists, its user-entered value (`ue`, short or legacy
+ *    key shape) matches the incoming patch's — a cell edited after the
+ *    calculation started is never touched.
+ * 4. The persisted error differs from the incoming one (identical errors
+ *    are dropped so concurrent non-leaders don't append redundant
+ *    Y.js updates).
+ */
+var shouldPersistErrorCellPatch = function (currentCellData, incomingCellData) {
+    var incomingError = (0, exports.getCellDataErrorValue)(incomingCellData);
+    if (!incomingError) {
+        return false;
+    }
+    var currentEffectiveValue = (0, utils_1.getCellEffectiveValue)(currentCellData);
+    var currentError = (0, utils_1.getExtendedValueError)(currentEffectiveValue);
+    if (currentEffectiveValue !== null &&
+        currentEffectiveValue !== undefined &&
+        !currentError) {
+        return false;
+    }
+    if (currentCellData !== null && currentCellData !== undefined) {
+        var currentUserEnteredValue = normalizeExtendedValue((0, utils_1.getCellUserEnteredValue)(currentCellData));
+        var incomingUserEnteredValue = normalizeExtendedValue((0, utils_1.getCellUserEnteredValue)(incomingCellData));
+        if (!(0, isEqual_1.default)(currentUserEnteredValue, incomingUserEnteredValue)) {
+            return false;
+        }
+    }
+    return !(0, isEqual_1.default)(currentError, incomingError);
+};
+exports.shouldPersistErrorCellPatch = shouldPersistErrorCellPatch;
+/**
+ * Build the cell data to write for a gated error patch that passed
+ * shouldPersistErrorCellPatch. If the doc cell doesn't exist yet there is
+ * nothing to destroy and the incoming cell data is written as-is. If it
+ * does exist, ONLY the error effective value is merged in — every other
+ * field of the doc cell (ue, formats, notes, …) is preserved so this write
+ * path can never remove doc state it didn't produce. The effective value is
+ * written into whichever key shape(s) the doc cell already uses (short `ev`
+ * by default).
+ */
+var mergeErrorEffectiveValueIntoCellData = function (currentCellData, incomingCellData) {
+    if (currentCellData === null || currentCellData === undefined) {
+        return incomingCellData;
+    }
+    var incomingEffectiveValue = (0, utils_1.getCellEffectiveValue)(incomingCellData);
+    var merged = tslib_1.__assign({}, currentCellData);
+    var hasLegacyKey = "effectiveValue" in merged;
+    if (hasLegacyKey) {
+        merged.effectiveValue = incomingEffectiveValue;
+    }
+    if ("ev" in merged || !hasLegacyKey) {
+        merged.ev = incomingEffectiveValue;
+    }
+    return merged;
+};
+exports.mergeErrorEffectiveValueIntoCellData = mergeErrorEffectiveValueIntoCellData;
+/**
+ * Update array type with immer patches
+ */
+var updateArrayType = function (yarray, patches) {
+    // Consecutive nested-path patches targeting the same array item are
+    // consolidated into one cloneDeep + one Y.Array write. An immer splice on
+    // a nested array (e.g. a sheet's rowMetadata on row insert/delete) emits
+    // one patch per shifted entry; writing each patch individually clones and
+    // re-serializes the entire item per entry — O(n²) on large sheets, which
+    // freezes the tab.
+    var pending = null;
+    var flushPending = function () {
+        if (!pending) {
+            return;
+        }
+        var index = pending.index, item = pending.item;
+        pending = null;
+        ensureArraySize(yarray, index);
+        yarray.insert(index, [item]);
+        yarray.delete(index + 1, 1);
+    };
+    patches.forEach(function (_a) {
+        var op = _a.op, path = _a.path, value = _a.value;
+        var _b = tslib_1.__read(path), arrayIndex = _b[0], nestedPath = _b.slice(1);
+        var index = Number(arrayIndex);
+        if (isNaN(index)) {
+            flushPending();
+            // User is replacing the entire array
+            if (op === "replace") {
+                yarray.delete(0, yarray.length);
+                yarray.push(value);
+            }
+            return;
+        }
+        if (op === "replace" || op === "add") {
+            if (nestedPath.length === 0) {
+                flushPending();
+                // Direct array item replacement
+                ensureArraySize(yarray, index);
+                yarray.insert(index, [value]);
+                yarray.delete(index + 1, 1);
+            }
+            else {
+                // Nested property update within array item
+                var updatedItem = void 0;
+                if (pending && pending.index === index) {
+                    updatedItem = pending.item;
+                }
+                else {
+                    flushPending();
+                    var item = index < yarray.length ? yarray.get(index) : {};
+                    var baseItem = item === null || item === undefined ? {} : item;
+                    // Clone the item and use lodash to set the nested property
+                    updatedItem = (0, cloneDeep_1.default)(baseItem);
+                    pending = { index: index, item: updatedItem };
+                }
+                (0, set_1.default)(updatedItem, nestedPath, value);
+            }
+        }
+        else if (op === "remove") {
+            if (nestedPath.length === 0) {
+                flushPending();
+                // Remove entire array item
+                if (index >= 0 && index < yarray.length) {
+                    yarray.delete(index, 1);
+                }
+            }
+            else {
+                // Remove nested property from array item
+                var updatedItem = null;
+                if (pending && pending.index === index) {
+                    if (pending.item && typeof pending.item === "object") {
+                        updatedItem = pending.item;
+                    }
+                }
+                else {
+                    flushPending();
+                    if (index >= 0 && index < yarray.length) {
+                        var item = yarray.get(index);
+                        if (item && typeof item === "object") {
+                            updatedItem = (0, cloneDeep_1.default)(item);
+                            pending = { index: index, item: updatedItem };
+                        }
+                    }
+                }
+                if (updatedItem) {
+                    // Check if we're removing from an array
+                    var parentPath = nestedPath.slice(0, -1);
+                    var lastKey = nestedPath[nestedPath.length - 1];
+                    if (parentPath.length > 0) {
+                        var parentValue = (0, get_1.default)(updatedItem, parentPath);
+                        if (Array.isArray(parentValue) && typeof lastKey === "number") {
+                            // Remove array element using splice
+                            parentValue.splice(lastKey, 1);
+                        }
+                        else {
+                            // Remove object property
+                            (0, unset_1.default)(updatedItem, nestedPath);
+                        }
+                    }
+                    else {
+                        // Direct property removal
+                        (0, unset_1.default)(updatedItem, nestedPath);
+                    }
+                }
+            }
+        }
+    });
+    flushPending();
+};
+exports.updateArrayType = updateArrayType;
+/**
+ * Helper function to ensure array is large enough
+ */
+function ensureArraySize(yarray, index) {
+    if (index >= yarray.length) {
+        var gaps = new Array(index - yarray.length).fill(null);
+        yarray.insert(yarray.length, gaps);
+        yarray.insert(index, [null]); // Insert placeholder that will be replaced
+    }
+}
+/**
+ * Normalize values to always be an array, converting object notation if needed
+ */
+function normalizeValuesToArray(values) {
+    if (!values) {
+        return [];
+    }
+    if (Array.isArray(values)) {
+        return tslib_1.__spreadArray([], tslib_1.__read(values), false);
+    }
+    // Convert object notation to array
+    var entries = Object.entries(values);
+    if (entries.length === 0) {
+        return [];
+    }
+    var maxIndex = Math.max.apply(Math, tslib_1.__spreadArray([], tslib_1.__read(entries.map(function (_a) {
+        var _b = tslib_1.__read(_a, 1), key = _b[0];
+        return Number(key);
+    })), false));
+    var result = new Array(maxIndex + 1).fill(null);
+    entries.forEach(function (_a) {
+        var _b = tslib_1.__read(_a, 2), key = _b[0], value = _b[1];
+        result[Number(key)] = value;
+    });
+    return result;
+}
+/**
+ * Validate and clean sheets data
+ */
+var validateSheets = function (sheets) {
+    return sheets.filter(Boolean).map(function (sheet) {
+        var _a;
+        return (tslib_1.__assign(tslib_1.__assign({}, sheet), { 
+            // Ensure merges is always an array and filter out falsy values
+            merges: (_a = sheet.merges) === null || _a === void 0 ? void 0 : _a.filter(Boolean) }));
+    });
+};
+exports.validateSheets = validateSheets;
+/**
+ * Map operations
+ */
+var applyMapPatches = function (yMap, patches) {
+    var e_7, _a, e_8, _b, e_9, _c;
+    try {
+        for (var patches_14 = tslib_1.__values(patches), patches_14_1 = patches_14.next(); !patches_14_1.done; patches_14_1 = patches_14.next()) {
+            var _d = patches_14_1.value, op = _d.op, path = _d.path, value = _d.value;
+            if (!path || !path.length) {
+                if (op === "remove") {
+                    // Only clear if there's something to clear
+                    if (yMap.size > 0)
+                        yMap.clear();
+                }
+                else if (op === "replace") {
+                    // Diff against current contents instead of clear-and-rewrite, so keys
+                    // whose references haven't changed don't generate Y.Map tombstones.
+                    var incoming = new Map(value);
+                    try {
+                        for (var _e = (e_8 = void 0, tslib_1.__values(Array.from(yMap.keys()))), _f = _e.next(); !_f.done; _f = _e.next()) {
+                            var k = _f.value;
+                            if (!incoming.has(k))
+                                yMap.delete(k);
+                        }
+                    }
+                    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+                    finally {
+                        try {
+                            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                        }
+                        finally { if (e_8) throw e_8.error; }
+                    }
+                    try {
+                        for (var incoming_1 = (e_9 = void 0, tslib_1.__values(incoming)), incoming_1_1 = incoming_1.next(); !incoming_1_1.done; incoming_1_1 = incoming_1.next()) {
+                            var _g = tslib_1.__read(incoming_1_1.value, 2), k = _g[0], v = _g[1];
+                            if (yMap.get(k) !== v)
+                                yMap.set(k, v);
+                        }
+                    }
+                    catch (e_9_1) { e_9 = { error: e_9_1 }; }
+                    finally {
+                        try {
+                            if (incoming_1_1 && !incoming_1_1.done && (_c = incoming_1.return)) _c.call(incoming_1);
+                        }
+                        finally { if (e_9) throw e_9.error; }
+                    }
+                }
+                continue;
+            }
+            var index = path[0];
+            if (op === "remove") {
+                if (yMap.has(index))
+                    yMap.delete(index);
+            }
+            else if (op === "add" || op === "replace") {
+                if (yMap.get(index) !== value)
+                    yMap.set(index, value);
+            }
+        }
+    }
+    catch (e_7_1) { e_7 = { error: e_7_1 }; }
+    finally {
+        try {
+            if (patches_14_1 && !patches_14_1.done && (_a = patches_14.return)) _a.call(patches_14);
+        }
+        finally { if (e_7) throw e_7.error; }
+    }
+};
+exports.applyMapPatches = applyMapPatches;
+/**
+ * Process events to find changes in sheet data
+ * Returns a new sheet data object with only the changes applied if possible, or null if a full reload is needed
+ */
+var processSheetDataEvents = function (events, currentSheetData, ySheetDataV2) {
+    var e_10, _a;
+    var changes = new Map();
+    var fullReloadSheets = new Set();
+    var _loop_1 = function (event_1) {
+        var path = event_1.path;
+        if (path.length > 0) {
+            var sheetId_2 = String(path[0]);
+            if (!changes.has(sheetId_2)) {
+                changes.set(sheetId_2, new Map());
+            }
+            var rows_1 = changes.get(sheetId_2);
+            // Path structure: [sheetId, rowIndex, "values", colIndex] or [sheetId, rowIndex]
+            if (path.length >= 4 && path[2] === "values") {
+                var rowIndex = Number(path[1]);
+                var columnIndex = Number(path[3]);
+                if (!isNaN(rowIndex) && !isNaN(columnIndex)) {
+                    var existing = rows_1.get(rowIndex);
+                    if (existing) {
+                        if (!existing.full) {
+                            existing.columns.add(columnIndex);
+                        }
+                    }
+                    else {
+                        rows_1.set(rowIndex, {
+                            full: false,
+                            columns: new Set([columnIndex]),
+                        });
+                    }
+                }
+            }
+            else if (path.length >= 2) {
+                var rowIndex = Number(path[1]);
+                if (!isNaN(rowIndex)) {
+                    var existing = rows_1.get(rowIndex);
+                    if (existing) {
+                        existing.full = true;
+                        existing.columns.clear();
+                    }
+                    else {
+                        rows_1.set(rowIndex, { full: true, columns: new Set() });
+                    }
+                }
+            }
+            else if (path.length === 1) {
+                if (event_1.isYArrayEvent && event_1.delta) {
+                    var index_1 = 0;
+                    event_1.delta.forEach(function (op) {
+                        if (op.retain) {
+                            index_1 += op.retain;
+                        }
+                        if (op.insert) {
+                            var count = Array.isArray(op.insert) ? op.insert.length : 1;
+                            for (var i = 0; i < count; i++) {
+                                var rowIndex = index_1 + i;
+                                var existing = rows_1.get(rowIndex);
+                                if (existing) {
+                                    existing.full = true;
+                                    existing.columns.clear();
+                                }
+                                else {
+                                    rows_1.set(rowIndex, { full: true, columns: new Set() });
+                                }
+                            }
+                            index_1 += count;
+                        }
+                        if (op.delete) {
+                            fullReloadSheets.add(sheetId_2); // Mark full sheet reload
+                        }
+                    });
+                }
+            }
+        }
+    };
+    try {
+        for (var events_1 = tslib_1.__values(events), events_1_1 = events_1.next(); !events_1_1.done; events_1_1 = events_1.next()) {
+            var event_1 = events_1_1.value;
+            _loop_1(event_1);
+        }
+    }
+    catch (e_10_1) { e_10 = { error: e_10_1 }; }
+    finally {
+        try {
+            if (events_1_1 && !events_1_1.done && (_a = events_1.return)) _a.call(events_1);
+        }
+        finally { if (e_10) throw e_10.error; }
+    }
+    if (changes.size > 0 || fullReloadSheets.size > 0) {
+        var next_1 = tslib_1.__assign({}, currentSheetData);
+        var hasChanges_1 = false;
+        fullReloadSheets.forEach(function (sheetId) {
+            var ySheet = ySheetDataV2.get(sheetId);
+            if (!ySheet)
+                return;
+            var sheetData = ySheet.toJSON();
+            next_1[sheetId] = sheetData;
+            hasChanges_1 = true;
+        });
+        changes.forEach(function (rowIndices, sheetId) {
+            var ySheet = ySheetDataV2.get(sheetId);
+            if (!ySheet)
+                return;
+            // If full sheet reload needed
+            if (fullReloadSheets.has(sheetId)) {
+                var sheetData = ySheet.toJSON();
+                next_1[sheetId] = sheetData;
+                hasChanges_1 = true;
+                return;
+            }
+            // Partial update
+            if (!next_1[sheetId]) {
+                next_1[sheetId] = [];
+            }
+            if (next_1[sheetId].length < ySheet.length) {
+                if (next_1[sheetId].length !== ySheet.length) {
+                    var sheetData = ySheet.toJSON();
+                    next_1[sheetId] = sheetData;
+                    hasChanges_1 = true;
+                    return;
+                }
+            }
+            var nextSheet = tslib_1.__spreadArray([], tslib_1.__read(next_1[sheetId]), false);
+            rowIndices.forEach(function (change, rowIndex) {
+                var _a;
+                if (rowIndex < 0 || rowIndex >= ySheet.length)
+                    return;
+                var yRow = ySheet.get(rowIndex);
+                if (change.full) {
+                    var normalizedRow = null;
+                    if (yRow) {
+                        var rowJson = yRow.toJSON();
+                        normalizedRow = rowJson;
+                    }
+                    nextSheet[rowIndex] = normalizedRow;
+                }
+                else {
+                    var currentRow = (_a = nextSheet[rowIndex]) !== null && _a !== void 0 ? _a : null;
+                    if (!yRow) {
+                        if (currentRow) {
+                            nextSheet[rowIndex] = currentRow;
+                        }
+                        return;
+                    }
+                    var yValues_1 = yRow.get("values");
+                    if (!yValues_1) {
+                        if (currentRow) {
+                            nextSheet[rowIndex] = currentRow;
+                        }
+                        return;
+                    }
+                    var baseRow = currentRow !== null && currentRow !== void 0 ? currentRow : yRow.toJSON();
+                    if (!baseRow) {
+                        return;
+                    }
+                    var baseValues = baseRow.values;
+                    // Always normalize to array to ensure .entries() works in calculation code
+                    var mergedValues_1 = normalizeValuesToArray(baseValues);
+                    change.columns.forEach(function (columnIndex) {
+                        var nextValue = yValues_1.get(columnIndex);
+                        mergedValues_1[columnIndex] =
+                            nextValue === undefined ? null : nextValue;
+                    });
+                    nextSheet[rowIndex] = tslib_1.__assign(tslib_1.__assign({}, baseRow), { values: mergedValues_1 });
+                }
+            });
+            next_1[sheetId] = nextSheet;
+            hasChanges_1 = true;
+        });
+        return hasChanges_1 ? next_1 : null;
+    }
+    return null;
+};
+exports.processSheetDataEvents = processSheetDataEvents;
+// ============================================================================
+// V3 Helper Functions (Flat Map Structure)
+// ============================================================================
+/**
+ * Convert letter to column index (1-based)
+ * A = 1, B = 2, ..., Z = 26, AA = 27, etc.
+ */
+var letterToColumnIndex = function (letters) {
+    return letters
+        .toUpperCase()
+        .split("")
+        .reduce(function (r, a) { return r * 26 + parseInt(a, 36) - 9; }, 0);
+};
+/**
+ * Create a V3 cell key from sheet ID, row and column indices
+ * Format: `${sheetId}!${A1Address}` (e.g., "1!A1", "2!B5")
+ */
+var createCellKeyV3 = function (sheetId, rowIndex, columnIndex) {
+    var _a;
+    var address = (_a = (0, utils_1.cellToAddress)({ rowIndex: rowIndex, columnIndex: columnIndex })) !== null && _a !== void 0 ? _a : "".concat(String.fromCharCode(65 + columnIndex - 1)).concat(rowIndex);
+    return "".concat(sheetId, "!").concat(address);
+};
+exports.createCellKeyV3 = createCellKeyV3;
+/**
+ * Parse a V3 cell key to extract sheet ID and position information
+ * Example: parseCellKeyV3("1!A1") => { sheetId: 1, address: "A1", rowIndex: 1, columnIndex: 1 }
+ */
+var parseCellKeyV3 = function (cellKey) {
+    var match = cellKey.match(/^(\d+)!([A-Z]+)(\d+)$/i);
+    if (!match)
+        return null;
+    var _a = tslib_1.__read(match, 4), sheetIdStr = _a[1], columnLetters = _a[2], rowIndexStr = _a[3];
+    return {
+        sheetId: Number(sheetIdStr),
+        address: "".concat(columnLetters.toUpperCase()).concat(rowIndexStr),
+        rowIndex: Number(rowIndexStr),
+        columnIndex: letterToColumnIndex(columnLetters),
+    };
+};
+exports.parseCellKeyV3 = parseCellKeyV3;
+/**
+ * Create a CellDataV3 object with position and sheetId
+ */
+var createCellDataV3 = function (value, sheetId, rowIndex, columnIndex) { return ({
+    value: value,
+    sId: sheetId,
+    r: rowIndex,
+    c: columnIndex,
+}); };
+exports.createCellDataV3 = createCellDataV3;
+/**
+ * Convert V2 SheetData to V3 flat Map format
+ * V2: { sheetId: [rows with values arrays] }
+ * V3: Map<cellKey, CellDataV3>
+ */
+var sheetDataV2ToV3 = function (v2Data) {
+    var v3Map = new Map();
+    var _loop_2 = function (sheetIdStr) {
+        var sheetId = Number(sheetIdStr);
+        var rows = v2Data[sheetId];
+        if (!rows)
+            return "continue";
+        rows.forEach(function (row, rowIndex) {
+            if (!(row === null || row === void 0 ? void 0 : row.values))
+                return;
+            row.values.forEach(function (cellData, colIndex) {
+                if (cellData) {
+                    var key = (0, exports.createCellKeyV3)(sheetId, rowIndex, colIndex);
+                    v3Map.set(key, (0, exports.createCellDataV3)(cellData, sheetId, rowIndex, colIndex));
+                }
+            });
+        });
+    };
+    for (var sheetIdStr in v2Data) {
+        _loop_2(sheetIdStr);
+    }
+    return v3Map;
+};
+exports.sheetDataV2ToV3 = sheetDataV2ToV3;
+/**
+ * Convert V3 flat Map format to V2 SheetData
+ * V3: Map<cellKey, CellDataV3>
+ * V2: { sheetId: [rows with values arrays] }
+ */
+var sheetDataV3ToV2 = function (v3Data) {
+    var e_11, _a;
+    var sheetData = {};
+    try {
+        for (var v3Data_1 = tslib_1.__values(v3Data), v3Data_1_1 = v3Data_1.next(); !v3Data_1_1.done; v3Data_1_1 = v3Data_1.next()) {
+            var _b = tslib_1.__read(v3Data_1_1.value, 2), _1 = _b[0], cellDataV3 = _b[1];
+            if (!cellDataV3)
+                continue;
+            var sheetId = cellDataV3.sId, rowIdx = cellDataV3.r, colIdx = cellDataV3.c, value = cellDataV3.value;
+            // Ensure sheet exists
+            if (!sheetData[sheetId]) {
+                sheetData[sheetId] = [];
+            }
+            // Ensure row exists
+            while (sheetData[sheetId].length <= rowIdx) {
+                sheetData[sheetId].push(null);
+            }
+            if (!sheetData[sheetId][rowIdx]) {
+                sheetData[sheetId][rowIdx] = { values: [] };
+            }
+            var row = sheetData[sheetId][rowIdx];
+            if (!row.values)
+                row.values = [];
+            // Ensure values array is long enough
+            while (row.values.length <= colIdx) {
+                row.values.push(null);
+            }
+            row.values[colIdx] = value;
+        }
+    }
+    catch (e_11_1) { e_11 = { error: e_11_1 }; }
+    finally {
+        try {
+            if (v3Data_1_1 && !v3Data_1_1.done && (_a = v3Data_1.return)) _a.call(v3Data_1);
+        }
+        finally { if (e_11) throw e_11.error; }
+    }
+    return sheetData;
+};
+exports.sheetDataV3ToV2 = sheetDataV3ToV2;
+/**
+ * Get a cell from V3 flat structure
+ */
+var getCellV3 = function (ySheetDataV3, sheetId, rowIndex, columnIndex) {
+    var key = (0, exports.createCellKeyV3)(sheetId, rowIndex, columnIndex);
+    return ySheetDataV3.get(key);
+};
+exports.getCellV3 = getCellV3;
+/**
+ * Set a cell in V3 flat structure
+ */
+var setCellV3 = function (ySheetDataV3, sheetId, rowIndex, columnIndex, value) {
+    var key = (0, exports.createCellKeyV3)(sheetId, rowIndex, columnIndex);
+    ySheetDataV3.set(key, (0, exports.createCellDataV3)(value, sheetId, rowIndex, columnIndex));
+};
+exports.setCellV3 = setCellV3;
+/**
+ * Delete a cell from V3 flat structure
+ */
+var deleteCellV3 = function (ySheetDataV3, sheetId, rowIndex, columnIndex) {
+    var key = (0, exports.createCellKeyV3)(sheetId, rowIndex, columnIndex);
+    ySheetDataV3.delete(key);
+};
+exports.deleteCellV3 = deleteCellV3;
+/**
+ * Delete all cells for a sheet from V3 flat structure
+ */
+var deleteSheetV3 = function (ySheetDataV3, sheetId) {
+    var e_12, _a;
+    var prefix = "".concat(sheetId, "!");
+    try {
+        for (var _b = tslib_1.__values(ySheetDataV3.keys()), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var key = _c.value;
+            if (key.startsWith(prefix)) {
+                ySheetDataV3.delete(key);
+            }
+        }
+    }
+    catch (e_12_1) { e_12 = { error: e_12_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_12) throw e_12.error; }
+    }
+};
+exports.deleteSheetV3 = deleteSheetV3;
+/**
+ * Get V3 sheet data map from Y.Doc
+ */
+var getSheetDataV3 = function (doc) {
+    return doc.getMap("sheetDataV3");
+};
+exports.getSheetDataV3 = getSheetDataV3;
+/**
+ * Apply immer patches to V3 sheet data (flat map structure)
+ *
+ * Optimized for bulk operations (paste, import) by consolidating cell-level
+ * patches before applying to Y.js. This reduces overhead by:
+ * 1. Deduplicating patches targeting the same cell (later patches win)
+ * 2. Processing all cell updates in a single pass
+ */
+var addSheetDataPatchesV3 = function (ySheetDataV3, patches) {
+    var e_13, _a, e_14, _b;
+    // Optimization: Pre-process and consolidate cell-level patches
+    // For bulk operations like paste (10k+ rows), this dramatically reduces overhead
+    var cellUpdates = new Map();
+    var otherPatches = [];
+    try {
+        // First pass: categorize and consolidate patches
+        for (var patches_15 = tslib_1.__values(patches), patches_15_1 = patches_15.next(); !patches_15_1.done; patches_15_1 = patches_15.next()) {
+            var patch = patches_15_1.value;
+            var op = patch.op, path = patch.path, value = patch.value;
+            var _c = tslib_1.__read(path, 1), sheetIdRaw = _c[0];
+            // Handle undefined sheetId separately (full replace)
+            if (typeof sheetIdRaw === "undefined") {
+                otherPatches.push(patch);
+                continue;
+            }
+            var sheetId = Number(sheetIdRaw);
+            if (op === "replace" || op === "add") {
+                // [sheetId, rowIndex, 'values', columnIndex] - Single cell update (most common in paste)
+                if (path.length === 4) {
+                    var _d = tslib_1.__read(path, 4), rowIndex = _d[1], columnIndex = _d[3];
+                    var rowIdx = Number(rowIndex);
+                    var colIdx = Number(columnIndex);
+                    var key = (0, exports.createCellKeyV3)(sheetId, rowIdx, colIdx);
+                    // Later patches override earlier ones for the same cell
+                    cellUpdates.set(key, { sheetId: sheetId, rowIdx: rowIdx, colIdx: colIdx, value: value });
+                }
+                else {
+                    // Row-level or sheet-level updates
+                    otherPatches.push(patch);
+                }
+            }
+            else if (op === "remove") {
+                if (path.length === 4) {
+                    var _e = tslib_1.__read(path, 4), rowIndex = _e[1], columnIndex = _e[3];
+                    var rowIdx = Number(rowIndex);
+                    var colIdx = Number(columnIndex);
+                    var key = (0, exports.createCellKeyV3)(sheetId, rowIdx, colIdx);
+                    cellUpdates.set(key, { sheetId: sheetId, rowIdx: rowIdx, colIdx: colIdx, value: null });
+                }
+                else {
+                    otherPatches.push(patch);
+                }
+            }
+            else {
+                otherPatches.push(patch);
+            }
+        }
+    }
+    catch (e_13_1) { e_13 = { error: e_13_1 }; }
+    finally {
+        try {
+            if (patches_15_1 && !patches_15_1.done && (_a = patches_15.return)) _a.call(patches_15);
+        }
+        finally { if (e_13) throw e_13.error; }
+    }
+    try {
+        // Second pass: Apply consolidated cell updates in batch
+        // This is much faster than processing each patch individually
+        for (var cellUpdates_2 = tslib_1.__values(cellUpdates), cellUpdates_2_1 = cellUpdates_2.next(); !cellUpdates_2_1.done; cellUpdates_2_1 = cellUpdates_2.next()) {
+            var _f = tslib_1.__read(cellUpdates_2_1.value, 2), key = _f[0], _g = _f[1], sheetId = _g.sheetId, rowIdx = _g.rowIdx, colIdx = _g.colIdx, value = _g.value;
+            if (value) {
+                ySheetDataV3.set(key, (0, exports.createCellDataV3)(value, sheetId, rowIdx, colIdx));
+            }
+            else {
+                ySheetDataV3.delete(key);
+            }
+        }
+    }
+    catch (e_14_1) { e_14 = { error: e_14_1 }; }
+    finally {
+        try {
+            if (cellUpdates_2_1 && !cellUpdates_2_1.done && (_b = cellUpdates_2.return)) _b.call(cellUpdates_2);
+        }
+        finally { if (e_14) throw e_14.error; }
+    }
+    // Row-targeted patches (e.g. the per-shifted-row patches an immer array
+    // splice emits for a row insert/delete) previously scanned the entire flat
+    // cell map once per patch — O(patches × totalCells), which freezes the tab
+    // when inserting a row near the top of a large sheet. Build a
+    // row → cell-keys index once per batch instead, and keep it in sync as
+    // patches apply.
+    var rowCellKeyIndex = null;
+    var rowIndexKey = function (sheetId, rowIdx) {
+        return "".concat(sheetId, ":").concat(rowIdx);
+    };
+    var ensureRowCellKeyIndex = function () {
+        var e_15, _a;
+        if (rowCellKeyIndex) {
+            return rowCellKeyIndex;
+        }
+        rowCellKeyIndex = new Map();
+        try {
+            for (var _b = tslib_1.__values(ySheetDataV3.entries()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = tslib_1.__read(_c.value, 2), key = _d[0], cellData = _d[1];
+                var rk = rowIndexKey(cellData === null || cellData === void 0 ? void 0 : cellData.sId, cellData === null || cellData === void 0 ? void 0 : cellData.r);
+                var keys = rowCellKeyIndex.get(rk);
+                if (!keys) {
+                    keys = new Set();
+                    rowCellKeyIndex.set(rk, keys);
+                }
+                keys.add(key);
+            }
+        }
+        catch (e_15_1) { e_15 = { error: e_15_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_15) throw e_15.error; }
+        }
+        return rowCellKeyIndex;
+    };
+    var trackCellKeySet = function (sheetId, rowIdx, key) {
+        if (!rowCellKeyIndex) {
+            return;
+        }
+        var rk = rowIndexKey(sheetId, rowIdx);
+        var keys = rowCellKeyIndex.get(rk);
+        if (!keys) {
+            keys = new Set();
+            rowCellKeyIndex.set(rk, keys);
+        }
+        keys.add(key);
+    };
+    var deleteRowCells = function (sheetId, rowIdx) {
+        var e_16, _a;
+        var keys = ensureRowCellKeyIndex().get(rowIndexKey(sheetId, rowIdx));
+        if (!keys) {
+            return;
+        }
+        try {
+            for (var keys_1 = tslib_1.__values(keys), keys_1_1 = keys_1.next(); !keys_1_1.done; keys_1_1 = keys_1.next()) {
+                var key = keys_1_1.value;
+                ySheetDataV3.delete(key);
+            }
+        }
+        catch (e_16_1) { e_16 = { error: e_16_1 }; }
+        finally {
+            try {
+                if (keys_1_1 && !keys_1_1.done && (_a = keys_1.return)) _a.call(keys_1);
+            }
+            finally { if (e_16) throw e_16.error; }
+        }
+        rowCellKeyIndex.delete(rowIndexKey(sheetId, rowIdx));
+    };
+    var dropSheetFromIndex = function (sheetId) {
+        var e_17, _a;
+        if (!rowCellKeyIndex) {
+            return;
+        }
+        var prefix = "".concat(sheetId, ":");
+        try {
+            for (var _b = tslib_1.__values(Array.from(rowCellKeyIndex.keys())), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var rk = _c.value;
+                if (rk.startsWith(prefix)) {
+                    rowCellKeyIndex.delete(rk);
+                }
+            }
+        }
+        catch (e_17_1) { e_17 = { error: e_17_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_17) throw e_17.error; }
+        }
+    };
+    // Process non-cell-level patches using original logic
+    var processPatch = function (_a) {
+        var e_18, _b, e_19, _c, e_20, _d;
+        var op = _a.op, path = _a.path, value = _a.value;
+        var _e = tslib_1.__read(path, 1), sheetIdRaw = _e[0];
+        if (typeof sheetIdRaw === "undefined") {
+            // Replace entire data
+            if (op === "replace") {
+                try {
+                    // Clear all cells
+                    for (var _f = tslib_1.__values(ySheetDataV3.keys()), _g = _f.next(); !_g.done; _g = _f.next()) {
+                        var key = _g.value;
+                        ySheetDataV3.delete(key);
+                    }
+                }
+                catch (e_18_1) { e_18 = { error: e_18_1 }; }
+                finally {
+                    try {
+                        if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+                    }
+                    finally { if (e_18) throw e_18.error; }
+                }
+                if (rowCellKeyIndex) {
+                    rowCellKeyIndex.clear();
+                }
+            }
+            var _loop_3 = function (curSheetId) {
+                var sheetId_3 = Number(curSheetId);
+                var rows = value[curSheetId];
+                if (!rows)
+                    return "continue";
+                Object.entries(rows).forEach(function (_a) {
+                    var _b = tslib_1.__read(_a, 2), rowIndexStr = _b[0], rowData = _b[1];
+                    if (!(rowData === null || rowData === void 0 ? void 0 : rowData.values))
+                        return;
+                    var rowIdx = Number(rowIndexStr);
+                    Object.entries(rowData.values).forEach(function (_a) {
+                        var _b = tslib_1.__read(_a, 2), colIndexStr = _b[0], cellData = _b[1];
+                        if (cellData) {
+                            var colIdx = Number(colIndexStr);
+                            var key = (0, exports.createCellKeyV3)(sheetId_3, rowIdx, colIdx);
+                            ySheetDataV3.set(key, (0, exports.createCellDataV3)(cellData, sheetId_3, rowIdx, colIdx));
+                            trackCellKeySet(sheetId_3, rowIdx, key);
+                        }
+                    });
+                });
+            };
+            // Assign values from the replacement object
+            for (var curSheetId in value) {
+                _loop_3(curSheetId);
+            }
+            return;
+        }
+        var sheetId = Number(sheetIdRaw);
+        if (op === "replace" || op === "add") {
+            // Cell-level patches (path.length === 4) are already handled above via consolidation
+            // [sheetId, rowIndex, 'values', columnIndex, ...nestedPath] - Deep nested property update
+            if (path.length > 4) {
+                var _h = tslib_1.__read(path), rowIndex = _h[1], columnIndex = _h[3], nestedPath = _h.slice(4);
+                var rowIdx = Number(rowIndex);
+                var colIdx = Number(columnIndex);
+                var key = (0, exports.createCellKeyV3)(sheetId, rowIdx, colIdx);
+                // Get existing cell data or create empty
+                var existing = ySheetDataV3.get(key);
+                var cellData = (existing === null || existing === void 0 ? void 0 : existing.value) ? (0, cloneDeep_1.default)(existing.value) : {};
+                // Apply nested property change
+                (0, set_1.default)(cellData, nestedPath, value);
+                ySheetDataV3.set(key, (0, exports.createCellDataV3)(cellData, sheetId, rowIdx, colIdx));
+                trackCellKeySet(sheetId, rowIdx, key);
+            }
+            // [sheetId, rowIndex, 'values'] - Replace values array
+            else if (path.length === 3 && path[2] === "values") {
+                var _j = tslib_1.__read(path, 2), rowIndex = _j[1];
+                var rowIdx_1 = Number(rowIndex);
+                // Delete existing cells for this row
+                deleteRowCells(sheetId, rowIdx_1);
+                // Add new cells
+                if (Array.isArray(value)) {
+                    value.forEach(function (cellData, colIndex) {
+                        if (cellData) {
+                            var key = (0, exports.createCellKeyV3)(sheetId, rowIdx_1, colIndex);
+                            ySheetDataV3.set(key, (0, exports.createCellDataV3)(cellData, sheetId, rowIdx_1, colIndex));
+                            trackCellKeySet(sheetId, rowIdx_1, key);
+                        }
+                    });
+                }
+            }
+            // [sheetId, rowIndex] - Entire row update
+            else if (path.length === 2) {
+                var _k = tslib_1.__read(path, 2), rowIndex = _k[1];
+                var rowIdx_2 = Number(rowIndex);
+                // Delete existing cells for this row
+                deleteRowCells(sheetId, rowIdx_2);
+                // Add new cells from row data
+                if (value === null || value === void 0 ? void 0 : value.values) {
+                    Object.entries(value.values).forEach(function (_a) {
+                        var _b = tslib_1.__read(_a, 2), colIndexStr = _b[0], cellData = _b[1];
+                        if (cellData) {
+                            var colIndex = Number(colIndexStr);
+                            var key = (0, exports.createCellKeyV3)(sheetId, rowIdx_2, colIndex);
+                            ySheetDataV3.set(key, (0, exports.createCellDataV3)(cellData, sheetId, rowIdx_2, colIndex));
+                            trackCellKeySet(sheetId, rowIdx_2, key);
+                        }
+                    });
+                }
+            }
+            // [sheetId] - Entire sheet update
+            else if (path.length === 1) {
+                // Delete all cells for this sheet
+                var prefix = "".concat(sheetId, "!");
+                try {
+                    for (var _l = tslib_1.__values(ySheetDataV3.keys()), _m = _l.next(); !_m.done; _m = _l.next()) {
+                        var key = _m.value;
+                        if (key.startsWith(prefix)) {
+                            ySheetDataV3.delete(key);
+                        }
+                    }
+                }
+                catch (e_19_1) { e_19 = { error: e_19_1 }; }
+                finally {
+                    try {
+                        if (_m && !_m.done && (_c = _l.return)) _c.call(_l);
+                    }
+                    finally { if (e_19) throw e_19.error; }
+                }
+                dropSheetFromIndex(sheetId);
+                // Add all new data
+                if (value) {
+                    Object.entries(value).forEach(function (_a) {
+                        var _b = tslib_1.__read(_a, 2), rowIndexStr = _b[0], rowData = _b[1];
+                        if (rowData === null || rowData === void 0 ? void 0 : rowData.values) {
+                            var rowIdx_3 = Number(rowIndexStr);
+                            Object.entries(rowData.values).forEach(function (_a) {
+                                var _b = tslib_1.__read(_a, 2), colIndexStr = _b[0], cellData = _b[1];
+                                if (cellData) {
+                                    var colIndex = Number(colIndexStr);
+                                    var key = (0, exports.createCellKeyV3)(sheetId, rowIdx_3, colIndex);
+                                    ySheetDataV3.set(key, (0, exports.createCellDataV3)(cellData, sheetId, rowIdx_3, colIndex));
+                                    trackCellKeySet(sheetId, rowIdx_3, key);
+                                }
+                            });
+                        }
+                    });
+                }
+            }
+        }
+        else if (op === "remove") {
+            // Cell-level removes (path.length === 4) are already handled above via consolidation
+            // [sheetId, rowIndex, values, columnIndex, ...nestedPath] - Remove nested property
+            if (path.length > 4) {
+                var _o = tslib_1.__read(path), rowIndex = _o[1], columnIndex = _o[3], nestedPath = _o.slice(4);
+                var rowIdx = Number(rowIndex);
+                var colIdx = Number(columnIndex);
+                var key = (0, exports.createCellKeyV3)(sheetId, rowIdx, colIdx);
+                var existing = ySheetDataV3.get(key);
+                if ((existing === null || existing === void 0 ? void 0 : existing.value) && typeof existing.value === "object") {
+                    var cellData = (0, cloneDeep_1.default)(existing.value);
+                    (0, unset_1.default)(cellData, nestedPath);
+                    ySheetDataV3.set(key, (0, exports.createCellDataV3)(cellData, sheetId, rowIdx, colIdx));
+                    trackCellKeySet(sheetId, rowIdx, key);
+                }
+            }
+            // [sheetId, rowIndex] - Remove entire row
+            else if (path.length === 2) {
+                var _p = tslib_1.__read(path, 2), rowIndex = _p[1];
+                var rowIdx = Number(rowIndex);
+                deleteRowCells(sheetId, rowIdx);
+            }
+            // [sheetId] - Remove entire sheet
+            else if (path.length === 1) {
+                var prefix = "".concat(sheetId, "!");
+                try {
+                    for (var _q = tslib_1.__values(ySheetDataV3.keys()), _r = _q.next(); !_r.done; _r = _q.next()) {
+                        var key = _r.value;
+                        if (key.startsWith(prefix)) {
+                            ySheetDataV3.delete(key);
+                        }
+                    }
+                }
+                catch (e_20_1) { e_20 = { error: e_20_1 }; }
+                finally {
+                    try {
+                        if (_r && !_r.done && (_d = _q.return)) _d.call(_q);
+                    }
+                    finally { if (e_20) throw e_20.error; }
+                }
+                dropSheetFromIndex(sheetId);
+            }
+        }
+    };
+    // Only process non-cell-level patches (cell-level already handled via consolidation)
+    otherPatches.forEach(processPatch);
+};
+exports.addSheetDataPatchesV3 = addSheetDataPatchesV3;
+/**
+ * Process V3 events and return updated sheet data
+ * @param changedKeys - Pre-extracted changes from Yjs event
+ * @param currentSheetData - Current sheet data state
+ * @param ySheetDataV3 - The Y.Map for V3 data
+ */
+var processSheetDataEventsV3 = function (changedKeys, currentSheetData, ySheetDataV3) {
+    if (changedKeys.size === 0)
+        return null;
+    var next = tslib_1.__assign({}, currentSheetData);
+    // Track which sheets/rows have been cloned to avoid re-cloning
+    var clonedSheets = new Set();
+    var clonedRows = new Map(); // "sheetId:rowIdx" -> cloned
+    var hasChanges = false;
+    changedKeys.forEach(function (change, cellKey) {
+        var parsed = (0, exports.parseCellKeyV3)(cellKey);
+        if (!parsed)
+            return;
+        var sheetId = parsed.sheetId, rowIndex = parsed.rowIndex, columnIndex = parsed.columnIndex;
+        var rowIdx = rowIndex;
+        var colIdx = columnIndex;
+        var rowKey = "".concat(sheetId, ":").concat(rowIdx);
+        // Ensure sheet exists and is cloned (to avoid mutating frozen React state)
+        if (!next[sheetId]) {
+            next[sheetId] = [];
+            clonedSheets.add(sheetId);
+        }
+        else if (!clonedSheets.has(sheetId)) {
+            // Clone the sheet array to avoid mutating frozen state
+            next[sheetId] = tslib_1.__spreadArray([], tslib_1.__read(next[sheetId]), false);
+            clonedSheets.add(sheetId);
+        }
+        var sheet = next[sheetId];
+        // Extend array efficiently using length assignment instead of while loop
+        if (sheet.length <= rowIdx) {
+            sheet.length = rowIdx + 1;
+        }
+        if (change.action === "delete") {
+            // Cell was deleted
+            var row = sheet[rowIdx];
+            if ((row === null || row === void 0 ? void 0 : row.values) && colIdx < row.values.length && row.values[colIdx]) {
+                // Clone row values only once per row
+                if (!clonedRows.has(rowKey)) {
+                    sheet[rowIdx] = tslib_1.__assign(tslib_1.__assign({}, row), { values: tslib_1.__spreadArray([], tslib_1.__read(row.values), false) });
+                    clonedRows.set(rowKey, true);
+                }
+                sheet[rowIdx].values[colIdx] = null;
+                hasChanges = true;
+            }
+        }
+        else {
+            // Cell was added or updated
+            var cellDataV3 = ySheetDataV3.get(cellKey);
+            if (cellDataV3) {
+                // Ensure row exists
+                if (!sheet[rowIdx]) {
+                    sheet[rowIdx] = { values: [] };
+                    clonedRows.set(rowKey, true);
+                }
+                else if (!clonedRows.has(rowKey)) {
+                    // Clone row values only once per row
+                    var row = sheet[rowIdx];
+                    sheet[rowIdx] = tslib_1.__assign(tslib_1.__assign({}, row), { values: row.values ? tslib_1.__spreadArray([], tslib_1.__read(row.values), false) : [] });
+                    clonedRows.set(rowKey, true);
+                }
+                var values = sheet[rowIdx].values;
+                // Extend array efficiently using length assignment
+                if (values.length <= colIdx) {
+                    values.length = colIdx + 1;
+                }
+                values[colIdx] = cellDataV3.value;
+                hasChanges = true;
+            }
+        }
+    });
+    return hasChanges ? next : null;
+};
+exports.processSheetDataEventsV3 = processSheetDataEventsV3;