@ricsam/formula-engine 0.2.13 → 0.2.15

package/dist/cjs/core/engine.cjs

@@ -60,6 +60,7 @@ var import_style_manager = require("./managers/style-manager.cjs");
 var import_copy_manager = require("./managers/copy-manager.cjs");
 var import_reference_manager = require("./managers/reference-manager.cjs");
 var import_range_metadata_manager = require("./managers/range-metadata-manager.cjs");
+var import_undo_redo_manager = require("./managers/undo-redo-manager.cjs");
 var import_engine_snapshot = require("./engine-snapshot.cjs");
 var import_mutation_invalidation = require("./mutation-invalidation.cjs");
 var import_resource_keys = require("./resource-keys.cjs");
@@ -76,6 +77,8 @@ class FormulaEngine {
   rangeMetadataManager;
   copyManager;
   referenceManager;
+  undoRedoManager;
+  historyCheckpointDepth = 0;
   _workbookManager;
   _namedExpressionManager;
   _tableManager;
@@ -85,7 +88,8 @@ class FormulaEngine {
   _dependencyManager;
   _styleManager;
   _rangeMetadataManager;
-  constructor() {
+  constructor(options = {}) {
+    this.undoRedoManager = new import_undo_redo_manager.UndoRedoManager(options.undoRedo);
     this.eventManager = new import_event_manager.EventManager;
     this.workbookManager = new import_workbook_manager.WorkbookManager;
     this.namedExpressionManager = new import_named_expression_manager.NamedExpressionManager;
@@ -109,8 +113,51 @@ class FormulaEngine {
     this._styleManager = this.styleManager;
     this._rangeMetadataManager = this.rangeMetadataManager;
   }
-  static buildEmpty() {
-    return new FormulaEngine;
+  static buildEmpty(options) {
+    return new FormulaEngine(options);
+  }
+  undo() {
+    if (!this.undoRedoManager.canUndo()) {
+      return false;
+    }
+    const target = this.undoRedoManager.popUndo();
+    if (!target) {
+      return false;
+    }
+    const current = this.serializeHistorySnapshot();
+    this.restoreHistorySnapshot(target);
+    this.undoRedoManager.pushRedo(current);
+    this.emitUpdate();
+    return true;
+  }
+  redo() {
+    if (!this.undoRedoManager.canRedo()) {
+      return false;
+    }
+    const target = this.undoRedoManager.popRedo();
+    if (!target) {
+      return false;
+    }
+    const current = this.serializeHistorySnapshot();
+    this.restoreHistorySnapshot(target);
+    this.undoRedoManager.pushUndo(current);
+    this.emitUpdate();
+    return true;
+  }
+  canUndo() {
+    return this.undoRedoManager.canUndo();
+  }
+  canRedo() {
+    return this.undoRedoManager.canRedo();
+  }
+  getUndoRedoState() {
+    return this.undoRedoManager.getState();
+  }
+  clearUndoRedoHistory() {
+    this.undoRedoManager.clear();
+  }
+  transact(callback) {
+    return this.withUndoRedoCheckpoint(callback);
   }
   emitMutation(footprint) {
     this.evaluationManager.invalidateFromMutation(footprint);
@@ -119,6 +166,21 @@ class FormulaEngine {
   emitUpdate() {
     this.eventManager.emitUpdate();
   }
+  withUndoRedoCheckpoint(callback) {
+    if (this.historyCheckpointDepth > 0) {
+      return callback();
+    }
+    const before = this.serializeHistorySnapshot();
+    this.historyCheckpointDepth++;
+    try {
+      const result = callback();
+      const after = this.serializeHistorySnapshot();
+      this.undoRedoManager.recordMutation(before, after);
+      return result;
+    } finally {
+      this.historyCheckpointDepth--;
+    }
+  }
   getExistingSheetContent(opts) {
     const sheet = this.workbookManager.getSheet(opts);
     return sheet ? new Map(sheet.content) : undefined;
@@ -195,8 +257,10 @@ class FormulaEngine {
     return this.evaluationManager.evaluationResultToSerializedValue(result, cellAddress, debug);
   }
   setCellMetadata(address, metadata) {
-    this.workbookManager.setCellMetadata(address, metadata);
-    this.emitUpdate();
+    return this.withUndoRedoCheckpoint(() => {
+      this.workbookManager.setCellMetadata(address, metadata);
+      this.emitUpdate();
+    });
   }
   getCellMetadata(address) {
     const metadata = this.workbookManager.getCellMetadata(address);
@@ -206,29 +270,37 @@ class FormulaEngine {
     return this.workbookManager.getSheetMetadataSerialized(opts);
   }
   setSheetMetadata(opts, metadata) {
-    this.workbookManager.setSheetMetadata(opts, metadata);
-    this.emitUpdate();
+    return this.withUndoRedoCheckpoint(() => {
+      this.workbookManager.setSheetMetadata(opts, metadata);
+      this.emitUpdate();
+    });
   }
   getSheetMetadata(opts) {
     return this.workbookManager.getSheetMetadata(opts);
   }
   setWorkbookMetadata(workbookName, metadata) {
-    this.workbookManager.setWorkbookMetadata(workbookName, metadata);
-    this.emitUpdate();
+    return this.withUndoRedoCheckpoint(() => {
+      this.workbookManager.setWorkbookMetadata(workbookName, metadata);
+      this.emitUpdate();
+    });
   }
   getWorkbookMetadata(workbookName) {
     return this.workbookManager.getWorkbookMetadata(workbookName);
   }
   addRangeMetadata(metadata) {
-    const id = this.rangeMetadataManager.addRangeMetadata(metadata);
-    this.emitUpdate();
-    return id;
+    return this.withUndoRedoCheckpoint(() => {
+      const id = this.rangeMetadataManager.addRangeMetadata(metadata);
+      this.emitUpdate();
+      return id;
+    });
   }
   removeRangeMetadata(id) {
-    const removed = this.rangeMetadataManager.removeRangeMetadata(id);
-    if (removed) {
-      this.emitUpdate();
-    }
+    return this.withUndoRedoCheckpoint(() => {
+      const removed = this.rangeMetadataManager.removeRangeMetadata(id);
+      if (removed) {
+        this.emitUpdate();
+      }
+    });
   }
   getAllRangeMetadata() {
     return this.rangeMetadataManager.getAllRangeMetadata();
@@ -240,17 +312,29 @@ class FormulaEngine {
     return this.rangeMetadataManager.getRangeMetadataIntersectingWithRange(range);
   }
   clearRangeMetadata(range) {
-    this.rangeMetadataManager.clearRangeMetadataInRange(range);
-    this.emitUpdate();
+    return this.withUndoRedoCheckpoint(() => {
+      this.rangeMetadataManager.clearRangeMetadataInRange(range);
+      this.emitUpdate();
+    });
   }
   createRef(address) {
-    return this.referenceManager.createRef(address);
+    return this.withUndoRedoCheckpoint(() => {
+      const id = this.referenceManager.createRef(address);
+      this.emitUpdate();
+      return id;
+    });
   }
   getRefAddress(refId) {
     return this.referenceManager.getRefAddress(refId);
   }
   deleteRef(refId) {
-    return this.referenceManager.deleteRef(refId);
+    return this.withUndoRedoCheckpoint(() => {
+      const deleted = this.referenceManager.deleteRef(refId);
+      if (deleted) {
+        this.emitUpdate();
+      }
+      return deleted;
+    });
   }
   getInvalidRefs() {
     return this.referenceManager.getInvalidRefs();
@@ -265,21 +349,25 @@ class FormulaEngine {
     throw new Error("Not implemented");
   }
   addNamedExpression(opts) {
-    this.assertNamedExpressionScopeExists(opts);
-    this.namedExpressionManager.addNamedExpression(opts);
-    this.emitMutation({
-      touchedCells: [],
-      resourceKeys: [import_resource_keys.getNamedExpressionResourceKey(opts)]
-    });
-  }
-  removeNamedExpression(opts) {
-    const removed = this.namedExpressionManager.removeNamedExpression(opts);
-    if (removed) {
+    return this.withUndoRedoCheckpoint(() => {
+      this.assertNamedExpressionScopeExists(opts);
+      this.namedExpressionManager.addNamedExpression(opts);
       this.emitMutation({
         touchedCells: [],
         resourceKeys: [import_resource_keys.getNamedExpressionResourceKey(opts)]
       });
-    }
+    });
+  }
+  removeNamedExpression(opts) {
+    return this.withUndoRedoCheckpoint(() => {
+      const removed = this.namedExpressionManager.removeNamedExpression(opts);
+      if (removed) {
+        this.emitMutation({
+          touchedCells: [],
+          resourceKeys: [import_resource_keys.getNamedExpressionResourceKey(opts)]
+        });
+      }
+    });
   }
   hasNamedExpression(opts) {
     const scope = opts.sheetName && opts.workbookName ? {
@@ -293,140 +381,130 @@ class FormulaEngine {
     });
   }
   updateNamedExpression(opts) {
-    this.namedExpressionManager.updateNamedExpression(opts);
-    this.emitMutation({
-      touchedCells: [],
-      resourceKeys: [import_resource_keys.getNamedExpressionResourceKey(opts)]
+    return this.withUndoRedoCheckpoint(() => {
+      this.namedExpressionManager.updateNamedExpression(opts);
+      this.emitMutation({
+        touchedCells: [],
+        resourceKeys: [import_resource_keys.getNamedExpressionResourceKey(opts)]
+      });
     });
   }
   renameNamedExpression(opts) {
-    this.namedExpressionManager.renameNamedExpression(opts);
-    const changedCells = this.workbookManager.updateAllFormulas((formula) => import_named_expression_renamer.renameNamedExpressionInFormula(formula, opts.expressionName, opts.newName));
-    const changedNamedExpressions = this.namedExpressionManager.updateAllNamedExpressions((formula) => import_named_expression_renamer.renameNamedExpressionInFormula(formula, opts.expressionName, opts.newName));
-    this.emitMutation({
-      touchedCells: import_mutation_invalidation.buildFormulaTouchedCells(changedCells),
-      resourceKeys: [
-        import_resource_keys.getNamedExpressionResourceKey({
-          expressionName: opts.expressionName,
-          workbookName: opts.workbookName,
-          sheetName: opts.sheetName
-        }),
-        import_resource_keys.getNamedExpressionResourceKey({
-          expressionName: opts.newName,
-          workbookName: opts.workbookName,
-          sheetName: opts.sheetName
-        }),
-        ...changedNamedExpressions
-      ]
+    return this.withUndoRedoCheckpoint(() => {
+      this.namedExpressionManager.renameNamedExpression(opts);
+      const changedCells = this.workbookManager.updateAllFormulas((formula) => import_named_expression_renamer.renameNamedExpressionInFormula(formula, opts.expressionName, opts.newName));
+      const changedNamedExpressions = this.namedExpressionManager.updateAllNamedExpressions((formula) => import_named_expression_renamer.renameNamedExpressionInFormula(formula, opts.expressionName, opts.newName));
+      this.emitMutation({
+        touchedCells: import_mutation_invalidation.buildFormulaTouchedCells(changedCells),
+        resourceKeys: [
+          import_resource_keys.getNamedExpressionResourceKey({
+            expressionName: opts.expressionName,
+            workbookName: opts.workbookName,
+            sheetName: opts.sheetName
+          }),
+          import_resource_keys.getNamedExpressionResourceKey({
+            expressionName: opts.newName,
+            workbookName: opts.workbookName,
+            sheetName: opts.sheetName
+          }),
+          ...changedNamedExpressions
+        ]
+      });
     });
   }
   setNamedExpressions(opts) {
-    const allExpressions = this.namedExpressionManager.getNamedExpressions();
-    let previousExpressions;
-    if (opts.type === "global") {
-      previousExpressions = new Map(allExpressions.globalExpressions);
-    } else if (opts.type === "workbook") {
-      previousExpressions = new Map(allExpressions.workbookExpressions.get(opts.workbookName) || []);
-    } else {
-      const sheetExpressions = allExpressions.sheetExpressions.get(opts.workbookName)?.get(opts.sheetName);
-      previousExpressions = new Map(sheetExpressions || []);
-    }
-    this.namedExpressionManager.setNamedExpressions(opts);
-    const scope = opts.type === "global" ? {} : opts.type === "workbook" ? { workbookName: opts.workbookName } : {
-      workbookName: opts.workbookName,
-      sheetName: opts.sheetName
-    };
-    this.emitMutation({
-      touchedCells: [],
-      resourceKeys: [
-        ...import_mutation_invalidation.getNamedExpressionScopeResourceKeys(previousExpressions.keys(), scope),
-        ...import_mutation_invalidation.getNamedExpressionScopeResourceKeys(opts.expressions.keys(), scope)
-      ]
+    return this.withUndoRedoCheckpoint(() => {
+      const allExpressions = this.namedExpressionManager.getNamedExpressions();
+      let previousExpressions;
+      if (opts.type === "global") {
+        previousExpressions = new Map(allExpressions.globalExpressions);
+      } else if (opts.type === "workbook") {
+        previousExpressions = new Map(allExpressions.workbookExpressions.get(opts.workbookName) || []);
+      } else {
+        const sheetExpressions = allExpressions.sheetExpressions.get(opts.workbookName)?.get(opts.sheetName);
+        previousExpressions = new Map(sheetExpressions || []);
+      }
+      this.namedExpressionManager.setNamedExpressions(opts);
+      const scope = opts.type === "global" ? {} : opts.type === "workbook" ? { workbookName: opts.workbookName } : {
+        workbookName: opts.workbookName,
+        sheetName: opts.sheetName
+      };
+      this.emitMutation({
+        touchedCells: [],
+        resourceKeys: [
+          ...import_mutation_invalidation.getNamedExpressionScopeResourceKeys(previousExpressions.keys(), scope),
+          ...import_mutation_invalidation.getNamedExpressionScopeResourceKeys(opts.expressions.keys(), scope)
+        ]
+      });
     });
   }
   addTable(props) {
-    const table = this.tableManager.addTable({
-      ...props,
-      getCellValue: (cellAddress) => this.getCellValue(cellAddress)
-    });
-    this.emitMutation({
-      touchedCells: import_mutation_invalidation.buildTableTouchedCells(this.workbookManager, [table]),
-      tableContextChangedCells: import_mutation_invalidation.buildTableContextChangedCells(this.workbookManager, [table]),
-      resourceKeys: [
-        import_resource_keys.getTableResourceKey({
-          workbookName: props.workbookName,
-          tableName: props.tableName
-        })
-      ]
+    return this.withUndoRedoCheckpoint(() => {
+      const table = this.tableManager.addTable({
+        ...props,
+        getCellValue: (cellAddress) => this.getCellValue(cellAddress)
+      });
+      this.emitMutation({
+        touchedCells: import_mutation_invalidation.buildTableTouchedCells(this.workbookManager, [table]),
+        tableContextChangedCells: import_mutation_invalidation.buildTableContextChangedCells(this.workbookManager, [table]),
+        resourceKeys: [
+          import_resource_keys.getTableResourceKey({
+            workbookName: props.workbookName,
+            tableName: props.tableName
+          })
+        ]
+      });
     });
   }
   renameTable(workbookName, names) {
-    const oldTable = this.tableManager.getTable({
-      workbookName,
-      name: names.oldName
-    });
-    const oldTableSnapshot = oldTable ? { ...oldTable, headers: new Map(oldTable.headers) } : undefined;
-    this.tableManager.renameTable(workbookName, names);
-    const changedCells = this.workbookManager.updateAllFormulas((formula) => import_table_renamer.renameTableInFormula(formula, names.oldName, names.newName));
-    const changedNamedExpressions = this.namedExpressionManager.updateAllNamedExpressions((formula) => import_table_renamer.renameTableInFormula(formula, names.oldName, names.newName));
-    const newTable = this.tableManager.getTable({
-      workbookName,
-      name: names.newName
-    });
-    this.emitMutation({
-      touchedCells: import_mutation_invalidation.mergeTouchedCells(import_mutation_invalidation.buildTableTouchedCells(this.workbookManager, [oldTableSnapshot]), import_mutation_invalidation.buildTableTouchedCells(this.workbookManager, [newTable]), import_mutation_invalidation.buildFormulaTouchedCells(changedCells)),
-      tableContextChangedCells: import_mutation_invalidation.buildTableContextChangedCells(this.workbookManager, [oldTableSnapshot, newTable]),
-      resourceKeys: [
-        import_resource_keys.getTableResourceKey({
-          workbookName,
-          tableName: names.oldName
-        }),
-        import_resource_keys.getTableResourceKey({
-          workbookName,
-          tableName: names.newName
-        }),
-        ...changedNamedExpressions
-      ]
+    return this.withUndoRedoCheckpoint(() => {
+      const oldTable = this.tableManager.getTable({
+        workbookName,
+        name: names.oldName
+      });
+      const oldTableSnapshot = oldTable ? { ...oldTable, headers: new Map(oldTable.headers) } : undefined;
+      this.tableManager.renameTable(workbookName, names);
+      const changedCells = this.workbookManager.updateAllFormulas((formula) => import_table_renamer.renameTableInFormula(formula, names.oldName, names.newName));
+      const changedNamedExpressions = this.namedExpressionManager.updateAllNamedExpressions((formula) => import_table_renamer.renameTableInFormula(formula, names.oldName, names.newName));
+      const newTable = this.tableManager.getTable({
+        workbookName,
+        name: names.newName
+      });
+      this.emitMutation({
+        touchedCells: import_mutation_invalidation.mergeTouchedCells(import_mutation_invalidation.buildTableTouchedCells(this.workbookManager, [oldTableSnapshot]), import_mutation_invalidation.buildTableTouchedCells(this.workbookManager, [newTable]), import_mutation_invalidation.buildFormulaTouchedCells(changedCells)),
+        tableContextChangedCells: import_mutation_invalidation.buildTableContextChangedCells(this.workbookManager, [oldTableSnapshot, newTable]),
+        resourceKeys: [
+          import_resource_keys.getTableResourceKey({
+            workbookName,
+            tableName: names.oldName
+          }),
+          import_resource_keys.getTableResourceKey({
+            workbookName,
+            tableName: names.newName
+          }),
+          ...changedNamedExpressions
+        ]
+      });
     });
   }
   updateTable(opts) {
-    const oldTable = this.tableManager.getTable({
-      workbookName: opts.workbookName,
-      name: opts.tableName
-    });
-    const oldTableSnapshot = oldTable ? { ...oldTable, headers: new Map(oldTable.headers) } : undefined;
-    this.tableManager.updateTable({
-      ...opts,
-      getCellValue: (cellAddress) => this.getCellValue(cellAddress)
-    });
-    const newTable = this.tableManager.getTable({
-      workbookName: opts.workbookName,
-      name: opts.tableName
-    });
-    this.emitMutation({
-      touchedCells: import_mutation_invalidation.mergeTouchedCells(import_mutation_invalidation.buildTableTouchedCells(this.workbookManager, [oldTableSnapshot]), import_mutation_invalidation.buildTableTouchedCells(this.workbookManager, [newTable])),
-      tableContextChangedCells: import_mutation_invalidation.buildTableContextChangedCells(this.workbookManager, [oldTableSnapshot, newTable]),
-      resourceKeys: [
-        import_resource_keys.getTableResourceKey({
-          workbookName: opts.workbookName,
-          tableName: opts.tableName
-        })
-      ]
-    });
-  }
-  removeTable(opts) {
-    const oldTable = this.tableManager.getTable({
-      workbookName: opts.workbookName,
-      name: opts.tableName
-    });
-    const oldTableSnapshot = oldTable ? { ...oldTable, headers: new Map(oldTable.headers) } : undefined;
-    const found = this.tableManager.removeTable(opts);
-    if (found) {
+    return this.withUndoRedoCheckpoint(() => {
+      const oldTable = this.tableManager.getTable({
+        workbookName: opts.workbookName,
+        name: opts.tableName
+      });
+      const oldTableSnapshot = oldTable ? { ...oldTable, headers: new Map(oldTable.headers) } : undefined;
+      this.tableManager.updateTable({
+        ...opts,
+        getCellValue: (cellAddress) => this.getCellValue(cellAddress)
+      });
+      const newTable = this.tableManager.getTable({
+        workbookName: opts.workbookName,
+        name: opts.tableName
+      });
       this.emitMutation({
-        touchedCells: import_mutation_invalidation.buildTableTouchedCells(this.workbookManager, [
-          oldTableSnapshot
-        ]),
-        tableContextChangedCells: import_mutation_invalidation.buildTableContextChangedCells(this.workbookManager, [oldTableSnapshot]),
+        touchedCells: import_mutation_invalidation.mergeTouchedCells(import_mutation_invalidation.buildTableTouchedCells(this.workbookManager, [oldTableSnapshot]), import_mutation_invalidation.buildTableTouchedCells(this.workbookManager, [newTable])),
+        tableContextChangedCells: import_mutation_invalidation.buildTableContextChangedCells(this.workbookManager, [oldTableSnapshot, newTable]),
         resourceKeys: [
           import_resource_keys.getTableResourceKey({
             workbookName: opts.workbookName,
@@ -434,7 +512,31 @@ class FormulaEngine {
           })
         ]
       });
-    }
+    });
+  }
+  removeTable(opts) {
+    return this.withUndoRedoCheckpoint(() => {
+      const oldTable = this.tableManager.getTable({
+        workbookName: opts.workbookName,
+        name: opts.tableName
+      });
+      const oldTableSnapshot = oldTable ? { ...oldTable, headers: new Map(oldTable.headers) } : undefined;
+      const found = this.tableManager.removeTable(opts);
+      if (found) {
+        this.emitMutation({
+          touchedCells: import_mutation_invalidation.buildTableTouchedCells(this.workbookManager, [
+            oldTableSnapshot
+          ]),
+          tableContextChangedCells: import_mutation_invalidation.buildTableContextChangedCells(this.workbookManager, [oldTableSnapshot]),
+          resourceKeys: [
+            import_resource_keys.getTableResourceKey({
+              workbookName: opts.workbookName,
+              tableName: opts.tableName
+            })
+          ]
+        });
+      }
+    });
   }
   getAllTables() {
     return Array.from(this.tableManager.tables.values()).flatMap((tables) => Array.from(tables.values()).map((table) => ({
@@ -455,20 +557,22 @@ class FormulaEngine {
     });
   }
   resetTables(tables) {
-    const oldTables = this.getAllTables();
-    const newTables = Array.from(tables.values()).flatMap((workbookTables) => Array.from(workbookTables.values()));
-    const resourceKeys = new Set;
-    for (const table of [...oldTables, ...newTables]) {
-      resourceKeys.add(import_resource_keys.getTableResourceKey({
-        workbookName: table.workbookName,
-        tableName: table.name
-      }));
-    }
-    this.tableManager.resetTables(tables);
-    this.emitMutation({
-      touchedCells: import_mutation_invalidation.mergeTouchedCells(import_mutation_invalidation.buildTableTouchedCells(this.workbookManager, oldTables), import_mutation_invalidation.buildTableTouchedCells(this.workbookManager, newTables)),
-      tableContextChangedCells: import_mutation_invalidation.buildTableContextChangedCells(this.workbookManager, [...oldTables, ...newTables]),
-      resourceKeys: Array.from(resourceKeys)
+    return this.withUndoRedoCheckpoint(() => {
+      const oldTables = this.getAllTables();
+      const newTables = Array.from(tables.values()).flatMap((workbookTables) => Array.from(workbookTables.values()));
+      const resourceKeys = new Set;
+      for (const table of [...oldTables, ...newTables]) {
+        resourceKeys.add(import_resource_keys.getTableResourceKey({
+          workbookName: table.workbookName,
+          tableName: table.name
+        }));
+      }
+      this.tableManager.resetTables(tables);
+      this.emitMutation({
+        touchedCells: import_mutation_invalidation.mergeTouchedCells(import_mutation_invalidation.buildTableTouchedCells(this.workbookManager, oldTables), import_mutation_invalidation.buildTableTouchedCells(this.workbookManager, newTables)),
+        tableContextChangedCells: import_mutation_invalidation.buildTableContextChangedCells(this.workbookManager, [...oldTables, ...newTables]),
+        resourceKeys: Array.from(resourceKeys)
+      });
     });
   }
   getTables(workbookName) {
@@ -478,14 +582,18 @@ class FormulaEngine {
     return this.tableManager.isCellInTable(cellAddress);
   }
   addConditionalStyle(style) {
-    this.styleManager.addConditionalStyle(style);
-    this.emitUpdate();
+    return this.withUndoRedoCheckpoint(() => {
+      this.styleManager.addConditionalStyle(style);
+      this.emitUpdate();
+    });
   }
   removeConditionalStyle(workbookName, index) {
-    const removed = this.styleManager.removeConditionalStyle(workbookName, index);
-    if (removed) {
-      this.emitUpdate();
-    }
+    return this.withUndoRedoCheckpoint(() => {
+      const removed = this.styleManager.removeConditionalStyle(workbookName, index);
+      if (removed) {
+        this.emitUpdate();
+      }
+    });
   }
   getConditionalStyleCount(workbookName) {
     const allStyles = this.styleManager.getAllConditionalStyles();
@@ -504,14 +612,18 @@ class FormulaEngine {
     return this.styleManager.getAllConditionalStyles();
   }
   addCellStyle(style) {
-    this.styleManager.addCellStyle(style);
-    this.emitUpdate();
+    return this.withUndoRedoCheckpoint(() => {
+      this.styleManager.addCellStyle(style);
+      this.emitUpdate();
+    });
   }
   removeCellStyle(workbookName, index) {
-    const removed = this.styleManager.removeCellStyle(workbookName, index);
-    if (removed) {
-      this.emitUpdate();
-    }
+    return this.withUndoRedoCheckpoint(() => {
+      const removed = this.styleManager.removeCellStyle(workbookName, index);
+      if (removed) {
+        this.emitUpdate();
+      }
+    });
   }
   getCellStyleCount(workbookName) {
     const allStyles = this.styleManager.getAllCellStyles();
@@ -524,8 +636,10 @@ class FormulaEngine {
     return this.styleManager.getStyleForRange(range);
   }
   clearCellStyles(range) {
-    this.styleManager.clearCellStyles(range);
-    this.emitUpdate();
+    return this.withUndoRedoCheckpoint(() => {
+      this.styleManager.clearCellStyles(range);
+      this.emitUpdate();
+    });
   }
   getTopLeftCell(cells) {
     let topLeft = cells[0];
@@ -555,100 +669,106 @@ class FormulaEngine {
     return this.dedupeAddresses(options.cut ? [...source, ...targetCells] : targetCells);
   }
   pasteCells(source, target, options) {
-    if (source.length === 0) {
-      return;
-    }
-    const touchedAddresses = this.getPasteTouchedAddresses(source, target, options);
-    const before = import_mutation_invalidation.captureCellContents(this.workbookManager, touchedAddresses);
-    this.copyManager.pasteCells(source, target, options);
-    const after = import_mutation_invalidation.captureCellContents(this.workbookManager, touchedAddresses);
-    this.emitMutation({
-      touchedCells: import_mutation_invalidation.buildTouchedCells(touchedAddresses.map((address) => ({
-        address,
-        before: before.get(import_mutation_invalidation.getMutationAddressKey(address)),
-        after: after.get(import_mutation_invalidation.getMutationAddressKey(address))
-      }))),
-      resourceKeys: []
+    return this.withUndoRedoCheckpoint(() => {
+      if (source.length === 0) {
+        return;
+      }
+      const touchedAddresses = this.getPasteTouchedAddresses(source, target, options);
+      const before = import_mutation_invalidation.captureCellContents(this.workbookManager, touchedAddresses);
+      this.copyManager.pasteCells(source, target, options);
+      const after = import_mutation_invalidation.captureCellContents(this.workbookManager, touchedAddresses);
+      this.emitMutation({
+        touchedCells: import_mutation_invalidation.buildTouchedCells(touchedAddresses.map((address) => ({
+          address,
+          before: before.get(import_mutation_invalidation.getMutationAddressKey(address)),
+          after: after.get(import_mutation_invalidation.getMutationAddressKey(address))
+        }))),
+        resourceKeys: []
+      });
     });
   }
   fillAreas(seedRange, targetRanges, options) {
-    const touchedAddresses = this.dedupeAddresses([
-      ...targetRanges.flatMap((targetRange) => import_mutation_invalidation.getFiniteRangeAddresses(targetRange)),
-      ...options.cut ? import_mutation_invalidation.getFiniteRangeAddresses(seedRange) : []
-    ]);
-    const before = import_mutation_invalidation.captureCellContents(this.workbookManager, touchedAddresses);
-    this.copyManager.fillAreas(seedRange, targetRanges, options);
-    const after = import_mutation_invalidation.captureCellContents(this.workbookManager, touchedAddresses);
-    this.emitMutation({
-      touchedCells: import_mutation_invalidation.buildTouchedCells(touchedAddresses.map((address) => ({
-        address,
-        before: before.get(import_mutation_invalidation.getMutationAddressKey(address)),
-        after: after.get(import_mutation_invalidation.getMutationAddressKey(address))
-      }))),
-      resourceKeys: []
+    return this.withUndoRedoCheckpoint(() => {
+      const touchedAddresses = this.dedupeAddresses([
+        ...targetRanges.flatMap((targetRange) => import_mutation_invalidation.getFiniteRangeAddresses(targetRange)),
+        ...options.cut ? import_mutation_invalidation.getFiniteRangeAddresses(seedRange) : []
+      ]);
+      const before = import_mutation_invalidation.captureCellContents(this.workbookManager, touchedAddresses);
+      this.copyManager.fillAreas(seedRange, targetRanges, options);
+      const after = import_mutation_invalidation.captureCellContents(this.workbookManager, touchedAddresses);
+      this.emitMutation({
+        touchedCells: import_mutation_invalidation.buildTouchedCells(touchedAddresses.map((address) => ({
+          address,
+          before: before.get(import_mutation_invalidation.getMutationAddressKey(address)),
+          after: after.get(import_mutation_invalidation.getMutationAddressKey(address))
+        }))),
+        resourceKeys: []
+      });
     });
   }
   smartPaste(sourceCells, pasteSelection, options) {
-    if (sourceCells.length === 0) {
-      return;
-    }
-    if (options.cut === true) {
-      for (const area of pasteSelection.areas) {
-        const target = {
-          workbookName: pasteSelection.workbookName,
-          sheetName: pasteSelection.sheetName,
-          colIndex: area.start.col,
-          rowIndex: area.start.row
-        };
-        this.pasteCells(sourceCells, target, options);
+    return this.withUndoRedoCheckpoint(() => {
+      if (sourceCells.length === 0) {
+        return;
       }
-      return;
-    }
-    const sourceBounds = this.getBoundsFromCells(sourceCells);
-    const sourceWidth = sourceBounds.maxCol - sourceBounds.minCol + 1;
-    const sourceHeight = sourceBounds.maxRow - sourceBounds.minRow + 1;
-    const seedRange = {
-      workbookName: sourceCells[0].workbookName,
-      sheetName: sourceCells[0].sheetName,
-      range: {
-        start: { col: sourceBounds.minCol, row: sourceBounds.minRow },
-        end: {
-          col: { type: "number", value: sourceBounds.maxCol },
-          row: { type: "number", value: sourceBounds.maxRow }
+      if (options.cut === true) {
+        for (const area of pasteSelection.areas) {
+          const target = {
+            workbookName: pasteSelection.workbookName,
+            sheetName: pasteSelection.sheetName,
+            colIndex: area.start.col,
+            rowIndex: area.start.row
+          };
+          this.pasteCells(sourceCells, target, options);
         }
+        return;
       }
-    };
-    for (const area of pasteSelection.areas) {
-      const pasteStartCol = area.start.col;
-      const pasteStartRow = area.start.row;
-      const pasteEndCol = area.end.col.type === "number" ? area.end.col.value : pasteStartCol;
-      const pasteEndRow = area.end.row.type === "number" ? area.end.row.value : pasteStartRow;
-      const pasteWidth = pasteEndCol - pasteStartCol + 1;
-      const pasteHeight = pasteEndRow - pasteStartRow + 1;
-      const shouldFill = pasteWidth > sourceWidth || pasteHeight > sourceHeight;
-      if (shouldFill) {
-        const targetRange = {
-          workbookName: pasteSelection.workbookName,
-          sheetName: pasteSelection.sheetName,
-          range: {
-            start: { col: pasteStartCol, row: pasteStartRow },
-            end: {
-              col: { type: "number", value: pasteEndCol },
-              row: { type: "number", value: pasteEndRow }
-            }
+      const sourceBounds = this.getBoundsFromCells(sourceCells);
+      const sourceWidth = sourceBounds.maxCol - sourceBounds.minCol + 1;
+      const sourceHeight = sourceBounds.maxRow - sourceBounds.minRow + 1;
+      const seedRange = {
+        workbookName: sourceCells[0].workbookName,
+        sheetName: sourceCells[0].sheetName,
+        range: {
+          start: { col: sourceBounds.minCol, row: sourceBounds.minRow },
+          end: {
+            col: { type: "number", value: sourceBounds.maxCol },
+            row: { type: "number", value: sourceBounds.maxRow }
           }
-        };
-        this.fillAreas(seedRange, [targetRange], options);
-      } else {
-        const target = {
-          workbookName: pasteSelection.workbookName,
-          sheetName: pasteSelection.sheetName,
-          colIndex: pasteStartCol,
-          rowIndex: pasteStartRow
-        };
-        this.pasteCells(sourceCells, target, options);
+        }
+      };
+      for (const area of pasteSelection.areas) {
+        const pasteStartCol = area.start.col;
+        const pasteStartRow = area.start.row;
+        const pasteEndCol = area.end.col.type === "number" ? area.end.col.value : pasteStartCol;
+        const pasteEndRow = area.end.row.type === "number" ? area.end.row.value : pasteStartRow;
+        const pasteWidth = pasteEndCol - pasteStartCol + 1;
+        const pasteHeight = pasteEndRow - pasteStartRow + 1;
+        const shouldFill = pasteWidth > sourceWidth || pasteHeight > sourceHeight;
+        if (shouldFill) {
+          const targetRange = {
+            workbookName: pasteSelection.workbookName,
+            sheetName: pasteSelection.sheetName,
+            range: {
+              start: { col: pasteStartCol, row: pasteStartRow },
+              end: {
+                col: { type: "number", value: pasteEndCol },
+                row: { type: "number", value: pasteEndRow }
+              }
+            }
+          };
+          this.fillAreas(seedRange, [targetRange], options);
+        } else {
+          const target = {
+            workbookName: pasteSelection.workbookName,
+            sheetName: pasteSelection.sheetName,
+            colIndex: pasteStartCol,
+            rowIndex: pasteStartRow
+          };
+          this.pasteCells(sourceCells, target, options);
+        }
       }
-    }
+    });
   }
   getBoundsFromCells(cells) {
     if (cells.length === 0) {
@@ -667,72 +787,84 @@ class FormulaEngine {
     return { minCol, minRow, maxCol, maxRow };
   }
   moveCell(source, target) {
-    this.pasteCells([source], target, {
-      cut: true,
-      type: "formula",
-      include: "all"
+    return this.withUndoRedoCheckpoint(() => {
+      this.pasteCells([source], target, {
+        cut: true,
+        type: "formula",
+        include: "all"
+      });
     });
   }
   moveRange(sourceRange, target) {
-    const cells = this.copyManager.expandRangeToCells(sourceRange);
-    this.pasteCells(cells, target, {
-      cut: true,
-      type: "formula",
-      include: "all"
+    return this.withUndoRedoCheckpoint(() => {
+      const cells = this.copyManager.expandRangeToCells(sourceRange);
+      this.pasteCells(cells, target, {
+        cut: true,
+        type: "formula",
+        include: "all"
+      });
     });
   }
   addSheet(opts) {
-    const sheet = this.workbookManager.addSheet(opts);
-    this.namedExpressionManager.addSheet(opts);
-    this.emitMutation({
-      touchedCells: [],
-      resourceKeys: [import_resource_keys.getSheetResourceKey(opts)]
+    return this.withUndoRedoCheckpoint(() => {
+      const sheet = this.workbookManager.addSheet(opts);
+      this.namedExpressionManager.addSheet(opts);
+      this.emitMutation({
+        touchedCells: [],
+        resourceKeys: [import_resource_keys.getSheetResourceKey(opts)]
+      });
+      return sheet;
     });
-    return sheet;
   }
   createSheet(opts) {
-    const sheetName = opts.sheetName ?? this.workbookManager.getNextAvailableSheetName(opts.workbookName, opts.baseName);
-    return this.addSheet({
-      workbookName: opts.workbookName,
-      sheetName
+    return this.withUndoRedoCheckpoint(() => {
+      const sheetName = opts.sheetName ?? this.workbookManager.getNextAvailableSheetName(opts.workbookName, opts.baseName);
+      return this.addSheet({
+        workbookName: opts.workbookName,
+        sheetName
+      });
     });
   }
   removeSheet(opts) {
-    const resourceKeys = this.getSheetResourceKeys(opts);
-    this.workbookManager.removeSheet(opts);
-    this.namedExpressionManager.removeSheet(opts);
-    this.tableManager.removeSheet(opts);
-    this.styleManager.removeSheetStyles(opts.workbookName, opts.sheetName);
-    this.rangeMetadataManager.removeSheetRangeMetadata(opts.workbookName, opts.sheetName);
-    this.referenceManager.invalidateSheet(opts.workbookName, opts.sheetName);
-    this.emitMutation({
-      touchedCells: [],
-      resourceKeys,
-      removedScopes: [{ type: "sheet", ...opts }]
+    return this.withUndoRedoCheckpoint(() => {
+      const resourceKeys = this.getSheetResourceKeys(opts);
+      this.workbookManager.removeSheet(opts);
+      this.namedExpressionManager.removeSheet(opts);
+      this.tableManager.removeSheet(opts);
+      this.styleManager.removeSheetStyles(opts.workbookName, opts.sheetName);
+      this.rangeMetadataManager.removeSheetRangeMetadata(opts.workbookName, opts.sheetName);
+      this.referenceManager.invalidateSheet(opts.workbookName, opts.sheetName);
+      this.emitMutation({
+        touchedCells: [],
+        resourceKeys,
+        removedScopes: [{ type: "sheet", ...opts }]
+      });
     });
   }
   renameSheet(opts) {
-    const oldResourceKeys = this.getSheetResourceKeys(opts);
-    this.workbookManager.renameSheet(opts);
-    this.namedExpressionManager.renameSheet(opts);
-    this.tableManager.updateTablesForSheetRename(opts);
-    this.styleManager.updateSheetName(opts.workbookName, opts.sheetName, opts.newSheetName);
-    this.rangeMetadataManager.updateSheetName(opts.workbookName, opts.sheetName, opts.newSheetName);
-    const changedCells = this.workbookManager.updateAllFormulas((formula) => import_sheet_renamer.renameSheetInFormula({
-      formula,
-      oldSheetName: opts.sheetName,
-      newSheetName: opts.newSheetName
-    }));
-    this.referenceManager.updateSheetName(opts.workbookName, opts.sheetName, opts.newSheetName);
-    this.emitMutation({
-      touchedCells: import_mutation_invalidation.buildFormulaTouchedCells(changedCells),
-      resourceKeys: Array.from(new Set([
-        ...oldResourceKeys,
-        ...this.getSheetResourceKeys({
-          workbookName: opts.workbookName,
-          sheetName: opts.newSheetName
-        })
-      ]))
+    return this.withUndoRedoCheckpoint(() => {
+      const oldResourceKeys = this.getSheetResourceKeys(opts);
+      this.workbookManager.renameSheet(opts);
+      this.namedExpressionManager.renameSheet(opts);
+      this.tableManager.updateTablesForSheetRename(opts);
+      this.styleManager.updateSheetName(opts.workbookName, opts.sheetName, opts.newSheetName);
+      this.rangeMetadataManager.updateSheetName(opts.workbookName, opts.sheetName, opts.newSheetName);
+      const changedCells = this.workbookManager.updateAllFormulas((formula) => import_sheet_renamer.renameSheetInFormula({
+        formula,
+        oldSheetName: opts.sheetName,
+        newSheetName: opts.newSheetName
+      }));
+      this.referenceManager.updateSheetName(opts.workbookName, opts.sheetName, opts.newSheetName);
+      this.emitMutation({
+        touchedCells: import_mutation_invalidation.buildFormulaTouchedCells(changedCells),
+        resourceKeys: Array.from(new Set([
+          ...oldResourceKeys,
+          ...this.getSheetResourceKeys({
+            workbookName: opts.workbookName,
+            sheetName: opts.newSheetName
+          })
+        ]))
+      });
     });
   }
   hasSheet(opts) {
@@ -763,239 +895,259 @@ class FormulaEngine {
     return this.workbookManager.search(query, options);
   }
   replace(query, replacement, target, options) {
-    const prepared = this.workbookManager.prepareReplace(query, replacement, target, options);
-    this.workbookManager.setCellContent(prepared.address, prepared.afterContent);
-    this.emitMutation({
-      touchedCells: import_mutation_invalidation.buildTouchedCells([
-        {
-          address: prepared.address,
-          before: prepared.beforeContent,
-          after: prepared.afterContent
-        }
-      ]),
-      resourceKeys: []
+    return this.withUndoRedoCheckpoint(() => {
+      const prepared = this.workbookManager.prepareReplace(query, replacement, target, options);
+      this.workbookManager.setCellContent(prepared.address, prepared.afterContent);
+      this.emitMutation({
+        touchedCells: import_mutation_invalidation.buildTouchedCells([
+          {
+            address: prepared.address,
+            before: prepared.beforeContent,
+            after: prepared.afterContent
+          }
+        ]),
+        resourceKeys: []
+      });
+      return prepared.change;
     });
-    return prepared.change;
   }
   replaceAll(query, replacement, options) {
-    const preparedReplacements = this.workbookManager.prepareReplaceAll(query, replacement, options);
-    if (preparedReplacements.length === 0) {
-      return [];
-    }
-    for (const prepared of preparedReplacements) {
-      this.workbookManager.setCellContent(prepared.address, prepared.afterContent);
-    }
-    this.emitMutation({
-      touchedCells: import_mutation_invalidation.buildTouchedCells(preparedReplacements.map((prepared) => ({
-        address: prepared.address,
-        before: prepared.beforeContent,
-        after: prepared.afterContent
-      }))),
-      resourceKeys: []
+    return this.withUndoRedoCheckpoint(() => {
+      const preparedReplacements = this.workbookManager.prepareReplaceAll(query, replacement, options);
+      if (preparedReplacements.length === 0) {
+        return [];
+      }
+      for (const prepared of preparedReplacements) {
+        this.workbookManager.setCellContent(prepared.address, prepared.afterContent);
+      }
+      this.emitMutation({
+        touchedCells: import_mutation_invalidation.buildTouchedCells(preparedReplacements.map((prepared) => ({
+          address: prepared.address,
+          before: prepared.beforeContent,
+          after: prepared.afterContent
+        }))),
+        resourceKeys: []
+      });
+      return preparedReplacements.flatMap((prepared) => prepared.changes);
     });
-    return preparedReplacements.flatMap((prepared) => prepared.changes);
   }
   addWorkbook(workbookName) {
-    this.workbookManager.addWorkbook(workbookName);
-    this.namedExpressionManager.addWorkbook(workbookName);
-    this.tableManager.addWorkbook(workbookName);
-    this.emitMutation({
-      touchedCells: [],
-      resourceKeys: [import_resource_keys.getWorkbookResourceKey(workbookName)]
+    return this.withUndoRedoCheckpoint(() => {
+      this.workbookManager.addWorkbook(workbookName);
+      this.namedExpressionManager.addWorkbook(workbookName);
+      this.tableManager.addWorkbook(workbookName);
+      this.emitMutation({
+        touchedCells: [],
+        resourceKeys: [import_resource_keys.getWorkbookResourceKey(workbookName)]
+      });
     });
   }
   removeWorkbook(workbookName) {
-    const resourceKeys = this.getWorkbookResourceKeys(workbookName);
-    this.workbookManager.removeWorkbook(workbookName);
-    this.namedExpressionManager.removeWorkbook(workbookName);
-    this.tableManager.removeWorkbook(workbookName);
-    this.styleManager.removeWorkbookStyles(workbookName);
-    this.rangeMetadataManager.removeWorkbookRangeMetadata(workbookName);
-    this.referenceManager.invalidateWorkbook(workbookName);
-    this.emitMutation({
-      touchedCells: [],
-      resourceKeys,
-      removedScopes: [{ type: "workbook", workbookName }]
+    return this.withUndoRedoCheckpoint(() => {
+      const resourceKeys = this.getWorkbookResourceKeys(workbookName);
+      this.workbookManager.removeWorkbook(workbookName);
+      this.namedExpressionManager.removeWorkbook(workbookName);
+      this.tableManager.removeWorkbook(workbookName);
+      this.styleManager.removeWorkbookStyles(workbookName);
+      this.rangeMetadataManager.removeWorkbookRangeMetadata(workbookName);
+      this.referenceManager.invalidateWorkbook(workbookName);
+      this.emitMutation({
+        touchedCells: [],
+        resourceKeys,
+        removedScopes: [{ type: "workbook", workbookName }]
+      });
     });
   }
   hasWorkbook(workbookName) {
     return this.workbookManager.getWorkbooks().has(workbookName);
   }
   cloneWorkbook(fromWorkbookName, toWorkbookName) {
-    const sourceWorkbook = this.workbookManager.getWorkbooks().get(fromWorkbookName);
-    if (!sourceWorkbook) {
-      throw new Error(`Source workbook "${fromWorkbookName}" not found`);
-    }
-    if (this.workbookManager.getWorkbooks().has(toWorkbookName)) {
-      throw new Error(`Target workbook "${toWorkbookName}" already exists`);
-    }
-    this.workbookManager.addWorkbook(toWorkbookName);
-    this.namedExpressionManager.addWorkbook(toWorkbookName);
-    this.tableManager.addWorkbook(toWorkbookName);
-    for (const [sheetName, sheet] of sourceWorkbook.sheets) {
-      this.workbookManager.addSheet({
-        workbookName: toWorkbookName,
-        sheetName
-      });
-      this.namedExpressionManager.addSheet({
-        workbookName: toWorkbookName,
-        sheetName
-      });
-      this.workbookManager.setSheetContent({ workbookName: toWorkbookName, sheetName }, new Map(sheet.content));
-      const targetSheet = this.workbookManager.getSheet({
-        workbookName: toWorkbookName,
-        sheetName
-      });
-      if (targetSheet) {
-        targetSheet.metadata = new Map(sheet.metadata);
-        if (sheet.sheetMetadata !== undefined) {
-          targetSheet.sheetMetadata = structuredClone(sheet.sheetMetadata);
-        }
+    return this.withUndoRedoCheckpoint(() => {
+      const sourceWorkbook = this.workbookManager.getWorkbooks().get(fromWorkbookName);
+      if (!sourceWorkbook) {
+        throw new Error(`Source workbook "${fromWorkbookName}" not found`);
       }
-    }
-    const targetWorkbook = this.workbookManager.getWorkbooks().get(toWorkbookName);
-    if (targetWorkbook && sourceWorkbook.workbookMetadata !== undefined) {
-      targetWorkbook.workbookMetadata = structuredClone(sourceWorkbook.workbookMetadata);
-    }
-    const namedExpressions = this.namedExpressionManager.getNamedExpressions();
-    const sourceWorkbookExpressions = namedExpressions.workbookExpressions.get(fromWorkbookName);
-    if (sourceWorkbookExpressions) {
-      for (const [expressionName, expression] of sourceWorkbookExpressions) {
-        this.namedExpressionManager.addNamedExpression({
-          expressionName,
-          expression: expression.expression,
-          workbookName: toWorkbookName
+      if (this.workbookManager.getWorkbooks().has(toWorkbookName)) {
+        throw new Error(`Target workbook "${toWorkbookName}" already exists`);
+      }
+      this.workbookManager.addWorkbook(toWorkbookName);
+      this.namedExpressionManager.addWorkbook(toWorkbookName);
+      this.tableManager.addWorkbook(toWorkbookName);
+      for (const [sheetName, sheet] of sourceWorkbook.sheets) {
+        this.workbookManager.addSheet({
+          workbookName: toWorkbookName,
+          sheetName
+        });
+        this.namedExpressionManager.addSheet({
+          workbookName: toWorkbookName,
+          sheetName
+        });
+        this.workbookManager.setSheetContent({ workbookName: toWorkbookName, sheetName }, new Map(sheet.content));
+        const targetSheet = this.workbookManager.getSheet({
+          workbookName: toWorkbookName,
+          sheetName
         });
+        if (targetSheet) {
+          targetSheet.metadata = new Map(sheet.metadata);
+          if (sheet.sheetMetadata !== undefined) {
+            targetSheet.sheetMetadata = structuredClone(sheet.sheetMetadata);
+          }
+        }
       }
-    }
-    const sourceSheetExpressions = namedExpressions.sheetExpressions.get(fromWorkbookName);
-    if (sourceSheetExpressions) {
-      for (const [sheetName, expressions] of sourceSheetExpressions) {
-        for (const [expressionName, expression] of expressions) {
+      const targetWorkbook = this.workbookManager.getWorkbooks().get(toWorkbookName);
+      if (targetWorkbook && sourceWorkbook.workbookMetadata !== undefined) {
+        targetWorkbook.workbookMetadata = structuredClone(sourceWorkbook.workbookMetadata);
+      }
+      const namedExpressions = this.namedExpressionManager.getNamedExpressions();
+      const sourceWorkbookExpressions = namedExpressions.workbookExpressions.get(fromWorkbookName);
+      if (sourceWorkbookExpressions) {
+        for (const [expressionName, expression] of sourceWorkbookExpressions) {
           this.namedExpressionManager.addNamedExpression({
             expressionName,
             expression: expression.expression,
-            workbookName: toWorkbookName,
-            sheetName
+            workbookName: toWorkbookName
           });
         }
       }
-    }
-    const sourceTables = this.tableManager.tables.get(fromWorkbookName);
-    if (sourceTables) {
-      for (const [tableName] of sourceTables) {
-        this.tableManager.copyTable({ workbookName: fromWorkbookName, tableName }, { workbookName: toWorkbookName, tableName });
+      const sourceSheetExpressions = namedExpressions.sheetExpressions.get(fromWorkbookName);
+      if (sourceSheetExpressions) {
+        for (const [sheetName, expressions] of sourceSheetExpressions) {
+          for (const [expressionName, expression] of expressions) {
+            this.namedExpressionManager.addNamedExpression({
+              expressionName,
+              expression: expression.expression,
+              workbookName: toWorkbookName,
+              sheetName
+            });
+          }
+        }
       }
-    }
-    for (const style of this.styleManager.getAllConditionalStyles()) {
-      if (style.areas.some((area) => area.workbookName === fromWorkbookName)) {
-        this.styleManager.addConditionalStyle({
-          ...style,
-          areas: style.areas.map((area) => area.workbookName === fromWorkbookName ? { ...area, workbookName: toWorkbookName } : area)
-        });
+      const sourceTables = this.tableManager.tables.get(fromWorkbookName);
+      if (sourceTables) {
+        for (const [tableName] of sourceTables) {
+          this.tableManager.copyTable({ workbookName: fromWorkbookName, tableName }, { workbookName: toWorkbookName, tableName });
+        }
       }
-    }
-    for (const style of this.styleManager.getAllCellStyles()) {
-      if (style.areas.some((area) => area.workbookName === fromWorkbookName)) {
-        this.styleManager.addCellStyle({
-          ...style,
-          areas: style.areas.map((area) => area.workbookName === fromWorkbookName ? { ...area, workbookName: toWorkbookName } : area)
-        });
+      for (const style of this.styleManager.getAllConditionalStyles()) {
+        if (style.areas.some((area) => area.workbookName === fromWorkbookName)) {
+          this.styleManager.addConditionalStyle({
+            ...style,
+            areas: style.areas.map((area) => area.workbookName === fromWorkbookName ? { ...area, workbookName: toWorkbookName } : area)
+          });
+        }
       }
-    }
-    for (const metadata of this.rangeMetadataManager.getAllRangeMetadata()) {
-      if (metadata.areas.some((area) => area.workbookName === fromWorkbookName)) {
-        this.rangeMetadataManager.addRangeMetadata({
-          metadata: metadata.metadata,
-          areas: metadata.areas.map((area) => area.workbookName === fromWorkbookName ? { ...area, workbookName: toWorkbookName } : area)
-        });
+      for (const style of this.styleManager.getAllCellStyles()) {
+        if (style.areas.some((area) => area.workbookName === fromWorkbookName)) {
+          this.styleManager.addCellStyle({
+            ...style,
+            areas: style.areas.map((area) => area.workbookName === fromWorkbookName ? { ...area, workbookName: toWorkbookName } : area)
+          });
+        }
       }
-    }
-    this.workbookManager.updateFormulasForWorkbook(toWorkbookName, (formula) => import_workbook_renamer.renameWorkbookInFormula({
-      formula,
-      oldWorkbookName: fromWorkbookName,
-      newWorkbookName: toWorkbookName
-    }));
-    this.emitMutation({
-      touchedCells: [],
-      resourceKeys: [import_resource_keys.getWorkbookResourceKey(toWorkbookName)]
+      for (const metadata of this.rangeMetadataManager.getAllRangeMetadata()) {
+        if (metadata.areas.some((area) => area.workbookName === fromWorkbookName)) {
+          this.rangeMetadataManager.addRangeMetadata({
+            metadata: metadata.metadata,
+            areas: metadata.areas.map((area) => area.workbookName === fromWorkbookName ? { ...area, workbookName: toWorkbookName } : area)
+          });
+        }
+      }
+      this.workbookManager.updateFormulasForWorkbook(toWorkbookName, (formula) => import_workbook_renamer.renameWorkbookInFormula({
+        formula,
+        oldWorkbookName: fromWorkbookName,
+        newWorkbookName: toWorkbookName
+      }));
+      this.emitMutation({
+        touchedCells: [],
+        resourceKeys: [import_resource_keys.getWorkbookResourceKey(toWorkbookName)]
+      });
     });
   }
   renameWorkbook(opts) {
-    const oldResourceKeys = this.getWorkbookResourceKeys(opts.workbookName);
-    this.workbookManager.renameWorkbook(opts);
-    this.namedExpressionManager.renameWorkbook(opts);
-    this.tableManager.updateTablesForWorkbookRename(opts);
-    this.styleManager.updateWorkbookName(opts.workbookName, opts.newWorkbookName);
-    this.rangeMetadataManager.updateWorkbookName(opts.workbookName, opts.newWorkbookName);
-    const changedCells = this.workbookManager.updateAllFormulas((formula) => import_workbook_renamer.renameWorkbookInFormula({
-      formula,
-      oldWorkbookName: opts.workbookName,
-      newWorkbookName: opts.newWorkbookName
-    }));
-    this.referenceManager.updateWorkbookName(opts.workbookName, opts.newWorkbookName);
-    this.emitMutation({
-      touchedCells: import_mutation_invalidation.buildFormulaTouchedCells(changedCells),
-      resourceKeys: Array.from(new Set([
-        ...oldResourceKeys,
-        ...this.getWorkbookResourceKeys(opts.newWorkbookName)
-      ]))
+    return this.withUndoRedoCheckpoint(() => {
+      const oldResourceKeys = this.getWorkbookResourceKeys(opts.workbookName);
+      this.workbookManager.renameWorkbook(opts);
+      this.namedExpressionManager.renameWorkbook(opts);
+      this.tableManager.updateTablesForWorkbookRename(opts);
+      this.styleManager.updateWorkbookName(opts.workbookName, opts.newWorkbookName);
+      this.rangeMetadataManager.updateWorkbookName(opts.workbookName, opts.newWorkbookName);
+      const changedCells = this.workbookManager.updateAllFormulas((formula) => import_workbook_renamer.renameWorkbookInFormula({
+        formula,
+        oldWorkbookName: opts.workbookName,
+        newWorkbookName: opts.newWorkbookName
+      }));
+      this.referenceManager.updateWorkbookName(opts.workbookName, opts.newWorkbookName);
+      this.emitMutation({
+        touchedCells: import_mutation_invalidation.buildFormulaTouchedCells(changedCells),
+        resourceKeys: Array.from(new Set([
+          ...oldResourceKeys,
+          ...this.getWorkbookResourceKeys(opts.newWorkbookName)
+        ]))
+      });
     });
   }
   getWorkbooks() {
     return this.workbookManager.getWorkbooks();
   }
   setSheetContent(opts, content) {
-    const previousContent = this.getExistingSheetContent(opts);
-    this.workbookManager.setSheetContent(opts, content);
-    this.emitMutation({
-      touchedCells: import_mutation_invalidation.buildSheetContentTouchedCells(opts, previousContent, content),
-      resourceKeys: []
+    return this.withUndoRedoCheckpoint(() => {
+      const previousContent = this.getExistingSheetContent(opts);
+      this.workbookManager.setSheetContent(opts, content);
+      this.emitMutation({
+        touchedCells: import_mutation_invalidation.buildSheetContentTouchedCells(opts, previousContent, content),
+        resourceKeys: []
+      });
     });
   }
   setCellContent(address, content) {
-    const previousValue = this.workbookManager.getCellContent(address);
-    this.workbookManager.setCellContent(address, content);
-    this.emitMutation({
-      touchedCells: import_mutation_invalidation.buildTouchedCells([
-        {
-          address,
-          before: previousValue,
-          after: content
-        }
-      ]),
-      resourceKeys: []
+    return this.withUndoRedoCheckpoint(() => {
+      const previousValue = this.workbookManager.getCellContent(address);
+      this.workbookManager.setCellContent(address, content);
+      this.emitMutation({
+        touchedCells: import_mutation_invalidation.buildTouchedCells([
+          {
+            address,
+            before: previousValue,
+            after: content
+          }
+        ]),
+        resourceKeys: []
+      });
     });
   }
   autoFill(opts, seedRange, fillRanges, direction) {
-    const touchedAddresses = this.dedupeAddresses(fillRanges.flatMap((range) => import_mutation_invalidation.getFiniteRangeAddresses({
-      workbookName: opts.workbookName,
-      sheetName: opts.sheetName,
-      range
-    })));
-    const before = import_mutation_invalidation.captureCellContents(this.workbookManager, touchedAddresses);
-    this.autoFillManager.fill(opts, seedRange, fillRanges, direction);
-    const after = import_mutation_invalidation.captureCellContents(this.workbookManager, touchedAddresses);
-    this.emitMutation({
-      touchedCells: import_mutation_invalidation.buildTouchedCells(touchedAddresses.map((address) => ({
-        address,
-        before: before.get(import_mutation_invalidation.getMutationAddressKey(address)),
-        after: after.get(import_mutation_invalidation.getMutationAddressKey(address))
-      }))),
-      resourceKeys: []
+    return this.withUndoRedoCheckpoint(() => {
+      const touchedAddresses = this.dedupeAddresses(fillRanges.flatMap((range) => import_mutation_invalidation.getFiniteRangeAddresses({
+        workbookName: opts.workbookName,
+        sheetName: opts.sheetName,
+        range
+      })));
+      const before = import_mutation_invalidation.captureCellContents(this.workbookManager, touchedAddresses);
+      this.autoFillManager.fill(opts, seedRange, fillRanges, direction);
+      const after = import_mutation_invalidation.captureCellContents(this.workbookManager, touchedAddresses);
+      this.emitMutation({
+        touchedCells: import_mutation_invalidation.buildTouchedCells(touchedAddresses.map((address) => ({
+          address,
+          before: before.get(import_mutation_invalidation.getMutationAddressKey(address)),
+          after: after.get(import_mutation_invalidation.getMutationAddressKey(address))
+        }))),
+        resourceKeys: []
+      });
     });
   }
   clearSpreadsheetRange(address) {
-    const clearedCells = Array.from(this.workbookManager.iterateCellsInRange(address));
-    const before = import_mutation_invalidation.captureCellContents(this.workbookManager, clearedCells);
-    this.workbookManager.clearSpreadsheetRange(address);
-    this.emitMutation({
-      touchedCells: import_mutation_invalidation.buildTouchedCells(clearedCells.map((cellAddress) => ({
-        address: cellAddress,
-        before: before.get(import_mutation_invalidation.getMutationAddressKey(cellAddress)),
-        after: undefined
-      }))),
-      resourceKeys: []
+    return this.withUndoRedoCheckpoint(() => {
+      const clearedCells = Array.from(this.workbookManager.iterateCellsInRange(address));
+      const before = import_mutation_invalidation.captureCellContents(this.workbookManager, clearedCells);
+      this.workbookManager.clearSpreadsheetRange(address);
+      this.emitMutation({
+        touchedCells: import_mutation_invalidation.buildTouchedCells(clearedCells.map((cellAddress) => ({
+          address: cellAddress,
+          before: before.get(import_mutation_invalidation.getMutationAddressKey(cellAddress)),
+          after: undefined
+        }))),
+        resourceKeys: []
+      });
     });
   }
   getState() {
@@ -1014,6 +1166,17 @@ class FormulaEngine {
   }
   buildSerializedSnapshot() {
     const evaluationSnapshots = this.dependencyManager.toSnapshot(this.evaluationManager);
+    const historySnapshot = this.buildHistorySnapshot();
+    return {
+      version: import_engine_snapshot.ENGINE_SNAPSHOT_VERSION,
+      managers: {
+        ...historySnapshot.managers,
+        dependency: evaluationSnapshots.dependency,
+        cache: evaluationSnapshots.cache
+      }
+    };
+  }
+  buildHistorySnapshot() {
     const workbookSnapshot = this.workbookManager.toSnapshot();
     return {
       version: import_engine_snapshot.ENGINE_SNAPSHOT_VERSION,
@@ -1023,12 +1186,13 @@ class FormulaEngine {
         table: this.tableManager.toSnapshot(),
         style: this.styleManager.toSnapshot(),
         rangeMetadata: this.rangeMetadataManager.toSnapshot(),
-        reference: this.referenceManager.toSnapshot(),
-        dependency: evaluationSnapshots.dependency,
-        cache: evaluationSnapshots.cache
+        reference: this.referenceManager.toSnapshot()
       }
     };
   }
+  serializeHistorySnapshot() {
+    return import_map_serializer.serialize(this.buildHistorySnapshot());
+  }
   buildNamedExpressionSnapshot(workbookSnapshot) {
     const namedExpressions = this.namedExpressionManager.toSnapshot();
     const workbookExpressions = new Map;
@@ -1052,14 +1216,15 @@ class FormulaEngine {
   serializeEngine() {
     return import_map_serializer.serialize(this.buildSerializedSnapshot());
   }
-  resetToSerializedEngine(data) {
-    const deserialized = import_map_serializer.deserialize(data);
-    if (!deserialized || typeof deserialized !== "object" || !("version" in deserialized) || deserialized.version !== import_engine_snapshot.ENGINE_SNAPSHOT_VERSION || !deserialized.managers) {
+  assertSupportedSnapshot(snapshot) {
+    if (!snapshot || typeof snapshot !== "object" || !("version" in snapshot) || snapshot.version !== import_engine_snapshot.ENGINE_SNAPSHOT_VERSION || !snapshot.managers) {
       throw new Error(`Unsupported serialized engine format. Expected EngineSnapshot version ${import_engine_snapshot.ENGINE_SNAPSHOT_VERSION}.`);
     }
+  }
+  restoreDataManagersFromSnapshot(managers) {
     this.namedExpressionManager.clear();
-    this.workbookManager.restoreFromSnapshot(deserialized.managers.workbook);
-    deserialized.managers.workbook.forEach((workbook) => {
+    this.workbookManager.restoreFromSnapshot(managers.workbook);
+    managers.workbook.forEach((workbook) => {
       this.namedExpressionManager.addWorkbook(workbook.name);
       workbook.sheets.forEach((sheet) => {
         this.namedExpressionManager.addSheet({
@@ -1068,17 +1233,29 @@ class FormulaEngine {
         });
       });
     });
-    this.namedExpressionManager.restoreFromSnapshot(deserialized.managers.namedExpression);
-    this.tableManager.restoreFromSnapshot(deserialized.managers.table);
-    this.styleManager.restoreFromSnapshot(deserialized.managers.style);
-    this.rangeMetadataManager.restoreFromSnapshot(deserialized.managers.rangeMetadata);
-    this.referenceManager.restoreFromSnapshot(deserialized.managers.reference);
+    this.namedExpressionManager.restoreFromSnapshot(managers.namedExpression);
+    this.tableManager.restoreFromSnapshot(managers.table);
+    this.styleManager.restoreFromSnapshot(managers.style);
+    this.rangeMetadataManager.restoreFromSnapshot(managers.rangeMetadata);
+    this.referenceManager.restoreFromSnapshot(managers.reference);
+  }
+  restoreHistorySnapshot(data) {
+    const deserialized = import_map_serializer.deserialize(data);
+    this.assertSupportedSnapshot(deserialized);
+    this.restoreDataManagersFromSnapshot(deserialized.managers);
+    this.evaluationManager.clearEvaluationCache();
+  }
+  resetToSerializedEngine(data) {
+    const deserialized = import_map_serializer.deserialize(data);
+    this.assertSupportedSnapshot(deserialized);
+    this.restoreDataManagersFromSnapshot(deserialized.managers);
     this.dependencyManager.restoreFromSnapshot({
       dependency: deserialized.managers.dependency,
       cache: deserialized.managers.cache
     }, this.evaluationManager);
+    this.clearUndoRedoHistory();
     this.eventManager.emitUpdate();
   }
 }
 
-//# debugId=E6611E5B614618F964756E2164756E21
+//# debugId=618331A008C422E664756E2164756E21