@bilig/core 0.1.28 → 0.1.30

package/dist/engine/services/operation-service.js

@@ -1,11 +1,24 @@
 import { Effect } from "effect";
-import { ValueTag } from "@bilig/protocol";
+import { formatAddress } from "@bilig/formula";
 import { makeCellEntity } from "../../entity-ids.js";
 import { batchOpOrder, compareOpOrder, createBatch, markBatchApplied, } from "../../replica-state.js";
-import { emptyValue, literalToValue } from "../../engine-value-utils.js";
+import { emptyValue, writeLiteralToCellStore } from "../../engine-value-utils.js";
 import { spillDependencyKey, tableDependencyKey } from "../../engine-metadata-utils.js";
-import { normalizeDefinedName, pivotKey } from "../../workbook-store.js";
+import { makeCellKey, normalizeDefinedName, pivotKey, } from "../../workbook-store.js";
 import { EngineMutationError } from "../errors.js";
+const noopVersionStore = {
+    get() {
+        return undefined;
+    },
+    set() {
+        return;
+    },
+};
+const FAST_LITERAL_OVERWRITE_FLAGS = 2 /* CellFlags.HasFormula */ |
+    4 /* CellFlags.JsOnly */ |
+    8 /* CellFlags.InCycle */ |
+    64 /* CellFlags.SpillChild */ |
+    128 /* CellFlags.PivotOutput */;
 function mutationErrorMessage(message, cause) {
     return cause instanceof Error && cause.message.length > 0 ? cause.message : message;
 }
