@bilig/headless 0.1.102 → 0.3.0

package/dist/work-paper-runtime.js

@@ -1,15 +1,68 @@
-import { SpreadsheetEngine, attachRuntimeSnapshot, makeCellKey, readRuntimeSnapshot, } from '@bilig/core';
+import { SpreadsheetEngine, attachRuntimeSnapshot, makeCellKey, readRuntimeImage, readRuntimeSnapshot, } from '@bilig/core';
 import { ErrorCode, MAX_COLS, MAX_ROWS, ValueTag, } from '@bilig/protocol';
-import { excelSerialToDateParts, formatAddress, formatRangeAddress, installExternalFunctionAdapter, isArrayValue, isCellReferenceText, parseCellAddress, parseFormula, parseRangeAddress, serializeFormula, translateFormulaReferences, } from '@bilig/formula';
-import { loadInitialMixedSheet, tryLoadInitialLiteralSheet } from './initial-sheet-load.js';
+import { excelSerialToDateParts, formatAddress, formatRangeAddress, indexToColumn, installExternalFunctionAdapter, isArrayValue, isCellReferenceText, parseCellAddress, parseFormula, parseRangeAddress, serializeFormula, translateFormulaReferences, } from '@bilig/formula';
+import { loadInitialLiteralSheet, loadInitialMixedSheet, tryLoadInitialLiteralSheet } from './initial-sheet-load.js';
 import { orderWorkPaperCellChanges } from './change-order.js';
 import { WorkPaperConfigValueTooBigError, WorkPaperConfigValueTooSmallError, WorkPaperEvaluationSuspendedError, WorkPaperExpectedValueOfTypeError, WorkPaperOperationError, WorkPaperParseError, WorkPaperSheetError, WorkPaperExpectedOneOfValuesError, WorkPaperFunctionPluginValidationError, WorkPaperInvalidArgumentsError, WorkPaperLanguageAlreadyRegisteredError, WorkPaperLanguageNotRegisteredError, WorkPaperNamedExpressionDoesNotExistError, WorkPaperNamedExpressionNameIsAlreadyTakenError, WorkPaperNamedExpressionNameIsInvalidError, WorkPaperNoOperationToRedoError, WorkPaperNoOperationToUndoError, WorkPaperNoRelativeAddressesAllowedError, WorkPaperNoSheetWithIdError, WorkPaperNoSheetWithNameError, WorkPaperNotAFormulaError, WorkPaperNothingToPasteError, WorkPaperSheetNameAlreadyTakenError, WorkPaperSheetSizeLimitExceededError, WorkPaperUnableToParseError, } from './work-paper-errors.js';
 import { buildMatrixMutationPlan } from './matrix-mutation-plan.js';
+import { readFastPhysicalRangeValues } from './fast-range-read.js';
 import { captureTrackedEngineEvent } from './tracked-engine-event-refs.js';
+import { detachTrackedIndexChanges, hasDeferredTrackedIndexChanges, materializeTrackedIndexChangeSourcesWithMetadata, materializeTrackedIndexChangesWithMetadata, } from './tracked-cell-index-changes.js';
 import { calculateWorkPaperFormulaInScratchWorkbook } from './work-paper-scratch-evaluator.js';
 import { replaceWorkPaperSheetContent } from './work-paper-sheet-replacement.js';
+const TRUSTED_TRACKED_PHYSICAL_SHEET_ID_PROPERTY = '__biligTrackedPhysicalSheetId';
+const TRUSTED_TRACKED_PHYSICAL_SORTED_SPLIT_PROPERTY = '__biligTrackedPhysicalSortedSliceSplit';
+function readTrustedPhysicalTrackedChangeMetadata(changedCellIndices) {
+    const trustedPhysicalSheetId = Reflect.get(changedCellIndices, TRUSTED_TRACKED_PHYSICAL_SHEET_ID_PROPERTY);
+    if (typeof trustedPhysicalSheetId !== 'number' || !Number.isInteger(trustedPhysicalSheetId) || trustedPhysicalSheetId < 0) {
+        return undefined;
+    }
+    const trustedSortedSliceSplit = Reflect.get(changedCellIndices, TRUSTED_TRACKED_PHYSICAL_SORTED_SPLIT_PROPERTY);
+    return typeof trustedSortedSliceSplit === 'number' && Number.isInteger(trustedSortedSliceSplit) && trustedSortedSliceSplit > 0
+        ? { trustedPhysicalSheetId, trustedSortedSliceSplit }
+        : { trustedPhysicalSheetId };
+}
 const EMPTY_NAMED_EXPRESSION_VALUES = new Map();
+const FAST_EXISTING_NUMERIC_LITERAL_FLAGS = 2 /* CellFlags.HasFormula */ | 4 /* CellFlags.JsOnly */ | 8 /* CellFlags.InCycle */ | 64 /* CellFlags.SpillChild */ | 128 /* CellFlags.PivotOutput */;
 const VISIBILITY_SHEET_STRIDE = MAX_ROWS * MAX_COLS;