@@ -25,6 +38,30 @@ export function createEngineOperationService(args) {
     const emitBatch = (batch) => {
         args.state.batchListeners.forEach((listener) => listener(batch));
     };
+    const entityVersions = args.state.trackReplicaVersions
+        ? args.state.entityVersions
+        : noopVersionStore;
+    const sheetDeleteVersions = args.state.trackReplicaVersions
+        ? args.state.sheetDeleteVersions
+        : noopVersionStore;
+    const setEntityVersionForOp = (op, order) => {
+        if (!args.state.trackReplicaVersions) {
+            return;
+        }
+        entityVersions.set(entityKeyForOp(op), order);
+    };
+    const setCellEntityVersion = (sheetName, address, order) => {
+        if (!args.state.trackReplicaVersions) {
+            return;
+        }
+        entityVersions.set(`cell:${sheetName}!${address}`, order);
+    };
+    const setSheetDeleteVersion = (sheetName, order) => {
+        if (!args.state.trackReplicaVersions) {
+            return;
+        }
+        sheetDeleteVersions.set(sheetName, order);
+    };
     const pruneCellIfOrphaned = (cellIndex) => {
         if (args.collectFormulaDependents(makeCellEntity(cellIndex)).length > 0) {
             return;
@@ -98,6 +135,11 @@ export function createEngineOperationService(args) {
                 return assertNever(op);
         }
     };
+    const canFastPathLiteralOverwrite = (cellIndex) => {
+        const flags = args.state.workbook.cellStore.flags[cellIndex] ?? 0;
+        return ((flags & FAST_LITERAL_OVERWRITE_FLAGS) === 0 &&
+            args.state.formulas.get(cellIndex) === undefined);
+    };
     const sheetDeleteBarrierForOp = (op) => {
         switch (op.kind) {
             case "upsertWorkbook":
@@ -131,20 +173,19 @@ export function createEngineOperationService(args) {
             case "upsertSpillRange":
             case "deleteSpillRange":
             case "deletePivotTable":
-                return args.state.sheetDeleteVersions.get(op.sheetName);
+                return sheetDeleteVersions.get(op.sheetName);
             case "setStyleRange":
             case "setFormatRange":
-                return args.state.sheetDeleteVersions.get(op.range.sheetName);
+                return sheetDeleteVersions.get(op.range.sheetName);
             case "upsertCellNumberFormat":
             case "upsertCellStyle":
                 return undefined;
             case "upsertSheet":
-                return args.state.sheetDeleteVersions.get(op.name);
+                return sheetDeleteVersions.get(op.name);
             case "renameSheet":
-                return args.state.sheetDeleteVersions.get(op.oldName);
+                return sheetDeleteVersions.get(op.oldName);
             case "upsertPivotTable":
-                return (args.state.sheetDeleteVersions.get(op.sheetName) ??
-                    args.state.sheetDeleteVersions.get(op.source.sheetName));
+                return (sheetDeleteVersions.get(op.sheetName) ?? sheetDeleteVersions.get(op.source.sheetName));
             default:
                 return assertNever(op);
         }
@@ -154,7 +195,7 @@ export function createEngineOperationService(args) {
         if (sheetDeleteOrder && compareOpOrder(order, sheetDeleteOrder) <= 0) {
             return false;
         }
-        const existingOrder = args.state.entityVersions.get(entityKeyForOp(op));
+        const existingOrder = entityVersions.get(entityKeyForOp(op));
         if (existingOrder && compareOpOrder(order, existingOrder) <= 0) {
             return false;
         }
@@ -167,7 +208,7 @@ export function createEngineOperationService(args) {
         else {
             args.state.workbook.deleteSpill(op.sheetName, op.address);
         }
-        args.state.entityVersions.set(entityKeyForOp(op), order);
+        setEntityVersionForOp(op, order);
         return collectTrackedDependents(args.reverseState.reverseSpillEdges, [
             spillDependencyKey(op.sheetName, op.address),
         ]);
@@ -183,17 +224,17 @@ export function createEngineOperationService(args) {
             rows: op.rows,
             cols: op.cols,
         });
-        args.state.entityVersions.set(entityKeyForOp(op), order);
+        setEntityVersionForOp(op, order);
     };
     const applyPivotDeleteOp = (op, order) => {
         const pivot = args.state.workbook.getPivot(op.sheetName, op.address);
         if (!pivot) {
-            args.state.entityVersions.set(entityKeyForOp(op), order);
+            setEntityVersionForOp(op, order);
             return [];
         }
         const changedPivotOutputs = args.clearOwnedPivot(pivot);
         args.state.workbook.deletePivot(op.sheetName, op.address);
-        args.state.entityVersions.set(entityKeyForOp(op), order);
+        setEntityVersionForOp(op, order);
         return changedPivotOutputs;
     };
     const applyDerivedOpNow = (op) => {
@@ -216,6 +257,7 @@ export function createEngineOperationService(args) {
         }
     };
     const applyBatchNow = (batch, source, potentialNewCells) => {
+        const isRestore = source === "restore";
         args.beginMutationCollection();
         let changedInputCount = 0;
         let formulaChangedCount = 0;
@@ -223,6 +265,7 @@ export function createEngineOperationService(args) {
         let topologyChanged = false;
         let sheetDeleted = false;
         let structuralInvalidation = false;
+        let compileMs = 0;
         const invalidatedRanges = [];
         const invalidatedRows = [];
         const invalidatedColumns = [];
@@ -242,24 +285,24 @@ export function createEngineOperationService(args) {
                 switch (op.kind) {
                     case "upsertWorkbook":
                         args.state.workbook.workbookName = op.name;
-                        args.state.entityVersions.set(entityKeyForOp(op), order);
+                        setEntityVersionForOp(op, order);
                         break;
                     case "setWorkbookMetadata":
                         args.state.workbook.setWorkbookProperty(op.key, op.value);
-                        args.state.entityVersions.set(entityKeyForOp(op), order);
+                        setEntityVersionForOp(op, order);
                         break;
                     case "setCalculationSettings":
                         args.state.workbook.setCalculationSettings(op.settings);
-                        args.state.entityVersions.set(entityKeyForOp(op), order);
+                        setEntityVersionForOp(op, order);
                         break;
                     case "setVolatileContext":
                         args.state.workbook.setVolatileContext(op.context);
-                        args.state.entityVersions.set(entityKeyForOp(op), order);
+                        setEntityVersionForOp(op, order);
                         break;
                     case "upsertSheet": {
                         args.state.workbook.createSheet(op.name, op.order, op.id);
-                        args.state.entityVersions.set(entityKeyForOp(op), order);
-                        const tombstone = args.state.sheetDeleteVersions.get(op.name);
+                        setEntityVersionForOp(op, order);
+                        const tombstone = sheetDeleteVersions.get(op.name);
                         if (!tombstone || compareOpOrder(order, tombstone) > 0) {
                             args.state.sheetDeleteVersions.delete(op.name);
                         }
@@ -271,10 +314,12 @@ export function createEngineOperationService(args) {
                     }
                     case "renameSheet": {
                         const renamedSheet = args.state.workbook.renameSheet(op.oldName, op.newName);
-                        args.state.entityVersions.set(`sheet:${op.oldName}`, order);
-                        args.state.entityVersions.set(`sheet:${op.newName}`, order);
-                        args.state.sheetDeleteVersions.set(op.oldName, order);
-                        const renamedTombstone = args.state.sheetDeleteVersions.get(op.newName);
+                        if (args.state.trackReplicaVersions) {
+                            entityVersions.set(`sheet:${op.oldName}`, order);
+                            entityVersions.set(`sheet:${op.newName}`, order);
+                        }
+                        setSheetDeleteVersion(op.oldName, order);
+                        const renamedTombstone = sheetDeleteVersions.get(op.newName);
                         if (!renamedTombstone || compareOpOrder(order, renamedTombstone) > 0) {
                             args.state.sheetDeleteVersions.delete(op.newName);
                         }
@@ -298,8 +343,8 @@ export function createEngineOperationService(args) {
                         changedInputCount += removal.changedInputCount;
                         formulaChangedCount += removal.formulaChangedCount;
                         explicitChangedCount = removal.explicitChangedCount;
-                        args.state.entityVersions.set(entityKeyForOp(op), order);
-                        args.state.sheetDeleteVersions.set(op.name, order);
+                        setEntityVersionForOp(op, order);
+                        setSheetDeleteVersion(op.name, order);
                         topologyChanged = true;
                         sheetDeleted = true;
                         structuralInvalidation = true;
@@ -322,7 +367,7 @@ export function createEngineOperationService(args) {
                         topologyChanged = true;
                         structuralInvalidation = true;
                         refreshAllPivots = true;
-                        args.state.entityVersions.set(entityKeyForOp(op), order);
+                        setEntityVersionForOp(op, order);
                         break;
                     }
                     case "updateRowMetadata":
@@ -332,7 +377,7 @@ export function createEngineOperationService(args) {
                             startIndex: op.start,
                             endIndex: op.start + op.count - 1,
                         });
-                        args.state.entityVersions.set(entityKeyForOp(op), order);
+                        setEntityVersionForOp(op, order);
                         break;
                     case "updateColumnMetadata":
                         args.state.workbook.setColumnMetadata(op.sheetName, op.start, op.count, op.size, op.hidden);
@@ -341,44 +386,44 @@ export function createEngineOperationService(args) {
                             startIndex: op.start,
                             endIndex: op.start + op.count - 1,
                         });
-                        args.state.entityVersions.set(entityKeyForOp(op), order);
+                        setEntityVersionForOp(op, order);
                         break;
                     case "setFreezePane":
                         args.state.workbook.setFreezePane(op.sheetName, op.rows, op.cols);
                         structuralInvalidation = true;
-                        args.state.entityVersions.set(entityKeyForOp(op), order);
+                        setEntityVersionForOp(op, order);
                         break;
                     case "clearFreezePane":
                         args.state.workbook.clearFreezePane(op.sheetName);
                         structuralInvalidation = true;
-                        args.state.entityVersions.set(entityKeyForOp(op), order);
+                        setEntityVersionForOp(op, order);
                         break;
                     case "setFilter":
                         args.state.workbook.setFilter(op.sheetName, op.range);
                         structuralInvalidation = true;
-                        args.state.entityVersions.set(entityKeyForOp(op), order);
+                        setEntityVersionForOp(op, order);
                         break;
                     case "clearFilter":
                         args.state.workbook.deleteFilter(op.sheetName, op.range);
                         structuralInvalidation = true;
-                        args.state.entityVersions.set(entityKeyForOp(op), order);
+                        setEntityVersionForOp(op, order);
                         break;
                     case "setSort":
                         args.state.workbook.setSort(op.sheetName, op.range, op.keys);
                         structuralInvalidation = true;
-                        args.state.entityVersions.set(entityKeyForOp(op), order);
+                        setEntityVersionForOp(op, order);
                         break;
                     case "clearSort":
                         args.state.workbook.deleteSort(op.sheetName, op.range);
                         structuralInvalidation = true;
-                        args.state.entityVersions.set(entityKeyForOp(op), order);
+                        setEntityVersionForOp(op, order);
                         break;
                     case "upsertTable": {
                         args.state.workbook.setTable(op.table);
                         const reboundCount = formulaChangedCount;
                         formulaChangedCount = args.rebindTableDependents([tableDependencyKey(op.table.name)], formulaChangedCount);
                         topologyChanged = topologyChanged || formulaChangedCount !== reboundCount;
-                        args.state.entityVersions.set(entityKeyForOp(op), order);
+                        setEntityVersionForOp(op, order);
                         break;
                     }
                     case "deleteTable": {
@@ -386,7 +431,7 @@ export function createEngineOperationService(args) {
                         const reboundCount = formulaChangedCount;
                         formulaChangedCount = args.rebindTableDependents([tableDependencyKey(op.name)], formulaChangedCount);
                         topologyChanged = topologyChanged || formulaChangedCount !== reboundCount;
-                        args.state.entityVersions.set(entityKeyForOp(op), order);
+                        setEntityVersionForOp(op, order);
                         break;
                     }
                     case "upsertSpillRange":
@@ -397,15 +442,18 @@ export function createEngineOperationService(args) {
                         break;
                     }
                     case "setCellValue": {
-                        const existingIndex = args.state.workbook.getCellIndex(op.sheetName, op.address);
-                        if (existingIndex !== undefined) {
-                            changedInputCount = args.markPivotRootsChanged(args.clearPivotForCell(existingIndex), changedInputCount);
+                        if (!isRestore) {
+                            const existingIndex = args.state.workbook.getCellIndex(op.sheetName, op.address);
+                            if (existingIndex !== undefined) {
+                                changedInputCount = args.markPivotRootsChanged(args.clearPivotForCell(existingIndex), changedInputCount);
+                            }
                         }
                         const cellIndex = args.ensureCellTracked(op.sheetName, op.address);
-                        changedInputCount = args.markSpillRootsChanged(args.clearOwnedSpill(cellIndex), changedInputCount);
-                        topologyChanged = args.removeFormula(cellIndex) || topologyChanged;
-                        const value = literalToValue(op.value, args.state.strings);
-                        args.state.workbook.cellStore.setValue(cellIndex, value, value.tag === ValueTag.String ? value.stringId : 0);
+                        if (!isRestore) {
+                            changedInputCount = args.markSpillRootsChanged(args.clearOwnedSpill(cellIndex), changedInputCount);
+                            topologyChanged = args.removeFormula(cellIndex) || topologyChanged;
+                        }
+                        writeLiteralToCellStore(args.state.workbook.cellStore, cellIndex, op.value, args.state.strings);
                         args.state.workbook.cellStore.flags[cellIndex] =
                             (args.state.workbook.cellStore.flags[cellIndex] ?? 0) &
                                 ~(2 /* CellFlags.HasFormula */ |
@@ -413,72 +461,82 @@ export function createEngineOperationService(args) {
                                     8 /* CellFlags.InCycle */ |
                                     64 /* CellFlags.SpillChild */ |
                                     128 /* CellFlags.PivotOutput */);
-                        pruneCellIfOrphaned(cellIndex);
+                        if (!isRestore) {
+                            pruneCellIfOrphaned(cellIndex);
+                        }
                         changedInputCount = args.markInputChanged(cellIndex, changedInputCount);
-                        explicitChangedCount = args.markExplicitChanged(cellIndex, explicitChangedCount);
-                        args.state.entityVersions.set(entityKeyForOp(op), order);
+                        if (!isRestore) {
+                            explicitChangedCount = args.markExplicitChanged(cellIndex, explicitChangedCount);
+                            setEntityVersionForOp(op, order);
+                        }
                         break;
                     }
                     case "setCellFormula": {
-                        const existingIndex = args.state.workbook.getCellIndex(op.sheetName, op.address);
-                        if (existingIndex !== undefined) {
-                            changedInputCount = args.markPivotRootsChanged(args.clearPivotForCell(existingIndex), changedInputCount);
+                        if (!isRestore) {
+                            const existingIndex = args.state.workbook.getCellIndex(op.sheetName, op.address);
+                            if (existingIndex !== undefined) {
+                                changedInputCount = args.markPivotRootsChanged(args.clearPivotForCell(existingIndex), changedInputCount);
+                            }
                         }
                         const cellIndex = args.ensureCellTracked(op.sheetName, op.address);
-                        changedInputCount = args.markSpillRootsChanged(args.clearOwnedSpill(cellIndex), changedInputCount);
-                        const compileStarted = performance.now();
+                        if (!isRestore) {
+                            changedInputCount = args.markSpillRootsChanged(args.clearOwnedSpill(cellIndex), changedInputCount);
+                        }
+                        const compileStarted = isRestore ? 0 : performance.now();
                         try {
                             args.bindFormula(cellIndex, op.sheetName, op.formula);
-                            args.state.setLastMetrics({
-                                ...args.state.getLastMetrics(),
-                                compileMs: performance.now() - compileStarted,
-                            });
+                            if (!isRestore) {
+                                compileMs += performance.now() - compileStarted;
+                            }
                             formulaChangedCount = args.markFormulaChanged(cellIndex, formulaChangedCount);
                             topologyChanged = true;
                         }
                         catch {
-                            args.state.setLastMetrics({
-                                ...args.state.getLastMetrics(),
-                                compileMs: performance.now() - compileStarted,
-                            });
+                            if (!isRestore) {
+                                compileMs += performance.now() - compileStarted;
+                            }
                             topologyChanged = args.removeFormula(cellIndex) || topologyChanged;
                             args.setInvalidFormulaValue(cellIndex);
                             changedInputCount = args.markInputChanged(cellIndex, changedInputCount);
                         }
-                        explicitChangedCount = args.markExplicitChanged(cellIndex, explicitChangedCount);
-                        args.state.entityVersions.set(entityKeyForOp(op), order);
+                        if (!isRestore) {
+                            explicitChangedCount = args.markExplicitChanged(cellIndex, explicitChangedCount);
+                            setEntityVersionForOp(op, order);
+                        }
                         break;
                     }
                     case "setCellFormat": {
                         const cellIndex = args.ensureCellTracked(op.sheetName, op.address);
                         args.state.workbook.setCellFormat(cellIndex, op.format);
-                        pruneCellIfOrphaned(cellIndex);
-                        explicitChangedCount = args.markExplicitChanged(cellIndex, explicitChangedCount);
-                        args.state.entityVersions.set(entityKeyForOp(op), order);
+                        if (!isRestore) {
+                            pruneCellIfOrphaned(cellIndex);
+                            explicitChangedCount = args.markExplicitChanged(cellIndex, explicitChangedCount);
+                            setEntityVersionForOp(op, order);
+                        }
                         break;
                     }
                     case "upsertCellStyle":
                         args.state.workbook.upsertCellStyle(op.style);
-                        args.state.entityVersions.set(entityKeyForOp(op), order);
+                        setEntityVersionForOp(op, order);
                         break;
                     case "upsertCellNumberFormat":
                         args.state.workbook.upsertCellNumberFormat(op.format);
-                        args.state.entityVersions.set(entityKeyForOp(op), order);
+                        setEntityVersionForOp(op, order);
                         break;
                     case "setStyleRange":
                         args.state.workbook.setStyleRange(op.range, op.styleId);
                         invalidatedRanges.push(op.range);
-                        args.state.entityVersions.set(entityKeyForOp(op), order);
+                        setEntityVersionForOp(op, order);
                         break;
                     case "setFormatRange":
                         args.state.workbook.setFormatRange(op.range, op.formatId);
                         invalidatedRanges.push(op.range);
-                        args.state.entityVersions.set(entityKeyForOp(op), order);
+                        setEntityVersionForOp(op, order);
                         break;
                     case "clearCell": {
                         const cellIndex = args.state.workbook.getCellIndex(op.sheetName, op.address);
                         if (cellIndex === undefined) {
-                            args.state.entityVersions.set(entityKeyForOp(op), order);
+                            setEntityVersionForOp(op, order);
                             break;
                         }
                         changedInputCount = args.markPivotRootsChanged(args.clearPivotForCell(cellIndex), changedInputCount);
@@ -495,7 +553,7 @@ export function createEngineOperationService(args) {
                         pruneCellIfOrphaned(cellIndex);
                         changedInputCount = args.markInputChanged(cellIndex, changedInputCount);
                         explicitChangedCount = args.markExplicitChanged(cellIndex, explicitChangedCount);
-                        args.state.entityVersions.set(entityKeyForOp(op), order);
+                        setEntityVersionForOp(op, order);
                         break;
                     }
                     case "upsertDefinedName": {
@@ -504,7 +562,7 @@ export function createEngineOperationService(args) {
                         const reboundCount = formulaChangedCount;
                         formulaChangedCount = args.rebindDefinedNameDependents([normalizedName], formulaChangedCount);
                         topologyChanged = topologyChanged || formulaChangedCount !== reboundCount;
-                        args.state.entityVersions.set(entityKeyForOp(op), order);
+                        setEntityVersionForOp(op, order);
                         break;
                     }
                     case "deleteDefinedName": {
@@ -513,7 +571,7 @@ export function createEngineOperationService(args) {
                         const reboundCount = formulaChangedCount;
                         formulaChangedCount = args.rebindDefinedNameDependents([normalizedName], formulaChangedCount);
                         topologyChanged = topologyChanged || formulaChangedCount !== reboundCount;
-                        args.state.entityVersions.set(entityKeyForOp(op), order);
+                        setEntityVersionForOp(op, order);
                         break;
                     }
                     case "upsertPivotTable":
@@ -557,21 +615,25 @@ export function createEngineOperationService(args) {
         const changedInputArray = args.getChangedInputBuffer().subarray(0, changedInputCount);
         let recalculated = args.recalculate(args.composeMutationRoots(changedInputCount, formulaChangedCount), changedInputArray);
         recalculated = args.reconcilePivotOutputs(recalculated, refreshAllPivots);
-        const changed = args.composeEventChanges(recalculated, explicitChangedCount);
+        const changed = isRestore
+            ? new Uint32Array()
+            : args.composeEventChanges(recalculated, explicitChangedCount);
         const lastMetrics = {
             ...args.state.getLastMetrics(),
             batchId: args.state.getLastMetrics().batchId + 1,
             changedInputCount: changedInputCount + formulaChangedCount,
+            compileMs,
         };
         args.state.setLastMetrics(lastMetrics);
         const event = {
             kind: "batch",
-            invalidation: sheetDeleted || structuralInvalidation ? "full" : "cells",
+            invalidation: isRestore || sheetDeleted || structuralInvalidation ? "full" : "cells",
             changedCellIndices: changed,
             invalidatedRanges,
             invalidatedRows,
             invalidatedColumns,
             metrics: lastMetrics,
+            explicitChangedCount,
         };
         if (event.invalidation === "full") {
             args.state.events.emitAllWatched(event);
@@ -587,6 +649,209 @@ export function createEngineOperationService(args) {
             args.state.redoStack.length = 0;
         }
     };
+    const applyCellMutationsAtNow = (refs, batch, source, potentialNewCells) => {
+        const isRestore = source === "restore";
+        args.beginMutationCollection();
+        let changedInputCount = 0;
+        let formulaChangedCount = 0;
+        let explicitChangedCount = 0;
+        let topologyChanged = false;
+        let compileMs = 0;
+        const reservedNewCells = potentialNewCells ?? refs.length;
+        args.state.workbook.cellStore.ensureCapacity(args.state.workbook.cellStore.size + reservedNewCells);
+        args.resetMaterializedCellScratch(reservedNewCells);
+        const sheetNameById = new Map();
+        const resolveSheetName = (sheetId) => {
+            const cached = sheetNameById.get(sheetId);
+            if (cached !== undefined) {
+                return cached;
+            }
+            const sheet = args.state.workbook.getSheetById(sheetId);
+            if (!sheet) {
+                throw new Error(`Unknown sheet id: ${sheetId}`);
+            }
+            sheetNameById.set(sheetId, sheet.name);
+            return sheet.name;
+        };
+        args.setBatchMutationDepth(args.getBatchMutationDepth() + 1);
+        try {
+            args.state.workbook.withBatchedColumnVersionUpdates(() => {
+                refs.forEach((ref, refIndex) => {
+                    const { sheetId, mutation } = ref;
+                    const order = args.state.trackReplicaVersions ? batchOpOrder(batch, refIndex) : undefined;
+                    const existingIndex = args.state.workbook.cellKeyToIndex.get(makeCellKey(sheetId, mutation.row, mutation.col));
+                    switch (mutation.kind) {
+                        case "setCellValue": {
+                            if (existingIndex !== undefined && canFastPathLiteralOverwrite(existingIndex)) {
+                                writeLiteralToCellStore(args.state.workbook.cellStore, existingIndex, mutation.value, args.state.strings);
+                                changedInputCount = args.markInputChanged(existingIndex, changedInputCount);
+                                if (!isRestore) {
+                                    explicitChangedCount = args.markExplicitChanged(existingIndex, explicitChangedCount);
+                                }
+                                if (!isRestore && args.state.trackReplicaVersions) {
+                                    setCellEntityVersion(resolveSheetName(sheetId), formatAddress(mutation.row, mutation.col), order);
+                                }
+                                break;
+                            }
+                            if (existingIndex !== undefined) {
+                                changedInputCount = args.markPivotRootsChanged(args.clearPivotForCell(existingIndex), changedInputCount);
+                            }
+                            const cellIndex = args.state.workbook.ensureCellAt(sheetId, mutation.row, mutation.col).cellIndex;
+                            if (!isRestore) {
+                                changedInputCount = args.markSpillRootsChanged(args.clearOwnedSpill(cellIndex), changedInputCount);
+                                topologyChanged = args.removeFormula(cellIndex) || topologyChanged;
+                            }
+                            writeLiteralToCellStore(args.state.workbook.cellStore, cellIndex, mutation.value, args.state.strings);
+                            args.state.workbook.cellStore.flags[cellIndex] =
+                                (args.state.workbook.cellStore.flags[cellIndex] ?? 0) &
+                                    ~(2 /* CellFlags.HasFormula */ |
+                                        4 /* CellFlags.JsOnly */ |
+                                        8 /* CellFlags.InCycle */ |
+                                        64 /* CellFlags.SpillChild */ |
+                                        128 /* CellFlags.PivotOutput */);
+                            if (!isRestore) {
+                                pruneCellIfOrphaned(cellIndex);
+                            }
+                            changedInputCount = args.markInputChanged(cellIndex, changedInputCount);
+                            if (!isRestore) {
+                                explicitChangedCount = args.markExplicitChanged(cellIndex, explicitChangedCount);
+                            }
+                            if (!isRestore && args.state.trackReplicaVersions) {
+                                setCellEntityVersion(resolveSheetName(sheetId), formatAddress(mutation.row, mutation.col), order);
+                            }
+                            break;
+                        }
+                        case "setCellFormula": {
+                            const sheetName = resolveSheetName(sheetId);
+                            if (!isRestore && existingIndex !== undefined) {
+                                changedInputCount = args.markPivotRootsChanged(args.clearPivotForCell(existingIndex), changedInputCount);
+                            }
+                            const cellIndex = args.state.workbook.ensureCellAt(sheetId, mutation.row, mutation.col).cellIndex;
+                            if (!isRestore) {
+                                changedInputCount = args.markSpillRootsChanged(args.clearOwnedSpill(cellIndex), changedInputCount);
+                            }
+                            const compileStarted = isRestore ? 0 : performance.now();
+                            try {
+                                args.bindFormula(cellIndex, sheetName, mutation.formula);
+                                if (!isRestore) {
+                                    compileMs += performance.now() - compileStarted;
+                                }
+                                formulaChangedCount = args.markFormulaChanged(cellIndex, formulaChangedCount);
+                                topologyChanged = true;
+                            }
+                            catch {
+                                if (!isRestore) {
+                                    compileMs += performance.now() - compileStarted;
+                                }
+                                topologyChanged = args.removeFormula(cellIndex) || topologyChanged;
+                                args.setInvalidFormulaValue(cellIndex);
+                                changedInputCount = args.markInputChanged(cellIndex, changedInputCount);
+                            }
+                            if (!isRestore) {
+                                explicitChangedCount = args.markExplicitChanged(cellIndex, explicitChangedCount);
+                            }
+                            if (!isRestore && args.state.trackReplicaVersions) {
+                                setCellEntityVersion(sheetName, formatAddress(mutation.row, mutation.col), order);
+                            }
+                            break;
+                        }
+                        case "clearCell": {
+                            if (existingIndex !== undefined && canFastPathLiteralOverwrite(existingIndex)) {
+                                args.state.workbook.cellStore.setValue(existingIndex, emptyValue());
+                                changedInputCount = args.markInputChanged(existingIndex, changedInputCount);
+                                if (!isRestore) {
+                                    explicitChangedCount = args.markExplicitChanged(existingIndex, explicitChangedCount);
+                                }
+                                if (!isRestore && args.state.trackReplicaVersions) {
+                                    setCellEntityVersion(resolveSheetName(sheetId), formatAddress(mutation.row, mutation.col), order);
+                                }
+                                break;
+                            }
+                            if (existingIndex === undefined) {
+                                if (!isRestore && args.state.trackReplicaVersions) {
+                                    setCellEntityVersion(resolveSheetName(sheetId), formatAddress(mutation.row, mutation.col), order);
+                                }
+                                break;
+                            }
+                            changedInputCount = args.markPivotRootsChanged(args.clearPivotForCell(existingIndex), changedInputCount);
+                            changedInputCount = args.markSpillRootsChanged(args.clearOwnedSpill(existingIndex), changedInputCount);
+                            topologyChanged = args.removeFormula(existingIndex) || topologyChanged;
+                            args.state.workbook.cellStore.setValue(existingIndex, emptyValue());
+                            args.state.workbook.cellStore.flags[existingIndex] =
+                                (args.state.workbook.cellStore.flags[existingIndex] ?? 0) &
+                                    ~(2 /* CellFlags.HasFormula */ |
+                                        4 /* CellFlags.JsOnly */ |
+                                        8 /* CellFlags.InCycle */ |
+                                        64 /* CellFlags.SpillChild */ |
+                                        128 /* CellFlags.PivotOutput */);
+                            if (!isRestore) {
+                                pruneCellIfOrphaned(existingIndex);
+                            }
+                            changedInputCount = args.markInputChanged(existingIndex, changedInputCount);
+                            if (!isRestore) {
+                                explicitChangedCount = args.markExplicitChanged(existingIndex, explicitChangedCount);
+                            }
+                            if (!isRestore && args.state.trackReplicaVersions) {
+                                setCellEntityVersion(resolveSheetName(sheetId), formatAddress(mutation.row, mutation.col), order);
+                            }
+                            break;
+                        }
+                        default:
+                            assertNever(mutation);
+                    }
+                });
+            });
+            const reboundCount = formulaChangedCount;
+            formulaChangedCount = args.syncDynamicRanges(formulaChangedCount);
+            topologyChanged = topologyChanged || formulaChangedCount !== reboundCount;
+        }
+        finally {
+            args.setBatchMutationDepth(args.getBatchMutationDepth() - 1);
+            args.flushWasmProgramSync();
+        }
+        markBatchApplied(args.state.replicaState, batch);
+        if (refs.length === 0) {
+            if (!isRestore) {
+                emitBatch(batch);
+            }
+            return;
+        }
+        if (topologyChanged) {
+            args.rebuildTopoRanks();
+            args.detectCycles();
+        }
+        formulaChangedCount = args.markVolatileFormulasChanged(formulaChangedCount);
+        const changedInputArray = args.getChangedInputBuffer().subarray(0, changedInputCount);
+        let recalculated = args.recalculate(args.composeMutationRoots(changedInputCount, formulaChangedCount), changedInputArray);
+        recalculated = args.reconcilePivotOutputs(recalculated, false);
+        const changed = isRestore
+            ? new Uint32Array()
+            : args.composeEventChanges(recalculated, explicitChangedCount);
+        const lastMetrics = {
+            ...args.state.getLastMetrics(),
+            batchId: args.state.getLastMetrics().batchId + 1,
+            changedInputCount: changedInputCount + formulaChangedCount,
+            compileMs,
+        };
+        args.state.setLastMetrics(lastMetrics);
+        const event = {
+            kind: "batch",
+            invalidation: isRestore ? "full" : "cells",
+            changedCellIndices: changed,
+            invalidatedRanges: [],
+            invalidatedRows: [],
+            invalidatedColumns: [],
+            metrics: lastMetrics,
+            explicitChangedCount,
+        };
+        if (isRestore) {
+            args.state.events.emitAllWatched(event);
+            return;
+        }
+        args.state.events.emit(event, changed, (cellIndex) => args.state.workbook.getQualifiedAddress(cellIndex));
+        void args.state.getSyncClientConnection()?.send(batch);
+        emitBatch(batch);
+    };
     return {
         applyBatch(batch, source, potentialNewCells) {
             return Effect.try({
@@ -599,6 +864,17 @@ export function createEngineOperationService(args) {
                 }),
             });
         },
+        applyCellMutationsAt(refs, batch, source, potentialNewCells) {
+            return Effect.try({
+                try: () => {
+                    applyCellMutationsAtNow(refs, batch, source, potentialNewCells);
+                },
+                catch: (cause) => new EngineMutationError({
+                    message: mutationErrorMessage(`Failed to apply ${source} cell mutations`, cause),
+                    cause,
+                }),
+            });
+        },
         applyDerivedOp(op) {
             return Effect.try({
                 try: () => applyDerivedOpNow(op),