+const TINY_TRACKED_CHANGE_LIMIT = 4;
+const RUNTIME_COLUMN_LABEL_CACHE = [];
+const RUNTIME_A1_CACHE_COLUMN_LIMIT = 64;
+const RUNTIME_A1_CACHE_ROW_LIMIT = 4096;
+const RUNTIME_A1_CACHE = [];
+function countPotentialNewTrackedCellMutations(refs) {
+    let count = 0;
+    for (let index = 0; index < refs.length; index += 1) {
+        const ref = refs[index];
+        if (ref && ref.cellIndex === undefined && ref.mutation.kind !== 'clearCell') {
+            count += 1;
+        }
+    }
+    return count;
+}
+function canSkipDimensionUpdateAfterLiteralMutation(refs, potentialNewCells) {
+    if (potentialNewCells !== 0 || refs.length !== 1) {
+        return false;
+    }
+    const ref = refs[0];
+    return ref?.cellIndex !== undefined && ref.mutation.kind === 'setCellValue' && ref.mutation.value !== null;
+}
+function readTrackedRuntimeCellValue(cellStore, cellIndex, strings) {
+    const tag = cellStore.tags[cellIndex] ?? ValueTag.Empty;
+    switch (tag) {
+        case ValueTag.Number:
+            return { tag: ValueTag.Number, value: cellStore.numbers[cellIndex] ?? 0 };
+        case ValueTag.Boolean:
+            return { tag: ValueTag.Boolean, value: (cellStore.numbers[cellIndex] ?? 0) !== 0 };
+        case ValueTag.String:
+            return cellStore.getValue(cellIndex, (stringId) => strings.get(stringId));
+        case ValueTag.Error:
+            return { tag: ValueTag.Error, code: cellStore.errors[cellIndex] };
+        case ValueTag.Empty:
+        default:
+            return { tag: ValueTag.Empty };
+    }
+}
 const DEFAULT_CONFIG = Object.freeze({
     accentSensitive: false,
     caseSensitive: false,
@@ -281,9 +334,6 @@ function matrixContainsFormulaContent(content) {
 function isDeferredBatchLiteralContent(content) {
     return content === null || typeof content === 'boolean' || typeof content === 'number' || typeof content === 'string';
 }
-function canUseInitialMixedSheetFastPath(content) {
-    return content.some((row) => row.some((value) => typeof value === 'string' && value.trim().startsWith('=')));
-}
 function stripLeadingEquals(formula) {
     return formula.trim().startsWith('=') ? formula.trim().slice(1) : formula.trim();
 }
@@ -508,17 +558,123 @@ function validateWorkPaperConfig(config) {
         }
     }
 }
-function validateSheetWithinLimits(sheetName, sheet, config) {
+function inspectSheetDimensionsWithinLimits(sheetName, sheet, config) {
     const height = sheet.length;
-    const width = Math.max(0, ...sheet.map((row) => row.length));
+    let width = 0;
+    let materializedHeight = 0;
+    let materializedWidth = 0;
+    for (let rowIndex = 0; rowIndex < sheet.length; rowIndex += 1) {
+        const row = sheet[rowIndex];
+        if (!Array.isArray(row)) {
+            throw new WorkPaperUnableToParseError({ sheetName, reason: 'Rows must be arrays' });
+        }
+        width = Math.max(width, row.length);
+        for (let colIndex = 0; colIndex < row.length; colIndex += 1) {
+            if (row[colIndex] !== null) {
+                materializedHeight = Math.max(materializedHeight, rowIndex + 1);
+                materializedWidth = Math.max(materializedWidth, colIndex + 1);
+            }
+        }
+    }
     if (height > (config.maxRows ?? MAX_ROWS) || width > (config.maxColumns ?? MAX_COLS)) {
         throw new WorkPaperSheetSizeLimitExceededError();
     }
-    sheet.forEach((row) => {
+    return { width: materializedWidth, height: materializedHeight };
+}
+function inspectRuntimeSnapshotSheetDimensionsWithinLimits(args) {
+    let materializedHeight = 0;
+    let materializedWidth = 0;
+    const dimensions = args.runtimeSheetCells?.dimensions;
+    if (dimensions &&
+        Number.isInteger(dimensions.width) &&
+        Number.isInteger(dimensions.height) &&
+        dimensions.width >= 0 &&
+        dimensions.height >= 0) {
+        materializedWidth = dimensions.width;
+        materializedHeight = dimensions.height;
+    }
+    else if (args.runtimeSheetCells?.coords) {
+        for (const coords of args.runtimeSheetCells.coords) {
+            materializedHeight = Math.max(materializedHeight, coords.row + 1);
+            materializedWidth = Math.max(materializedWidth, coords.col + 1);
+        }
+    }
+    else {
+        for (const cell of args.snapshotSheet.cells) {
+            const parsed = parseCellAddress(cell.address, args.sheetName);
+            materializedHeight = Math.max(materializedHeight, parsed.row + 1);
+            materializedWidth = Math.max(materializedWidth, parsed.col + 1);
+        }
+    }
+    if (materializedHeight > (args.config.maxRows ?? MAX_ROWS) || materializedWidth > (args.config.maxColumns ?? MAX_COLS)) {
+        throw new WorkPaperSheetSizeLimitExceededError();
+    }
+    return { width: materializedWidth, height: materializedHeight };
+}
+function inspectSheetWithinLimits(sheetName, sheet, config) {
+    const height = sheet.length;
+    let width = 0;
+    let materializedHeight = 0;
+    let materializedWidth = 0;
+    let materializedCellCount = 0;
+    let formulaCellCount = 0;
+    let hasFormula = false;
+    for (let rowIndex = 0; rowIndex < sheet.length; rowIndex += 1) {
+        const row = sheet[rowIndex];
         if (!Array.isArray(row)) {
             throw new WorkPaperUnableToParseError({ sheetName, reason: 'Rows must be arrays' });
         }
-    });
+        width = Math.max(width, row.length);
+        for (let colIndex = 0; colIndex < row.length; colIndex += 1) {
+            const cell = row[colIndex];
+            if (cell !== null) {
+                materializedCellCount += 1;
+                materializedHeight = Math.max(materializedHeight, rowIndex + 1);
+                materializedWidth = Math.max(materializedWidth, colIndex + 1);
+            }
+            if (typeof cell === 'string' && cellHasFormulaPrefix(cell)) {
+                formulaCellCount += 1;
+                hasFormula = true;
+            }
+        }
+    }
+    if (height > (config.maxRows ?? MAX_ROWS) || width > (config.maxColumns ?? MAX_COLS)) {
+        throw new WorkPaperSheetSizeLimitExceededError();
+    }
+    return {
+        hasFormula,
+        dimensions: { width: materializedWidth, height: materializedHeight },
+        materializedCellCount,
+        maxColumnCount: width,
+        formulaCellCount,
+    };
+}
+function cellHasFormulaPrefix(value) {
+    const first = value.charCodeAt(0);
+    if (first === 61) {
+        return true;
+    }
+    if (first !== 32 && first !== 9 && first !== 10 && first !== 13) {
+        return false;
+    }
+    return value.trimStart().charCodeAt(0) === 61;
+}
+function runtimeSnapshotMatchesSheetNames(sheets, runtimeSnapshot) {
+    const sheetNames = Object.keys(sheets);
+    if (runtimeSnapshot.sheets.length !== sheetNames.length) {
+        return false;
+    }
+    const matchedNames = new Set();
+    for (const snapshotSheet of runtimeSnapshot.sheets) {
+        if (!Object.prototype.hasOwnProperty.call(sheets, snapshotSheet.name) || matchedNames.has(snapshotSheet.name)) {
+            return false;
+        }
+        matchedNames.add(snapshotSheet.name);
+    }
+    return true;
+}
+function validateSheetWithinLimits(sheetName, sheet, config) {
+    inspectSheetWithinLimits(sheetName, sheet, config);
 }
 function functionPluginIds(config) {
     return (config.functionPlugins ?? []).map((plugin) => plugin.id).toSorted();
@@ -612,6 +768,9 @@ class WorkPaperEmitter {
         };
         this.onDetailed(eventName, wrapper);
     }
+    hasListeners(eventName) {
+        return this.listeners[eventName].size > 0 || this.detailedListeners[eventName].size > 0;
+    }
     emitDetailed(event) {
         this.dispatchDetailed(event);
     }
@@ -708,6 +867,8 @@ export class WorkPaper {
     visibilityCache = null;
     namedExpressionValueCache = null;
     sheetRecordsCache = null;
+    sheetDimensionsCache = new Map();
+    spillSheetIdsCache = null;
     batchDepth = 0;
     batchStartVisibility = null;
     batchStartNamedValues = null;
@@ -723,9 +884,124 @@ export class WorkPaper {
     suspendedCellMutationPotentialNewCells = 0;
     queuedEvents = [];
     trackedEngineEvents = [];
+    pendingLazyTrackedChanges = [];
     engineEventCaptureEnabled = true;
+    retainedTrackedEngineEventIndicesDepth = 0;
     unsubscribeEngineEvents = null;
     disposed = false;
+    getVisibleCellIndex(sheetId, row, col) {
+        const sheet = this.engine.workbook.getSheetById(sheetId);
+        if (!sheet) {
+            return undefined;
+        }
+        return this.getVisibleCellIndexInSheet(sheet, row, col);
+    }
+    getVisibleCellIndexInSheet(sheet, row, col) {
+        if (sheet.structureVersion === 1) {
+            const cellIndex = sheet.grid.getPhysical(row, col);
+            return cellIndex === -1 ? undefined : cellIndex;
+        }
+        return sheet.logical.getVisibleCell(row, col);
+    }
+    cacheSheetDimensions(sheetId, dimensions) {
+        this.sheetDimensionsCache.set(sheetId, { width: dimensions.width, height: dimensions.height });
+    }
+    cacheInitializedSheetDimensions(sheetId, dimensions) {
+        if (this.sheetHasSpills(sheetId)) {
+            this.sheetDimensionsCache.delete(sheetId);
+            return;
+        }
+        this.cacheSheetDimensions(sheetId, dimensions);
+    }
+    sheetHasSpills(sheetId) {
+        if (this.spillSheetIdsCache === null) {
+            const spillSheetIds = new Set();
+            this.engine.workbook.listSpills().forEach((spill) => {
+                const spillSheet = this.engine.workbook.getSheet(spill.sheetName);
+                if (spillSheet) {
+                    spillSheetIds.add(spillSheet.id);
+                }
+            });
+            this.spillSheetIdsCache = spillSheetIds;
+        }
+        return this.spillSheetIdsCache.has(sheetId);
+    }
+    scanSheetDimensions(sheet) {
+        let width = 0;
+        let height = 0;
+        sheet.grid.forEachCellEntry((_cellIndex, row, col) => {
+            height = Math.max(height, row + 1);
+            width = Math.max(width, col + 1);
+        });
+        return { width, height };
+    }
+    invalidateSheetDimensions(sheetId) {
+        this.sheetDimensionsCache.delete(sheetId);
+    }
+    invalidateAllSheetDimensions() {
+        this.sheetDimensionsCache.clear();
+        this.spillSheetIdsCache = null;
+    }
+    expandCachedSheetDimensions(sheetId, row, col) {
+        const cached = this.sheetDimensionsCache.get(sheetId);
+        if (!cached) {
+            return;
+        }
+        cached.height = Math.max(cached.height, row + 1);
+        cached.width = Math.max(cached.width, col + 1);
+    }
+    invalidateCachedSheetDimensionsIfEdge(sheetId, row, col) {
+        const cached = this.sheetDimensionsCache.get(sheetId);
+        if (!cached) {
+            return;
+        }
+        if (row + 1 >= cached.height || col + 1 >= cached.width) {
+            this.invalidateSheetDimensions(sheetId);
+        }
+    }
+    updateSheetDimensionsAfterCellMutationRefs(refs) {
+        if (this.sheetDimensionsCache.size === 0) {
+            return;
+        }
+        if (refs.length === 1) {
+            const ref = refs[0];
+            const mutation = ref?.mutation;
+            if (ref && mutation && mutation.kind !== 'setCellFormula') {
+                const cached = this.sheetDimensionsCache.get(ref.sheetId);
+                if (!cached) {
+                    return;
+                }
+                const noKnownSpills = this.spillSheetIdsCache !== null && !this.spillSheetIdsCache.has(ref.sheetId);
+                if (noKnownSpills &&
+                    (mutation.kind === 'setCellValue'
+                        ? mutation.row + 1 <= cached.height && mutation.col + 1 <= cached.width
+                        : mutation.row + 1 < cached.height && mutation.col + 1 < cached.width)) {
+                    return;
+                }
+            }
+        }
+        for (let index = 0; index < refs.length; index += 1) {
+            const ref = refs[index];
+            if (!ref) {
+                continue;
+            }
+            const mutation = ref.mutation;
+            if (mutation.kind === 'setCellFormula') {
+                this.spillSheetIdsCache = null;
+                this.invalidateSheetDimensions(ref.sheetId);
+                continue;
+            }
+            if (this.sheetHasSpills(ref.sheetId)) {
+                this.invalidateSheetDimensions(ref.sheetId);
+                continue;
+            }
+            if (mutation.kind === 'clearCell') {
+                this.invalidateCachedSheetDimensionsIfEdge(ref.sheetId, mutation.row, mutation.col);
+                continue;
+            }
+            this.expandCachedSheetDimensions(ref.sheetId, mutation.row, mutation.col);
+        }
+    }
     constructor(configInput = {}) {
         ensureCustomAdapterInstalled();
         validateWorkPaperConfig(configInput);
@@ -738,6 +1014,7 @@ export class WorkPaper {
             useColumnIndex: this.config.useColumnIndex,
             trackReplicaVersions: false,
         });
+        this.invalidateAllSheetDimensions();
         this.attachEngineEventTracking();
         this.captureFunctionRegistry();
         this.internals = Object.freeze({
@@ -811,38 +1088,69 @@ export class WorkPaper {
     static buildFromSheets(sheets, configInput = {}, namedExpressions = []) {
         const workbook = new WorkPaper(configInput);
         const runtimeSnapshot = namedExpressions.length === 0 ? readRuntimeSnapshot(sheets) : undefined;
-        const runtimeSnapshotMatchesSheets = runtimeSnapshot !== undefined &&
-            runtimeSnapshot.sheets.length === Object.keys(sheets).length &&
-            runtimeSnapshot.sheets.every((sheet) => Object.prototype.hasOwnProperty.call(sheets, sheet.name));
+        const runtimeSnapshotMatchesSheets = runtimeSnapshot !== undefined && runtimeSnapshotMatchesSheetNames(sheets, runtimeSnapshot);
+        const runtimeSnapshotSheetsByName = runtimeSnapshotMatchesSheets
+            ? new Map(runtimeSnapshot.sheets.map((sheet) => [sheet.name, sheet]))
+            : undefined;
+        const runtimeImageSheetCellsByName = runtimeSnapshotMatchesSheets && runtimeSnapshot
+            ? new Map((readRuntimeImage(runtimeSnapshot)?.sheetCells ?? []).map((sheet) => [sheet.sheetName, sheet]))
+            : undefined;
+        const inspectedSheets = new Map();
         Object.entries(sheets).forEach(([sheetName, sheet]) => {
-            validateSheetWithinLimits(sheetName, sheet, workbook.config);
+            const snapshotSheet = runtimeSnapshotSheetsByName?.get(sheetName);
+            inspectedSheets.set(sheetName, snapshotSheet
+                ? (() => {
+                    const dimensions = inspectRuntimeSnapshotSheetDimensionsWithinLimits({
+                        sheetName,
+                        snapshotSheet,
+                        runtimeSheetCells: runtimeImageSheetCellsByName?.get(sheetName),
+                        config: workbook.config,
+                    });
+                    return {
+                        hasFormula: false,
+                        dimensions,
+                        materializedCellCount: runtimeImageSheetCellsByName?.get(sheetName)?.cellCount ?? 0,
+                        maxColumnCount: dimensions.width,
+                        formulaCellCount: 0,
+                    };
+                })()
+                : inspectSheetWithinLimits(sheetName, sheet, workbook.config));
         });
         workbook.withEngineEventCaptureDisabled(() => {
             if (runtimeSnapshot && runtimeSnapshotMatchesSheets) {
                 workbook.engine.importSnapshot(runtimeSnapshot);
-                return;
             }
-            Object.keys(sheets).forEach((sheetName) => {
-                workbook.engine.createSheet(sheetName);
-            });
-            namedExpressions.forEach((expression) => {
-                workbook.upsertNamedExpressionInternal(expression, { duringInitialization: true });
-            });
-            Object.entries(sheets).forEach(([sheetName, sheet]) => {
-                const sheetId = workbook.requireSheetId(sheetName);
-                if (tryLoadInitialLiteralSheet(workbook.engine, sheetId, sheet)) {
-                    return;
-                }
-                if (canUseInitialMixedSheetFastPath(sheet)) {
+            else {
+                Object.keys(sheets).forEach((sheetName) => {
+                    workbook.engine.createSheet(sheetName);
+                });
+                namedExpressions.forEach((expression) => {
+                    workbook.upsertNamedExpressionInternal(expression, { duringInitialization: true });
+                });
+                Object.entries(sheets).forEach(([sheetName, sheet]) => {
+                    const sheetId = workbook.requireSheetId(sheetName);
+                    const inspected = inspectedSheets.get(sheetName);
+                    if (!inspected?.hasFormula) {
+                        loadInitialLiteralSheet(workbook.engine, sheetId, sheet, inspected);
+                        return;
+                    }
+                    const rewriteInitialFormula = workbook.namedExpressions.size === 0 && workbook.functionAliasLookup.size === 0
+                        ? (formula) => formula
+                        : (formula) => workbook.rewriteFormulaForStorage(formula, sheetId);
                     loadInitialMixedSheet({
                         engine: workbook.engine,
                         sheetId,
                         content: sheet,
-                        rewriteFormula: (formula, destination) => workbook.rewriteFormulaForStorage(formula, destination.sheet),
+                        rewriteFormula: rewriteInitialFormula,
+                        inspection: inspected,
                     });
-                    return;
+                });
+            }
+            Object.keys(sheets).forEach((sheetName) => {
+                const inspected = inspectedSheets.get(sheetName);
+                if (inspected) {
+                    workbook.cacheInitializedSheetDimensions(workbook.requireSheetId(sheetName), inspected.dimensions);
                 }
-                workbook.replaceSheetContentInternal(sheetId, sheet, { duringInitialization: true });
             });
         });
         workbook.clearHistoryStacks();
@@ -1008,6 +1316,7 @@ export class WorkPaper {
     }
     updateConfig(next) {
         this.assertNotDisposed();
+        this.materializePendingLazyTrackedChanges();
         const merged = {
             ...this.config,
             ...cloneConfig(next),
@@ -1043,9 +1352,11 @@ export class WorkPaper {
     }
     rebuildAndRecalculate() {
         this.assertNotDisposed();
+        this.materializePendingLazyTrackedChanges();
         if (this.shouldSuppressEvents()) {
             try {
                 this.engine.recalculateNow();
+                this.invalidateAllSheetDimensions();
             }
             catch (error) {
                 throw new WorkPaperOperationError(this.messageOf(error, 'Recalculation failed'));
@@ -1057,6 +1368,7 @@ export class WorkPaper {
         this.drainTrackedEngineEvents();
         try {
             this.engine.recalculateNow();
+            this.invalidateAllSheetDimensions();
         }
         catch (error) {
             throw new WorkPaperOperationError(this.messageOf(error, 'Recalculation failed'));
@@ -1069,13 +1381,14 @@ export class WorkPaper {
             ...this.computeCellChanges(beforeVisibility, afterVisibility),
             ...this.computeNamedExpressionChanges(beforeNames, afterNames),
         ];
-        if (changes.length > 0) {
+        if (changes.length > 0 && this.emitter.hasListeners('valuesUpdated')) {
             this.emitter.emitDetailed({ eventName: 'valuesUpdated', payload: { changes } });
         }
         return changes;
     }
     batch(batchOperations) {
         this.assertNotDisposed();
+        this.materializePendingLazyTrackedChanges();
         const isOutermost = this.batchDepth === 0;
         if (isOutermost) {
             this.batchUsesTrackedFastPath = this.canUseTrackedMutationFastPath();
@@ -1097,22 +1410,32 @@ export class WorkPaper {
         finally {
             this.batchDepth -= 1;
             if (isOutermost) {
-                this.flushPendingBatchOps();
+                if (this.batchUsesTrackedFastPath) {
+                    this.withRetainedTrackedEngineEventIndices(() => {
+                        this.flushPendingBatchOps();
+                    });
+                }
+                else {
+                    this.flushPendingBatchOps();
+                }
                 this.mergeUndoHistory(this.batchUndoStackLength);
             }
         }
         if (!isOutermost) {
             return [];
         }
+        const shouldEmitValuesUpdated = this.emitter.hasListeners('valuesUpdated');
         const changes = this.batchUsesTrackedFastPath
-            ? this.computeTrackedChangesWithoutVisibilityCache(this.drainTrackedEngineEvents())
+            ? this.computeTrackedChangesWithoutVisibilityCache(this.drainTrackedEngineEvents(), {
+                preferLazyPublicChanges: !shouldEmitValuesUpdated,
+            })
             : this.computeChangesAfterMutation(this.batchStartVisibility ?? new Map(), this.batchStartNamedValues ?? new Map());
         this.batchUsesTrackedFastPath = false;
         this.batchStartVisibility = null;
         this.batchStartNamedValues = null;
         if (!this.evaluationSuspended) {
             this.flushQueuedEvents();
-            if (changes.length > 0) {
+            if (changes.length > 0 && shouldEmitValuesUpdated) {
                 this.emitter.emitDetailed({ eventName: 'valuesUpdated', payload: { changes } });
             }
         }
@@ -1120,6 +1443,7 @@ export class WorkPaper {
     }
     suspendEvaluation() {
         this.assertNotDisposed();
+        this.materializePendingLazyTrackedChanges();
         if (this.evaluationSuspended) {
             return;
         }
@@ -1140,12 +1464,23 @@ export class WorkPaper {
     }
     resumeEvaluation() {
         this.assertNotDisposed();
+        this.materializePendingLazyTrackedChanges();
         if (!this.evaluationSuspended) {
             return [];
         }
-        this.flushSuspendedCellMutations();
+        if (this.suspendedUsesTrackedFastPath) {
+            this.withRetainedTrackedEngineEventIndices(() => {
+                this.flushSuspendedCellMutations();
+            });
+        }
+        else {
+            this.flushSuspendedCellMutations();
+        }
+        const shouldEmitValuesUpdated = this.emitter.hasListeners('valuesUpdated');
         const changes = this.suspendedUsesTrackedFastPath
-            ? this.computeTrackedChangesWithoutVisibilityCache(this.drainTrackedEngineEvents())
+            ? this.computeTrackedChangesWithoutVisibilityCache(this.drainTrackedEngineEvents(), {
+                preferLazyPublicChanges: !shouldEmitValuesUpdated,
+            })
             : this.computeChangesAfterMutation(this.suspendedVisibility ?? new Map(), this.suspendedNamedValues ?? new Map());
         this.evaluationSuspended = false;
         this.suspendedVisibility = null;
@@ -1153,7 +1488,7 @@ export class WorkPaper {
         this.suspendedUsesTrackedFastPath = false;
         this.flushQueuedEvents();
         this.emitter.emitDetailed({ eventName: 'evaluationResumed', payload: { changes } });
-        if (changes.length > 0) {
+        if (changes.length > 0 && shouldEmitValuesUpdated) {
             this.emitter.emitDetailed({ eventName: 'valuesUpdated', payload: { changes } });
         }
         return changes;
@@ -1163,19 +1498,39 @@ export class WorkPaper {
     }
     undo() {
         this.assertNotDisposed();
+        const preservesPositions = !this.historyTopIsCellMutations(this.getUndoStack());
+        if (this.canUseTrackedMutationFastPath()) {
+            return this.captureTrackedChangesWithoutVisibilityCache(() => {
+                if (!this.engine.undo()) {
+                    throw new WorkPaperNoOperationToUndoError();
+                }
+                this.invalidateAllSheetDimensions();
+            }, { preservePendingTrackedPositions: preservesPositions });
+        }
         return this.captureChanges(undefined, () => {
             if (!this.engine.undo()) {
                 throw new WorkPaperNoOperationToUndoError();
             }
-        });
+            this.invalidateAllSheetDimensions();
+        }, { preservePendingTrackedPositions: preservesPositions });
     }
     redo() {
         this.assertNotDisposed();
+        const preservesPositions = !this.historyTopIsCellMutations(this.getRedoStack());
+        if (this.canUseTrackedMutationFastPath()) {
+            return this.captureTrackedChangesWithoutVisibilityCache(() => {
+                if (!this.engine.redo()) {
+                    throw new WorkPaperNoOperationToRedoError();
+                }
+                this.invalidateAllSheetDimensions();
+            }, { preservePendingTrackedPositions: preservesPositions });
+        }
         return this.captureChanges(undefined, () => {
             if (!this.engine.redo()) {
                 throw new WorkPaperNoOperationToRedoError();
             }
-        });
+            this.invalidateAllSheetDimensions();
+        }, { preservePendingTrackedPositions: preservesPositions });
     }
     isThereSomethingToUndo() {
         return this.getUndoStack().length > 0;
@@ -1254,7 +1609,11 @@ export class WorkPaper {
     }
     getCellValue(address) {
         this.assertReadable();
-        return cloneCellValue(this.engine.getCellValue(this.sheetName(address.sheet), this.a1(address)));
+        const sheet = this.sheetRecord(address.sheet);
+        const cellIndex = this.getVisibleCellIndexInSheet(sheet, address.row, address.col);
+        return cellIndex === undefined
+            ? emptyValue()
+            : readTrackedRuntimeCellValue(this.engine.workbook.cellStore, cellIndex, this.engine.strings);
     }
     getCellFormula(address) {
         this.prepareReadableState();
@@ -1282,6 +1641,11 @@ export class WorkPaper {
     }
     getRangeValues(range) {
         this.assertReadable();
+        assertRange(range);
+        const fastValues = readFastPhysicalRangeValues(this.engine, range);
+        if (fastValues !== undefined) {
+            return fastValues;
+        }
         const ref = this.rangeRef(range);
         return this.engine.getRangeValues(ref);
     }
@@ -1340,13 +1704,13 @@ export class WorkPaper {
     getSheetDimensions(sheetId) {
         this.prepareReadableState();
         const sheet = this.sheetRecord(sheetId);
-        let width = 0;
-        let height = 0;
-        sheet.grid.forEachCellEntry((_cellIndex, row, col) => {
-            height = Math.max(height, row + 1);
-            width = Math.max(width, col + 1);
-        });
-        return { width, height };
+        const cached = this.sheetDimensionsCache.get(sheetId);
+        if (cached) {
+            return { width: cached.width, height: cached.height };
+        }
+        const dimensions = this.scanSheetDimensions(sheet);
+        this.cacheSheetDimensions(sheetId, dimensions);
+        return dimensions;
     }
     simpleCellAddressFromString(value, defaultSheetId) {
         this.assertNotDisposed();
@@ -1744,6 +2108,81 @@ export class WorkPaper {
         const { hours, minutes, seconds } = dateTime;
         return { hours, minutes, seconds };
     }
+    trySetExistingNumericCellContentsWithTrackedFastPath(args) {
+        if (!this.canUseTrackedMutationFastPath() || args.sheet.structureVersion !== 1) {
+            return null;
+        }
+        const cellStore = this.engine.workbook.cellStore;
+        if (cellStore.sheetIds[args.cellIndex] !== args.address.sheet ||
+            cellStore.rows[args.cellIndex] !== args.address.row ||
+            cellStore.cols[args.cellIndex] !== args.address.col ||
+            (cellStore.formulaIds[args.cellIndex] ?? 0) !== 0 ||
+            ((cellStore.flags[args.cellIndex] ?? 0) & FAST_EXISTING_NUMERIC_LITERAL_FLAGS) !== 0 ||
+            cellStore.tags[args.cellIndex] !== ValueTag.Number) {
+            return null;
+        }
+        const existingNumericMutationEngine = this.engine;
+        if (typeof existingNumericMutationEngine.tryApplyExistingNumericCellMutationAt !== 'function') {
+            return null;
+        }
+        if (this.pendingLazyTrackedChanges.length > 0) {
+            this.materializePendingLazyTrackedChanges();
+        }
+        if (this.trackedEngineEvents.length > 0) {
+            this.drainTrackedEngineEvents();
+        }
+        let result = null;
+        const oldNumericValue = cellStore.numbers[args.cellIndex] ?? 0;
+        const previousCaptureEnabled = this.engineEventCaptureEnabled;
+        this.engineEventCaptureEnabled = false;
+        try {
+            if (this.pendingBatchOps.length > 0) {
+                this.flushPendingBatchOps();
+            }
+            const request = {
+                sheetId: args.address.sheet,
+                row: args.address.row,
+                col: args.address.col,
+                cellIndex: args.cellIndex,
+                value: args.value,
+                emitTracked: false,
+                trustedExistingNumericLiteral: true,
+                oldNumericValue,
+            };
+            result = existingNumericMutationEngine.tryApplyExistingNumericCellMutationAt(request);
+        }
+        catch (error) {
+            if (error instanceof Error && WORKPAPER_PUBLIC_ERROR_NAMES.has(error.name)) {
+                throw error;
+            }
+            throw new WorkPaperOperationError(this.messageOf(error, 'Mutation failed'));
+        }
+        finally {
+            this.engineEventCaptureEnabled = previousCaptureEnabled;
+        }
+        if (!result) {
+            return null;
+        }
+        if (this.trackedEngineEvents.length > 0) {
+            this.trackedEngineEvents = [];
+        }
+        let changes = this.tryBuildDirectExistingNumericTrackedChanges(result, args.address, args.cellIndex, true, args.sheet.name, args.value);
+        if (changes === null) {
+            const shouldEmitValuesUpdated = this.emitter.hasListeners('valuesUpdated');
+            const events = [this.trackedEventFromExistingNumericMutationResult(result)];
+            changes = this.computeTrackedChangesWithoutVisibilityCache(events, {
+                preferLazyPublicChanges: !shouldEmitValuesUpdated,
+            });
+            if (changes.length > 0 && shouldEmitValuesUpdated) {
+                this.emitter.emitDetailed({ eventName: 'valuesUpdated', payload: { changes } });
+            }
+            return changes;
+        }
+        if (changes.length > 0 && this.emitter.hasListeners('valuesUpdated')) {
+            this.emitter.emitDetailed({ eventName: 'valuesUpdated', payload: { changes } });
+        }
+        return changes;
+    }
     setCellContents(address, content) {
         this.assertNotDisposed();
         const sheet = this.sheetRecord(address.sheet);
@@ -1753,15 +2192,40 @@ export class WorkPaper {
             if (address.row >= (this.config.maxRows ?? MAX_ROWS) || address.col >= (this.config.maxColumns ?? MAX_COLS)) {
                 throw new WorkPaperOperationError('Cell contents cannot be set');
             }
-            const existingCellIndex = sheet.grid.get(address.row, address.col);
-            if (this.enqueueSuspendedLiteralMutation(address.sheet, address.row, address.col, content, existingCellIndex)) {
+            const visibleCellIndex = this.getVisibleCellIndexInSheet(sheet, address.row, address.col);
+            if (this.evaluationSuspended &&
+                this.enqueueSuspendedLiteralMutation(address.sheet, address.row, address.col, content, visibleCellIndex)) {
                 return [];
             }
-            if (this.enqueueDeferredBatchLiteral(address.sheet, address.row, address.col, content, existingCellIndex)) {
+            if (this.batchDepth !== 0 && this.enqueueDeferredBatchLiteral(address.sheet, address.row, address.col, content, visibleCellIndex)) {
                 return [];
             }
+            if (typeof content === 'number' && visibleCellIndex !== undefined) {
+                const fastPathChanges = this.trySetExistingNumericCellContentsWithTrackedFastPath({
+                    sheet,
+                    address,
+                    cellIndex: visibleCellIndex,
+                    value: content,
+                });
+                if (fastPathChanges !== null) {
+                    return fastPathChanges;
+                }
+            }
             const mutate = () => {
                 this.flushPendingBatchOps();
+                const existingNumericMutationEngine = this.engine;
+                if (typeof content === 'number' &&
+                    visibleCellIndex !== undefined &&
+                    sheet.structureVersion === 1 &&
+                    existingNumericMutationEngine.tryApplyExistingNumericCellMutationAt?.({
+                        sheetId: address.sheet,
+                        row: address.row,
+                        col: address.col,
+                        cellIndex: visibleCellIndex,
+                        value: content,
+                    })) {
+                    return;
+                }
                 const mutation = content === null
                     ? { kind: 'clearCell', row: address.row, col: address.col }
                     : typeof content === 'string' && content.trim().startsWith('=')
@@ -1777,16 +2241,26 @@ export class WorkPaper {
                             col: address.col,
                             value: content,
                         };
-                this.applyCellMutationRefs([{ sheetId: address.sheet, mutation }], {
+                this.applyCellMutationRefs([{ sheetId: address.sheet, mutation, ...(visibleCellIndex !== undefined ? { cellIndex: visibleCellIndex } : {}) }], {
                     captureUndo: true,
-                    potentialNewCells: content === null || existingCellIndex !== -1 ? 0 : 1,
+                    potentialNewCells: content === null || visibleCellIndex !== undefined ? 0 : 1,
                     source: 'local',
                     returnUndoOps: false,
                     reuseRefs: true,
                 });
             };
             if (this.canUseTrackedMutationFastPath()) {
-                return this.captureTrackedChangesWithoutVisibilityCache(mutate);
+                return this.captureTrackedChangesWithoutVisibilityCache(mutate, {
+                    singleLiteralChange: isFormulaContent(content)
+                        ? undefined
+                        : {
+                            address: { sheet: address.sheet, row: address.row, col: address.col },
+                            ...(visibleCellIndex === undefined ? {} : { cellIndex: visibleCellIndex }),
+                            isPhysicalSheet: sheet.structureVersion === 1,
+                            sheetName: sheet.name,
+                            value: content,
+                        },
+                });
             }
             return this.captureChanges(undefined, () => {
                 mutate();
@@ -1884,9 +2358,17 @@ export class WorkPaper {
         if (!this.isItPossibleToAddRows(sheetId, ...indexes)) {
             throw new WorkPaperOperationError('Rows cannot be added');
         }
+        if (indexes.length === 1 && this.canUseTrackedStructuralFastPath()) {
+            const [start, amount] = indexes[0];
+            return this.captureTrackedChangesWithoutVisibilityCache(() => {
+                this.engine.insertRows(this.sheetName(sheetId), start, amount);
+                this.invalidateSheetDimensions(sheetId);
+            });
+        }
         return this.batchStructuralChanges(() => {
             indexes.forEach(([start, amount]) => {
                 this.engine.insertRows(this.sheetName(sheetId), start, amount);
+                this.invalidateSheetDimensions(sheetId);
             });
         });
     }
@@ -1895,11 +2377,19 @@ export class WorkPaper {
         if (!this.isItPossibleToRemoveRows(sheetId, ...indexes)) {
             throw new WorkPaperOperationError('Rows cannot be removed');
         }
+        if (indexes.length === 1 && this.canUseTrackedStructuralFastPath()) {
+            const [start, amount] = indexes[0];
+            return this.captureTrackedChangesWithoutVisibilityCache(() => {
+                this.engine.deleteRows(this.sheetName(sheetId), start, amount);
+                this.invalidateSheetDimensions(sheetId);
+            });
+        }
         return this.batchStructuralChanges(() => {
             indexes
                 .toSorted((left, right) => right[0] - left[0])
                 .forEach(([start, amount]) => {
                 this.engine.deleteRows(this.sheetName(sheetId), start, amount);
+                this.invalidateSheetDimensions(sheetId);
             });
         });
     }
@@ -1908,9 +2398,17 @@ export class WorkPaper {
         if (!this.isItPossibleToAddColumns(sheetId, ...indexes)) {
             throw new WorkPaperOperationError('Columns cannot be added');
         }
+        if (indexes.length === 1 && this.canUseTrackedStructuralFastPath()) {
+            const [start, amount] = indexes[0];
+            return this.captureTrackedChangesWithoutVisibilityCache(() => {
+                this.engine.insertColumns(this.sheetName(sheetId), start, amount);
+                this.invalidateSheetDimensions(sheetId);
+            });
+        }
         return this.batchStructuralChanges(() => {
             indexes.forEach(([start, amount]) => {
                 this.engine.insertColumns(this.sheetName(sheetId), start, amount);
+                this.invalidateSheetDimensions(sheetId);
             });
         });
     }
@@ -1919,11 +2417,19 @@ export class WorkPaper {
         if (!this.isItPossibleToRemoveColumns(sheetId, ...indexes)) {
             throw new WorkPaperOperationError('Columns cannot be removed');
         }
+        if (indexes.length === 1 && this.canUseTrackedStructuralFastPath()) {
+            const [start, amount] = indexes[0];
+            return this.captureTrackedChangesWithoutVisibilityCache(() => {
+                this.engine.deleteColumns(this.sheetName(sheetId), start, amount);
+                this.invalidateSheetDimensions(sheetId);
+            });
+        }
         return this.batchStructuralChanges(() => {
             indexes
                 .toSorted((left, right) => right[0] - left[0])
                 .forEach(([start, amount]) => {
                 this.engine.deleteColumns(this.sheetName(sheetId), start, amount);
+                this.invalidateSheetDimensions(sheetId);
             });
         });
     }
@@ -1939,6 +2445,8 @@ export class WorkPaper {
                 startAddress: formatAddress(target.row, target.col),
                 endAddress: formatAddress(target.row + sourceHeight, target.col + sourceWidth),
             });
+            this.invalidateSheetDimensions(source.start.sheet);
+            this.invalidateSheetDimensions(target.sheet);
         });
     }
     moveRows(sheetId, start, count, target) {
@@ -1946,11 +2454,13 @@ export class WorkPaper {
             throw new WorkPaperOperationError('Rows cannot be moved');
         }
         return this.canUseTrackedStructuralFastPath()
-            ? this.batchStructuralChanges(() => {
+            ? this.captureTrackedChangesWithoutVisibilityCache(() => {
                 this.engine.moveRows(this.sheetName(sheetId), start, count, target);
+                this.invalidateSheetDimensions(sheetId);
             })
             : this.captureChanges(undefined, () => {
                 this.engine.moveRows(this.sheetName(sheetId), start, count, target);
+                this.invalidateSheetDimensions(sheetId);
             });
     }
     moveColumns(sheetId, start, count, target) {
@@ -1958,15 +2468,18 @@ export class WorkPaper {
             throw new WorkPaperOperationError('Columns cannot be moved');
         }
         return this.canUseTrackedStructuralFastPath()
-            ? this.batchStructuralChanges(() => {
+            ? this.captureTrackedChangesWithoutVisibilityCache(() => {
                 this.engine.moveColumns(this.sheetName(sheetId), start, count, target);
+                this.invalidateSheetDimensions(sheetId);
             })
             : this.captureChanges(undefined, () => {
                 this.engine.moveColumns(this.sheetName(sheetId), start, count, target);
+                this.invalidateSheetDimensions(sheetId);
             });
     }
     addSheet(sheetName) {
         this.assertNotDisposed();
+        this.materializePendingLazyTrackedChanges();
         const name = sheetName?.trim() || this.nextSheetName();
         if (!this.isItPossibleToAddSheet(name)) {
             throw new WorkPaperSheetNameAlreadyTakenError(name);
@@ -1977,6 +2490,7 @@ export class WorkPaper {
         this.engine.createSheet(name);
         this.sheetRecordsCache = null;
         const sheetId = this.requireSheetId(name);
+        this.cacheSheetDimensions(sheetId, { width: 0, height: 0 });
         const payload = { sheetId, sheetName: name };
         if (this.shouldSuppressEvents()) {
             this.queuedEvents.push({ eventName: 'sheetAdded', payload });
@@ -1985,7 +2499,7 @@ export class WorkPaper {
             this.emitter.emitDetailed({ eventName: 'sheetAdded', payload });
         }
         const changes = this.computeChangesAfterMutation(beforeVisibility, beforeNames);
-        if (!this.shouldSuppressEvents() && changes.length > 0) {
+        if (!this.shouldSuppressEvents() && changes.length > 0 && this.emitter.hasListeners('valuesUpdated')) {
             this.emitter.emitDetailed({ eventName: 'valuesUpdated', payload: { changes } });
         }
         return name;
@@ -2005,6 +2519,7 @@ export class WorkPaper {
         }, () => {
             this.engine.deleteSheet(sheetName);
             this.sheetRecordsCache = null;
+            this.invalidateSheetDimensions(sheetId);
         });
     }
     clearSheet(sheetId) {
@@ -2021,6 +2536,7 @@ export class WorkPaper {
                 startAddress: 'A1',
                 endAddress: formatAddress(dimensions.height - 1, dimensions.width - 1),
             });
+            this.cacheSheetDimensions(sheetId, { width: 0, height: 0 });
         });
     }
     setSheetContent(sheetId, content) {
@@ -2207,6 +2723,7 @@ export class WorkPaper {
         if (this.disposed) {
             return;
         }
+        this.materializePendingLazyTrackedChanges();
         this.disposed = true;
         this.unsubscribeEngineEvents?.();
         this.unsubscribeEngineEvents = null;
@@ -2215,8 +2732,11 @@ export class WorkPaper {
         this.clipboard = null;
         this.visibilityCache = null;
         this.namedExpressionValueCache = null;
+        this.sheetDimensionsCache.clear();
+        this.spillSheetIdsCache = null;
         this.queuedEvents = [];
         this.trackedEngineEvents = [];
+        this.pendingLazyTrackedChanges = [];
         this.namedExpressions.clear();
     }
     attachEngineEventTracking() {
@@ -2229,9 +2749,21 @@ export class WorkPaper {
             if (!this.engineEventCaptureEnabled) {
                 return;
             }
-            this.trackedEngineEvents.push(captureTrackedEngineEvent(event));
+            this.trackedEngineEvents.push(captureTrackedEngineEvent(event, {
+                borrowChangedCellIndexViews: this.retainedTrackedEngineEventIndicesDepth > 0,
+                cloneChangedCellIndices: this.retainedTrackedEngineEventIndicesDepth === 0,
+            }));
         });
     }
+    withRetainedTrackedEngineEventIndices(callback) {
+        this.retainedTrackedEngineEventIndicesDepth += 1;
+        try {
+            return callback();
+        }
+        finally {
+            this.retainedTrackedEngineEventIndicesDepth -= 1;
+        }
+    }
     withEngineEventCaptureDisabled(callback) {
         const previous = this.engineEventCaptureEnabled;
         this.engineEventCaptureEnabled = false;
@@ -2249,6 +2781,77 @@ export class WorkPaper {
         this.trackedEngineEvents = [];
         return events;
     }
+    existingNumericMutationChangedCellCount(result) {
+        return result.changedCellIndices?.length ?? result.changedCellCount ?? 0;
+    }
+    existingNumericMutationChangedCellAt(result, index) {
+        if (result.changedCellIndices) {
+            return result.changedCellIndices[index];
+        }
+        if (index === 0) {
+            return result.firstChangedCellIndex;
+        }
+        if (index === 1) {
+            return result.secondChangedCellIndex;
+        }
+        return undefined;
+    }
+    materializeExistingNumericMutationChangedCellIndices(result) {
+        if (result.changedCellIndices) {
+            return result.changedCellIndices;
+        }
+        const count = this.existingNumericMutationChangedCellCount(result);
+        const changed = new Uint32Array(count);
+        for (let index = 0; index < count; index += 1) {
+            changed[index] = this.existingNumericMutationChangedCellAt(result, index) ?? 0;
+        }
+        return changed;
+    }
+    trackedEventFromExistingNumericMutationResult(result) {
+        let sortedDisjoint = true;
+        let previous = -1;
+        let firstChangedCellIndex;
+        let lastChangedCellIndex;
+        const changedCellCount = this.existingNumericMutationChangedCellCount(result);
+        for (let index = 0; index < changedCellCount; index += 1) {
+            const cellIndex = this.existingNumericMutationChangedCellAt(result, index) ?? -1;
+            if (index === 0) {
+                firstChangedCellIndex = cellIndex;
+            }
+            if (!Number.isInteger(cellIndex) || cellIndex < 0 || cellIndex <= previous) {
+                sortedDisjoint = false;
+            }
+            previous = cellIndex;
+            lastChangedCellIndex = cellIndex;
+        }
+        return {
+            invalidation: 'cells',
+            changedCellIndices: this.materializeExistingNumericMutationChangedCellIndices(result),
+            changedInputCount: 1,
+            explicitChangedCount: result.explicitChangedCount,
+            changedCellIndicesSortedDisjoint: sortedDisjoint,
+            ...(firstChangedCellIndex === undefined ? {} : { firstChangedCellIndex }),
+            ...(lastChangedCellIndex === undefined ? {} : { lastChangedCellIndex }),
+            hasInvalidatedRanges: false,
+            hasInvalidatedRows: false,
+            hasInvalidatedColumns: false,
+        };
+    }
+    trackLazyTrackedChanges(changes) {
+        if (hasDeferredTrackedIndexChanges(changes)) {
+            this.pendingLazyTrackedChanges.push(changes);
+        }
+    }
+    materializePendingLazyTrackedChanges(options = {}) {
+        if (this.pendingLazyTrackedChanges.length === 0) {
+            return;
+        }
+        const pending = this.pendingLazyTrackedChanges;
+        this.pendingLazyTrackedChanges = [];
+        for (let index = 0; index < pending.length; index += 1) {
+            detachTrackedIndexChanges(pending[index], { preservePositions: options.preservePositions });
+        }
+    }
     resetChangeTrackingCaches() {
         this.sheetRecordsCache = null;
         this.visibilityCache = null;
@@ -2278,11 +2881,12 @@ export class WorkPaper {
         this.pendingBatchPotentialNewCells = 0;
         this.engine.applyCellMutationsAtWithOptions(ops, {
             captureUndo: true,
-            potentialNewCells: potentialNewCells > 0 ? potentialNewCells : undefined,
+            potentialNewCells,
             source: 'local',
             returnUndoOps: false,
             reuseRefs: true,
         });
+        this.updateSheetDimensionsAfterCellMutationRefs(ops);
     }
     applyCellMutationRefs(refs, options) {
         if (this.evaluationSuspended && (options.source ?? 'local') === 'local') {
@@ -2294,6 +2898,7 @@ export class WorkPaper {
                 const mutation = ref.mutation;
                 this.suspendedCellMutationRefs.push({
                     sheetId: ref.sheetId,
+                    ...(ref.cellIndex !== undefined ? { cellIndex: ref.cellIndex } : {}),
                     mutation: mutation.kind === 'setCellValue'
                         ? {
                             kind: 'setCellValue',
@@ -2315,11 +2920,13 @@ export class WorkPaper {
                             },
                 });
             }
-            this.suspendedCellMutationPotentialNewCells +=
-                options.potentialNewCells ?? refs.reduce((count, ref) => (ref?.mutation.kind === 'clearCell' ? count : count + 1), 0);
+            this.suspendedCellMutationPotentialNewCells += options.potentialNewCells ?? countPotentialNewTrackedCellMutations(refs);
             return;
         }
         this.engine.applyCellMutationsAtWithOptions(refs, options);
+        if (!canSkipDimensionUpdateAfterLiteralMutation(refs, options.potentialNewCells)) {
+            this.updateSheetDimensionsAfterCellMutationRefs(refs);
+        }
     }
     flushSuspendedCellMutations() {
         if (this.suspendedCellMutationRefs.length === 0) {
@@ -2331,42 +2938,53 @@ export class WorkPaper {
         this.suspendedCellMutationPotentialNewCells = 0;
         this.engine.applyCellMutationsAtWithOptions(refs, {
             captureUndo: true,
-            potentialNewCells: potentialNewCells > 0 ? potentialNewCells : undefined,
+            potentialNewCells,
             source: 'local',
             returnUndoOps: false,
             reuseRefs: true,
         });
+        this.updateSheetDimensionsAfterCellMutationRefs(refs);
     }
-    enqueueSuspendedLiteralMutation(sheetId, row, col, content, existingCellIndex = this.engine.workbook.getSheetById(sheetId)?.grid.get(row, col) ?? -1) {
+    enqueueSuspendedLiteralMutation(sheetId, row, col, content, cellIndex) {
         if (!this.evaluationSuspended || !isDeferredBatchLiteralContent(content) || isFormulaContent(content)) {
             return false;
         }
         if (content === null) {
-            this.suspendedCellMutationRefs.push({ sheetId, mutation: { kind: 'clearCell', row, col } });
+            this.suspendedCellMutationRefs.push({
+                sheetId,
+                mutation: { kind: 'clearCell', row, col },
+                ...(cellIndex !== undefined ? { cellIndex } : {}),
+            });
             return true;
         }
         this.suspendedCellMutationRefs.push({
             sheetId,
             mutation: { kind: 'setCellValue', row, col, value: content },
+            ...(cellIndex !== undefined ? { cellIndex } : {}),
         });
-        if (existingCellIndex === -1) {
+        if (cellIndex === undefined) {
             this.suspendedCellMutationPotentialNewCells += 1;
         }
         return true;
     }
-    enqueueDeferredBatchLiteral(sheetId, row, col, content, existingCellIndex = this.engine.workbook.getSheetById(sheetId)?.grid.get(row, col) ?? -1) {
+    enqueueDeferredBatchLiteral(sheetId, row, col, content, cellIndex) {
         if (this.batchDepth === 0 || this.evaluationSuspended || !isDeferredBatchLiteralContent(content) || isFormulaContent(content)) {
             return false;
         }
         if (content === null) {
-            this.pendingBatchOps.push({ sheetId, mutation: { kind: 'clearCell', row, col } });
+            this.pendingBatchOps.push({
+                sheetId,
+                mutation: { kind: 'clearCell', row, col },
+                ...(cellIndex !== undefined ? { cellIndex } : {}),
+            });
             return true;
         }
         this.pendingBatchOps.push({
             sheetId,
             mutation: { kind: 'setCellValue', row, col, value: content },
+            ...(cellIndex !== undefined ? { cellIndex } : {}),
         });
-        if (existingCellIndex === -1) {
+        if (cellIndex === undefined) {
             this.pendingBatchPotentialNewCells += 1;
         }
         return true;
@@ -2406,6 +3024,28 @@ export class WorkPaper {
     a1(address) {
         return formatAddress(address.row, address.col);
     }
+    trackedA1(row, col) {
+        if (row >= 0 && row < RUNTIME_A1_CACHE_ROW_LIMIT && col >= 0 && col < RUNTIME_A1_CACHE_COLUMN_LIMIT) {
+            const cacheKey = row * RUNTIME_A1_CACHE_COLUMN_LIMIT + col;
+            let cached = RUNTIME_A1_CACHE[cacheKey];
+            if (cached === undefined) {
+                let column = RUNTIME_COLUMN_LABEL_CACHE[col];
+                if (column === undefined) {
+                    column = indexToColumn(col);
+                    RUNTIME_COLUMN_LABEL_CACHE[col] = column;
+                }
+                cached = `${column}${row + 1}`;
+                RUNTIME_A1_CACHE[cacheKey] = cached;
+            }
+            return cached;
+        }
+        let column = RUNTIME_COLUMN_LABEL_CACHE[col];
+        if (column === undefined) {
+            column = indexToColumn(col);
+            RUNTIME_COLUMN_LABEL_CACHE[col] = column;
+        }
+        return `${column}${row + 1}`;
+    }
     rangeRef(range) {
         assertRange(range);
         return sourceRangeRef(this.sheetName(range.start.sheet), range);
@@ -2500,44 +3140,264 @@ export class WorkPaper {
         });
         return orderWorkPaperCellChanges(cellChanges, this.listSheetRecords());
     }
-    readTrackedCellChange(cellIndex) {
-        const sheetId = this.engine.workbook.cellStore.sheetIds[cellIndex];
-        const row = this.engine.workbook.cellStore.rows[cellIndex];
-        const col = this.engine.workbook.cellStore.cols[cellIndex];
-        if (sheetId === undefined || row === undefined || col === undefined) {
-            return undefined;
+    materializeTrackedEventChanges(event, lazy = false) {
+        if (event.patches && event.patches.length > 0) {
+            const cellPatches = event.patches.filter((patch) => patch.kind === 'cell');
+            return { changes: cellPatches, canReusePublicChanges: false, ordered: false };
+        }
+        const trustedPhysicalMetadata = lazy && event.changedCellIndices instanceof Uint32Array
+            ? readTrustedPhysicalTrackedChangeMetadata(event.changedCellIndices)
+            : undefined;
+        const materialized = materializeTrackedIndexChangesWithMetadata(this.engine, event.changedCellIndices, {
+            explicitChangedCount: event.explicitChangedCount,
+            lazy,
+            ...trustedPhysicalMetadata,
+        });
+        if (lazy) {
+            this.trackLazyTrackedChanges(materialized.changes);
         }
-        const sheetName = this.engine.workbook.getSheetNameById(sheetId);
-        if (sheetName === undefined) {
+        return {
+            changes: materialized.changes,
+            canReusePublicChanges: true,
+            ordered: materialized.ordered,
+        };
+    }
+    readSingleTrackedCellChange(cellIndex) {
+        const cellStore = this.engine.workbook.cellStore;
+        const sheetId = cellStore.sheetIds[cellIndex];
+        if (sheetId === undefined) {
             return undefined;
         }
+        const sheet = this.engine.workbook.getSheetById(sheetId);
+        const sheetName = sheet?.name ?? this.engine.workbook.getSheetNameById(sheetId);
+        let row;
+        let col;
+        if (!sheet || sheet.structureVersion === 1) {
+            row = cellStore.rows[cellIndex];
+            col = cellStore.cols[cellIndex];
+        }
+        else {
+            const position = this.engine.workbook.getCellPosition(cellIndex);
+            if (!position) {
+                return undefined;
+            }
+            row = position.row;
+            col = position.col;
+        }
+        const tag = cellStore.tags[cellIndex] ?? ValueTag.Empty;
+        let newValue;
+        switch (tag) {
+            case ValueTag.Number:
+                newValue = { tag: ValueTag.Number, value: cellStore.numbers[cellIndex] ?? 0 };
+                break;
+            case ValueTag.Boolean:
+                newValue = { tag: ValueTag.Boolean, value: (cellStore.numbers[cellIndex] ?? 0) !== 0 };
+                break;
+            case ValueTag.String:
+                newValue = cellStore.getValue(cellIndex, (stringId) => this.engine.strings.get(stringId));
+                break;
+            case ValueTag.Error:
+                newValue = { tag: ValueTag.Error, code: cellStore.errors[cellIndex] };
+                break;
+            case ValueTag.Empty:
+            default:
+                newValue = { tag: ValueTag.Empty };
+                break;
+        }
         return {
             kind: 'cell',
             address: { sheet: sheetId, row, col },
             sheetName,
-            a1: formatAddress(row, col),
-            newValue: this.engine.workbook.cellStore.getValue(cellIndex, (id) => this.engine.strings.get(id)),
+            a1: this.trackedA1(row, col),
+            newValue,
         };
     }
-    materializeTrackedEventChanges(event) {
-        if (event.patches && event.patches.length > 0) {
-            const cellPatches = event.patches.filter((patch) => patch.kind === 'cell');
-            return cellPatches;
+    readTinySortedPhysicalTrackedEventChanges(event) {
+        if (!event.changedCellIndicesSortedDisjoint) {
+            return null;
+        }
+        const cellStore = this.engine.workbook.cellStore;
+        const firstCellIndex = event.changedCellIndices[0];
+        if (firstCellIndex === undefined) {
+            return [];
+        }
+        const sheetId = cellStore.sheetIds[firstCellIndex];
+        if (sheetId === undefined) {
+            return [];
+        }
+        const sheet = this.engine.workbook.getSheetById(sheetId);
+        if (sheet && sheet.structureVersion !== 1) {
+            return null;
+        }
+        const sheetName = sheet?.name ?? this.engine.workbook.getSheetNameById(sheetId);
+        if (event.changedCellIndices.length === 1) {
+            const row = cellStore.rows[firstCellIndex];
+            const col = cellStore.cols[firstCellIndex];
+            return [
+                {
+                    kind: 'cell',
+                    address: { sheet: sheetId, row, col },
+                    sheetName,
+                    a1: this.trackedA1(row, col),
+                    newValue: readTrackedRuntimeCellValue(cellStore, firstCellIndex, this.engine.strings),
+                },
+            ];
+        }
+        if (event.changedCellIndices.length === 2) {
+            const secondCellIndex = event.changedCellIndices[1];
+            if (cellStore.sheetIds[secondCellIndex] !== sheetId) {
+                return null;
+            }
+            const firstRow = cellStore.rows[firstCellIndex];
+            const firstCol = cellStore.cols[firstCellIndex];
+            const secondRow = cellStore.rows[secondCellIndex];
+            const secondCol = cellStore.cols[secondCellIndex];
+            if (secondRow < firstRow || (secondRow === firstRow && secondCol < firstCol)) {
+                return null;
+            }
+            return [
+                {
+                    kind: 'cell',
+                    address: { sheet: sheetId, row: firstRow, col: firstCol },
+                    sheetName,
+                    a1: this.trackedA1(firstRow, firstCol),
+                    newValue: readTrackedRuntimeCellValue(cellStore, firstCellIndex, this.engine.strings),
+                },
+                {
+                    kind: 'cell',
+                    address: { sheet: sheetId, row: secondRow, col: secondCol },
+                    sheetName,
+                    a1: this.trackedA1(secondRow, secondCol),
+                    newValue: readTrackedRuntimeCellValue(cellStore, secondCellIndex, this.engine.strings),
+                },
+            ];
         }
         const changes = [];
+        let previousRow = -1;
+        let previousCol = -1;
         for (let index = 0; index < event.changedCellIndices.length; index += 1) {
-            const change = this.readTrackedCellChange(event.changedCellIndices[index]);
-            if (change) {
-                changes.push(change);
+            const cellIndex = event.changedCellIndices[index];
+            if (cellStore.sheetIds[cellIndex] !== sheetId) {
+                return null;
+            }
+            const row = cellStore.rows[cellIndex];
+            const col = cellStore.cols[cellIndex];
+            if (row < previousRow || (row === previousRow && col < previousCol)) {
+                return null;
             }
+            changes.push({
+                kind: 'cell',
+                address: { sheet: sheetId, row, col },
+                sheetName,
+                a1: this.trackedA1(row, col),
+                newValue: readTrackedRuntimeCellValue(cellStore, cellIndex, this.engine.strings),
+            });
+            previousRow = row;
+            previousCol = col;
         }
         return changes;
     }
-    computeCellChangesFromTrackedEvents(beforeVisibility, events) {
+    tryReadTinyTrackedEventChangesWithoutVisibility(event) {
+        if (event.patches !== undefined &&
+            event.invalidation !== 'full' &&
+            event.patches.length <= TINY_TRACKED_CHANGE_LIMIT &&
+            !event.hasInvalidatedRanges &&
+            !event.hasInvalidatedRows &&
+            !event.hasInvalidatedColumns) {
+            const changes = [];
+            let alreadySorted = true;
+            let previousSheetId = -1;
+            let previousSheetOrder = -1;
+            let previousRow = -1;
+            let previousCol = -1;
+            for (let index = 0; index < event.patches.length; index += 1) {
+                const patch = event.patches[index];
+                if (!patch || patch.kind !== 'cell') {
+                    return null;
+                }
+                const sheetOrder = patch.address.sheet === previousSheetId ? previousSheetOrder : this.sheetRecord(patch.address.sheet).order;
+                if (sheetOrder < previousSheetOrder ||
+                    (sheetOrder === previousSheetOrder &&
+                        (patch.address.row < previousRow || (patch.address.row === previousRow && patch.address.col < previousCol)))) {
+                    alreadySorted = false;
+                }
+                changes.push({
+                    kind: 'cell',
+                    address: patch.address,
+                    sheetName: patch.sheetName,
+                    a1: patch.a1,
+                    newValue: patch.newValue,
+                });
+                previousSheetId = patch.address.sheet;
+                previousSheetOrder = sheetOrder;
+                previousRow = patch.address.row;
+                previousCol = patch.address.col;
+            }
+            return alreadySorted ? changes : orderWorkPaperCellChanges(changes, this.listSheetRecords(), event.explicitChangedCount);
+        }
+        if (event.invalidation === 'full' ||
+            event.patches !== undefined ||
+            event.changedCellIndices.length > TINY_TRACKED_CHANGE_LIMIT ||
+            event.hasInvalidatedRanges ||
+            event.hasInvalidatedRows ||
+            event.hasInvalidatedColumns) {
+            return null;
+        }
+        if (event.changedCellIndices.length === 0) {
+            return [];
+        }
+        const sortedPhysicalChanges = this.readTinySortedPhysicalTrackedEventChanges(event);
+        if (sortedPhysicalChanges) {
+            return sortedPhysicalChanges;
+        }
+        const changes = [];
+        const cellKeys = [];
+        let alreadySorted = true;
+        let previousSheetId = -1;
+        let previousSheetOrder = -1;
+        let previousRow = -1;
+        let previousCol = -1;
+        for (let index = 0; index < event.changedCellIndices.length; index += 1) {
+            const change = this.readSingleTrackedCellChange(event.changedCellIndices[index]);
+            if (!change) {
+                continue;
+            }
+            const cellKey = makeCellKey(change.address.sheet, change.address.row, change.address.col);
+            for (let priorIndex = 0; priorIndex < cellKeys.length; priorIndex += 1) {
+                if (cellKeys[priorIndex] === cellKey) {
+                    return null;
+                }
+            }
+            cellKeys.push(cellKey);
+            const sheetOrder = change.address.sheet === previousSheetId ? previousSheetOrder : this.sheetRecord(change.address.sheet).order;
+            if (sheetOrder < previousSheetOrder ||
+                (sheetOrder === previousSheetOrder &&
+                    (change.address.row < previousRow || (change.address.row === previousRow && change.address.col < previousCol)))) {
+                alreadySorted = false;
+            }
+            changes.push(change);
+            previousSheetId = change.address.sheet;
+            previousSheetOrder = sheetOrder;
+            previousRow = change.address.row;
+            previousCol = change.address.col;
+        }
+        return alreadySorted ? changes : orderWorkPaperCellChanges(changes, this.listSheetRecords(), event.explicitChangedCount);
+    }
+    computeCellChangesFromTrackedEvents(beforeVisibility, events, updateVisibility = true, options = {}) {
         if (events.some((event) => event.invalidation === 'full')) {
             return null;
         }
         const nextVisibility = beforeVisibility;
+        const sheetOrders = new Map();
+        const sheetOrderFor = (sheetId) => {
+            const existing = sheetOrders.get(sheetId);
+            if (existing !== undefined) {
+                return existing;
+            }
+            const order = this.sheetRecord(sheetId).order;
+            sheetOrders.set(sheetId, order);
+            return order;
+        };
         const ensureMutableSheet = (sheetId, sheetName) => {
             const existing = nextVisibility.get(sheetId);
             if (existing) {
@@ -2552,17 +3412,95 @@ export class WorkPaper {
             nextVisibility.set(sheetId, created);
             return created;
         };
+        const tryReadSmallTrackedEventChanges = (event) => {
+            if (event.invalidation === 'full' ||
+                event.patches !== undefined ||
+                event.changedCellIndices.length > 4 ||
+                event.hasInvalidatedRanges ||
+                event.hasInvalidatedRows ||
+                event.hasInvalidatedColumns) {
+                return null;
+            }
+            if (event.changedCellIndices.length === 0) {
+                return [];
+            }
+            const changes = [];
+            const cellKeys = [];
+            let alreadySorted = true;
+            let previousSheetOrder = -1;
+            let previousRow = -1;
+            let previousCol = -1;
+            for (let index = 0; index < event.changedCellIndices.length; index += 1) {
+                const change = this.readSingleTrackedCellChange(event.changedCellIndices[index]);
+                if (!change) {
+                    continue;
+                }
+                const cellKey = makeCellKey(change.address.sheet, change.address.row, change.address.col);
+                for (let priorIndex = 0; priorIndex < cellKeys.length; priorIndex += 1) {
+                    if (cellKeys[priorIndex] === cellKey) {
+                        return null;
+                    }
+                }
+                cellKeys.push(cellKey);
+                const sheet = updateVisibility ? ensureMutableSheet(change.address.sheet, change.sheetName) : undefined;
+                const sheetOrder = sheet?.order ?? sheetOrderFor(change.address.sheet);
+                if (sheetOrder < previousSheetOrder ||
+                    (sheetOrder === previousSheetOrder &&
+                        (change.address.row < previousRow || (change.address.row === previousRow && change.address.col < previousCol)))) {
+                    alreadySorted = false;
+                }
+                if (sheet) {
+                    if (change.newValue.tag === ValueTag.Empty) {
+                        sheet.cells.delete(cellKey);
+                    }
+                    else {
+                        sheet.cells.set(cellKey, change.newValue);
+                    }
+                }
+                changes.push(change);
+                previousSheetOrder = sheetOrder;
+                previousRow = change.address.row;
+                previousCol = change.address.col;
+            }
+            return alreadySorted ? changes : orderWorkPaperCellChanges(changes, this.listSheetRecords(), event.explicitChangedCount);
+        };
         if (events.length === 1) {
             const event = events[0];
-            const eventChanges = this.materializeTrackedEventChanges(event);
+            if (!options.preferLazyPublicChanges) {
+                const smallChanges = tryReadSmallTrackedEventChanges(event);
+                if (smallChanges) {
+                    return { changes: smallChanges, nextVisibility };
+                }
+            }
+            const materializedEventChanges = this.materializeTrackedEventChanges(event, !updateVisibility);
+            const eventChanges = materializedEventChanges.changes;
+            if (!updateVisibility && materializedEventChanges.canReusePublicChanges && materializedEventChanges.ordered) {
+                return {
+                    changes: eventChanges,
+                    nextVisibility,
+                };
+            }
+            const directChanges = [];
+            const seenCellKeys = eventChanges.length > 4 && eventChanges.length <= 64 ? new Set() : undefined;
+            const smallCellKeys = eventChanges.length > 1 && eventChanges.length <= 4 ? [] : undefined;
             let hasDuplicateCellKey = false;
-            if (eventChanges.length <= 4) {
-                for (let index = 0; index < eventChanges.length; index += 1) {
-                    const change = eventChanges[index];
-                    const cellKey = makeCellKey(change.address.sheet, change.address.row, change.address.col);
+            let alreadySorted = true;
+            let previousSheetOrder = -1;
+            let previousRow = -1;
+            let previousCol = -1;
+            for (let index = 0; index < eventChanges.length; index += 1) {
+                const change = eventChanges[index];
+                const cellKey = makeCellKey(change.address.sheet, change.address.row, change.address.col);
+                if (seenCellKeys) {
+                    if (seenCellKeys.has(cellKey)) {
+                        hasDuplicateCellKey = true;
+                        break;
+                    }
+                    seenCellKeys.add(cellKey);
+                }
+                else if (smallCellKeys) {
                     for (let priorIndex = 0; priorIndex < index; priorIndex += 1) {
-                        const prior = eventChanges[priorIndex];
-                        if (makeCellKey(prior.address.sheet, prior.address.row, prior.address.col) === cellKey) {
+                        if (smallCellKeys[priorIndex] === cellKey) {
                             hasDuplicateCellKey = true;
                             break;
                         }
@@ -2570,52 +3508,37 @@ export class WorkPaper {
                     if (hasDuplicateCellKey) {
                         break;
                     }
+                    smallCellKeys[index] = cellKey;
                 }
-            }
-            else {
-                const seenCellKeys = new Set();
-                for (let index = 0; index < eventChanges.length; index += 1) {
-                    const change = eventChanges[index];
-                    const cellKey = makeCellKey(change.address.sheet, change.address.row, change.address.col);
-                    if (seenCellKeys.has(cellKey)) {
-                        hasDuplicateCellKey = true;
-                        break;
-                    }
-                    seenCellKeys.add(cellKey);
+                const sheet = updateVisibility ? ensureMutableSheet(change.address.sheet, change.sheetName) : undefined;
+                const sheetOrder = sheet?.order ?? sheetOrderFor(change.address.sheet);
+                if (sheetOrder < previousSheetOrder ||
+                    (sheetOrder === previousSheetOrder &&
+                        (change.address.row < previousRow || (change.address.row === previousRow && change.address.col < previousCol)))) {
+                    alreadySorted = false;
                 }
-            }
-            if (!hasDuplicateCellKey) {
-                const directChanges = [];
-                let alreadySorted = true;
-                let previousSheetOrder = -1;
-                let previousRow = -1;
-                let previousCol = -1;
-                for (let index = 0; index < eventChanges.length; index += 1) {
-                    const change = eventChanges[index];
-                    const cellKey = makeCellKey(change.address.sheet, change.address.row, change.address.col);
-                    const sheet = ensureMutableSheet(change.address.sheet, change.sheetName);
-                    if (sheet.order < previousSheetOrder ||
-                        (sheet.order === previousSheetOrder &&
-                            (change.address.row < previousRow || (change.address.row === previousRow && change.address.col < previousCol)))) {
-                        alreadySorted = false;
-                    }
+                if (sheet) {
                     if (change.newValue.tag === ValueTag.Empty) {
                         sheet.cells.delete(cellKey);
                     }
                     else {
                         sheet.cells.set(cellKey, change.newValue);
                     }
-                    directChanges[index] = {
+                }
+                directChanges[index] = materializedEventChanges.canReusePublicChanges
+                    ? change
+                    : {
                         kind: 'cell',
                         address: change.address,
                         sheetName: change.sheetName,
                         a1: change.a1,
                         newValue: change.newValue,
                     };
-                    previousSheetOrder = sheet.order;
-                    previousRow = change.address.row;
-                    previousCol = change.address.col;
-                }
+                previousSheetOrder = sheetOrder;
+                previousRow = change.address.row;
+                previousCol = change.address.col;
+            }
+            if (!hasDuplicateCellKey) {
                 return {
                     changes: alreadySorted
                         ? directChanges
@@ -2624,9 +3547,36 @@ export class WorkPaper {
                 };
             }
         }
+        const materializedSources = updateVisibility
+            ? null
+            : materializeTrackedIndexChangeSourcesWithMetadata(this.engine, events, {
+                deferLazyDetach: true,
+                lazy: options.preferLazyPublicChanges,
+            });
+        if (materializedSources) {
+            this.trackLazyTrackedChanges(materializedSources.changes);
+            if (updateVisibility) {
+                for (const change of materializedSources.changes) {
+                    const cellKey = makeCellKey(change.address.sheet, change.address.row, change.address.col);
+                    const sheet = ensureMutableSheet(change.address.sheet, change.sheetName);
+                    if (change.newValue.tag === ValueTag.Empty) {
+                        sheet.cells.delete(cellKey);
+                    }
+                    else {
+                        sheet.cells.set(cellKey, change.newValue);
+                    }
+                }
+            }
+            return {
+                changes: materializedSources.ordered
+                    ? materializedSources.changes
+                    : orderWorkPaperCellChanges(materializedSources.changes, this.listSheetRecords()),
+                nextVisibility,
+            };
+        }
         const latestChangesByKey = new Map();
         for (const event of events) {
-            const eventChanges = this.materializeTrackedEventChanges(event);
+            const eventChanges = this.materializeTrackedEventChanges(event).changes;
             for (let index = 0; index < eventChanges.length; index += 1) {
                 const change = eventChanges[index];
                 const cellKey = makeCellKey(change.address.sheet, change.address.row, change.address.col);
@@ -2640,14 +3590,16 @@ export class WorkPaper {
                 });
             }
         }
-        for (const change of latestChangesByKey.values()) {
-            const cellKey = makeCellKey(change.address.sheet, change.address.row, change.address.col);
-            const sheet = ensureMutableSheet(change.address.sheet, change.sheetName);
-            if (change.newValue.tag === ValueTag.Empty) {
-                sheet.cells.delete(cellKey);
-            }
-            else {
-                sheet.cells.set(cellKey, change.newValue);
+        if (updateVisibility) {
+            for (const change of latestChangesByKey.values()) {
+                const cellKey = makeCellKey(change.address.sheet, change.address.row, change.address.col);
+                const sheet = ensureMutableSheet(change.address.sheet, change.sheetName);
+                if (change.newValue.tag === ValueTag.Empty) {
+                    sheet.cells.delete(cellKey);
+                }
+                else {
+                    sheet.cells.set(cellKey, change.newValue);
+                }
             }
         }
         const directChanges = [...latestChangesByKey.values()];
@@ -2690,16 +3642,31 @@ export class WorkPaper {
         this.batchStartNamedValues = this.namedExpressions.size > 0 ? this.ensureNamedExpressionValueCache() : EMPTY_NAMED_EXPRESSION_VALUES;
         this.batchUsesTrackedFastPath = false;
     }
-    computeTrackedChangesWithoutVisibilityCache(events) {
-        const fastPath = this.computeCellChangesFromTrackedEvents(new Map(), events);
+    computeTrackedChangesWithoutVisibilityCache(events, options = {}) {
+        if (events.length === 1) {
+            const event = events[0];
+            if (!options.preferLazyPublicChanges || event.changedCellIndices.length <= TINY_TRACKED_CHANGE_LIMIT) {
+                const tinyChanges = this.tryReadTinyTrackedEventChangesWithoutVisibility(event);
+                if (tinyChanges) {
+                    return tinyChanges;
+                }
+            }
+        }
+        const fastPath = this.computeCellChangesFromTrackedEvents(new Map(), events, false, options);
         if (!fastPath) {
             throw new WorkPaperOperationError('Mutation emitted an unsupported invalidation pattern for tracked changes');
         }
         return fastPath.changes;
     }
-    captureTrackedChangesWithoutVisibilityCache(mutate) {
+    captureTrackedChangesWithoutVisibilityCache(mutate, options = {}) {
         this.assertNotDisposed();
-        this.drainTrackedEngineEvents();
+        if (this.pendingLazyTrackedChanges.length > 0) {
+            this.materializePendingLazyTrackedChanges({ preservePositions: options.preservePendingTrackedPositions });
+        }
+        if (this.trackedEngineEvents.length > 0) {
+            this.drainTrackedEngineEvents();
+        }
+        this.retainedTrackedEngineEventIndicesDepth += 1;
         try {
             mutate();
         }
@@ -2709,13 +3676,159 @@ export class WorkPaper {
             }
             throw new WorkPaperOperationError(this.messageOf(error, 'Mutation failed'));
         }
-        const changes = this.computeTrackedChangesWithoutVisibilityCache(this.drainTrackedEngineEvents());
-        if (changes.length > 0) {
+        finally {
+            this.retainedTrackedEngineEventIndicesDepth -= 1;
+        }
+        const events = this.drainTrackedEngineEvents();
+        const directSingleLiteralChanges = this.tryBuildDirectSingleLiteralTrackedChange(events, options.singleLiteralChange);
+        if (directSingleLiteralChanges) {
+            if (directSingleLiteralChanges.length > 0 && this.emitter.hasListeners('valuesUpdated')) {
+                this.emitter.emitDetailed({ eventName: 'valuesUpdated', payload: { changes: directSingleLiteralChanges } });
+            }
+            return directSingleLiteralChanges;
+        }
+        const shouldEmitValuesUpdated = this.emitter.hasListeners('valuesUpdated');
+        const changes = this.computeTrackedChangesWithoutVisibilityCache(events, {
+            preferLazyPublicChanges: !shouldEmitValuesUpdated,
+        });
+        if (changes.length > 0 && shouldEmitValuesUpdated) {
             this.emitter.emitDetailed({ eventName: 'valuesUpdated', payload: { changes } });
         }
         return changes;
     }
+    tryBuildDirectSingleLiteralTrackedChange(events, expected) {
+        if (expected === undefined || expected.cellIndex === undefined || events.length !== 1) {
+            return null;
+        }
+        const event = events[0];
+        if (event.invalidation === 'full' ||
+            event.patches !== undefined ||
+            event.changedCellIndices.length < 1 ||
+            event.changedCellIndices.length > 2 ||
+            event.changedCellIndices[0] !== expected.cellIndex ||
+            event.hasInvalidatedRanges ||
+            event.hasInvalidatedRows ||
+            event.hasInvalidatedColumns) {
+            return null;
+        }
+        const literalChange = {
+            kind: 'cell',
+            address: { sheet: expected.address.sheet, row: expected.address.row, col: expected.address.col },
+            sheetName: expected.sheetName,
+            a1: this.trackedA1(expected.address.row, expected.address.col),
+            newValue: scalarValueFromLiteral(expected.value),
+        };
+        if (event.changedCellIndices.length === 1) {
+            return [literalChange];
+        }
+        const formulaCellIndex = event.changedCellIndices[1];
+        const cellStore = this.engine.workbook.cellStore;
+        if (cellStore.sheetIds[formulaCellIndex] !== expected.address.sheet) {
+            return null;
+        }
+        if (!expected.isPhysicalSheet) {
+            return null;
+        }
+        const formulaRow = cellStore.rows[formulaCellIndex];
+        const formulaCol = cellStore.cols[formulaCellIndex];
+        if (formulaRow < expected.address.row || (formulaRow === expected.address.row && formulaCol < expected.address.col)) {
+            return null;
+        }
+        return [
+            literalChange,
+            {
+                kind: 'cell',
+                address: { sheet: expected.address.sheet, row: formulaRow, col: formulaCol },
+                sheetName: expected.sheetName,
+                a1: this.trackedA1(formulaRow, formulaCol),
+                newValue: readTrackedRuntimeCellValue(cellStore, formulaCellIndex, this.engine.strings),
+            },
+        ];
+    }
+    tryBuildDirectExistingNumericTrackedChanges(result, address, cellIndex, isPhysicalSheet, sheetName, value) {
+        const changedCellCount = result.changedCellIndices?.length ?? result.changedCellCount ?? 0;
+        const firstChangedCellIndex = result.changedCellIndices?.[0] ?? result.firstChangedCellIndex;
+        if (changedCellCount < 1 || firstChangedCellIndex !== cellIndex) {
+            return null;
+        }
+        const literalChange = {
+            kind: 'cell',
+            address: { sheet: address.sheet, row: address.row, col: address.col },
+            sheetName,
+            a1: this.trackedA1(address.row, address.col),
+            newValue: { tag: ValueTag.Number, value },
+        };
+        if (changedCellCount === 1) {
+            return [literalChange];
+        }
+        if (!isPhysicalSheet) {
+            return null;
+        }
+        if (changedCellCount > 2) {
+            const changedCellIndices = result.changedCellIndices;
+            if (changedCellIndices === undefined) {
+                return null;
+            }
+            const cellStore = this.engine.workbook.cellStore;
+            const changes = [];
+            changes.length = changedCellCount;
+            changes[0] = literalChange;
+            let alreadySorted = true;
+            let previousRow = address.row;
+            let previousCol = address.col;
+            for (let index = 1; index < changedCellCount; index += 1) {
+                const changedCellIndex = changedCellIndices[index];
+                if (cellStore.sheetIds[changedCellIndex] !== address.sheet) {
+                    return null;
+                }
+                const row = cellStore.rows[changedCellIndex];
+                const col = cellStore.cols[changedCellIndex];
+                if (row === undefined || col === undefined) {
+                    return null;
+                }
+                if (row < previousRow || (row === previousRow && col < previousCol)) {
+                    alreadySorted = false;
+                }
+                changes[index] = {
+                    kind: 'cell',
+                    address: { sheet: address.sheet, row, col },
+                    sheetName,
+                    a1: this.trackedA1(row, col),
+                    newValue: readTrackedRuntimeCellValue(cellStore, changedCellIndex, this.engine.strings),
+                };
+                previousRow = row;
+                previousCol = col;
+            }
+            return alreadySorted ? changes : orderWorkPaperCellChanges(changes, this.listSheetRecords(), result.explicitChangedCount);
+        }
+        const formulaCellIndex = result.changedCellIndices?.[1] ?? result.secondChangedCellIndex;
+        if (formulaCellIndex === undefined) {
+            return null;
+        }
+        const cellStore = this.engine.workbook.cellStore;
+        if (cellStore.sheetIds[formulaCellIndex] !== address.sheet) {
+            return null;
+        }
+        const formulaRow = result.secondChangedRow ?? cellStore.rows[formulaCellIndex];
+        const formulaCol = result.secondChangedCol ?? cellStore.cols[formulaCellIndex];
+        if (formulaRow < address.row || (formulaRow === address.row && formulaCol < address.col)) {
+            return null;
+        }
+        return [
+            literalChange,
+            {
+                kind: 'cell',
+                address: { sheet: address.sheet, row: formulaRow, col: formulaCol },
+                sheetName,
+                a1: this.trackedA1(formulaRow, formulaCol),
+                newValue: result.secondChangedNumericValue === undefined
+                    ? readTrackedRuntimeCellValue(cellStore, formulaCellIndex, this.engine.strings)
+                    : { tag: ValueTag.Number, value: result.secondChangedNumericValue },
+            },
+        ];
+    }
     batchStructuralChanges(batchOperations) {
+        this.materializePendingLazyTrackedChanges();
         if (!this.canUseTrackedStructuralFastPath()) {
             this.downgradeTrackedBatchFastPath();
             return this.batch(batchOperations);
@@ -2725,16 +3838,19 @@ export class WorkPaper {
         this.drainTrackedEngineEvents();
         this.batchDepth += 1;
         try {
-            batchOperations();
+            this.withRetainedTrackedEngineEventIndices(batchOperations);
         }
         finally {
             this.batchDepth -= 1;
             this.flushPendingBatchOps();
             this.mergeUndoHistory(undoStackStart);
         }
-        const changes = this.computeTrackedChangesWithoutVisibilityCache(this.drainTrackedEngineEvents());
+        const shouldEmitValuesUpdated = this.emitter.hasListeners('valuesUpdated');
+        const changes = this.computeTrackedChangesWithoutVisibilityCache(this.drainTrackedEngineEvents(), {
+            preferLazyPublicChanges: !shouldEmitValuesUpdated,
+        });
         this.flushQueuedEvents();
-        if (changes.length > 0) {
+        if (changes.length > 0 && shouldEmitValuesUpdated) {
             this.emitter.emitDetailed({ eventName: 'valuesUpdated', payload: { changes } });
         }
         return changes;
@@ -2756,8 +3872,9 @@ export class WorkPaper {
         this.namedExpressionValueCache = afterNames;
         return hasNamedExpressions ? [...cellChanges, ...this.computeNamedExpressionChanges(beforeNames, afterNames)] : cellChanges;
     }
-    captureChanges(semanticEvent, mutate) {
+    captureChanges(semanticEvent, mutate, options = {}) {
         this.assertNotDisposed();
+        this.materializePendingLazyTrackedChanges({ preservePositions: options.preservePendingTrackedPositions });
         this.downgradeTrackedBatchFastPath();
         if (semanticEvent !== undefined) {
             this.flushPendingBatchOps();
@@ -2810,7 +3927,7 @@ export class WorkPaper {
                 this.emitter.emitDetailed(event);
             }
         }
-        if (!this.shouldSuppressEvents() && changes.length > 0) {
+        if (!this.shouldSuppressEvents() && changes.length > 0 && this.emitter.hasListeners('valuesUpdated')) {
             this.emitter.emitDetailed({ eventName: 'valuesUpdated', payload: { changes } });
         }
         return changes;
@@ -2839,6 +3956,10 @@ export class WorkPaper {
         }
         return stack;
     }
+    historyTopIsCellMutations(stack) {
+        const kind = stack.at(-1)?.forward.kind;
+        return kind === 'cell-mutations' || kind === 'single-existing-numeric-cell-mutation';
+    }
     clearHistoryStacks() {
         this.getUndoStack().length = 0;
         this.getRedoStack().length = 0;
@@ -2849,6 +3970,19 @@ export class WorkPaper {
                 return record.ops;
             case 'single-op':
                 return [record.op];
+            case 'single-existing-numeric-cell-mutation': {
+                const sheetName = this.getSheetName(record.sheetId);
+                return sheetName
+                    ? [
+                        {
+                            kind: 'setCellValue',
+                            sheetName,
+                            address: formatAddress(record.row, record.col),
+                            value: record.value,
+                        },
+                    ]
+                    : [];
+            }
             case 'cell-mutations':
                 return record.refs.flatMap((ref) => {
                     const sheetName = this.getSheetName(ref.sheetId);
@@ -3024,6 +4158,7 @@ export class WorkPaper {
         });
     }
     replaceSheetContentInternal(sheetId, content, options) {
+        const dimensions = inspectSheetDimensionsWithinLimits(this.sheetName(sheetId), content, this.config);
         replaceWorkPaperSheetContent({
             sheetId,
             sheetName: this.sheetName(sheetId),
@@ -3037,9 +4172,10 @@ export class WorkPaper {
             getUndoStackLength: () => this.getUndoStack().length,
             mergeUndoHistory: (undoStackStart) => this.mergeUndoHistory(undoStackStart),
         });
+        this.cacheInitializedSheetDimensions(sheetId, dimensions);
     }
     applyRawContent(address, content) {
-        const existingCellIndex = this.engine.workbook.getSheetById(address.sheet)?.grid.get(address.row, address.col) ?? -1;
+        const cellIndex = this.getVisibleCellIndex(address.sheet, address.row, address.col);
         const mutation = content === null
             ? { kind: 'clearCell', row: address.row, col: address.col }
             : typeof content === 'string' && content.trim().startsWith('=')
@@ -3055,9 +4191,9 @@ export class WorkPaper {
                     col: address.col,
                     value: content,
                 };
-        this.applyCellMutationRefs([{ sheetId: address.sheet, mutation }], {
+        this.applyCellMutationRefs([{ sheetId: address.sheet, mutation, ...(cellIndex !== undefined ? { cellIndex } : {}) }], {
             captureUndo: true,
-            potentialNewCells: content === null || existingCellIndex !== -1 ? 0 : 1,
+            potentialNewCells: content === null || cellIndex !== undefined ? 0 : 1,
             source: 'local',
             returnUndoOps: false,
             reuseRefs: true,