@ricsam/formula-engine 0.2.1 → 0.2.3

package/dist/cjs/core/managers/dependency-manager.cjs

@@ -2,27 +2,37 @@ var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __moduleCache = /* @__PURE__ */ new WeakMap;
+function __accessProp(key) {
+  return this[key];
+}
 var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
   if (entry)
     return entry;
   entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    }));
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
   __moduleCache.set(from, entry);
   return entry;
 };
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 
@@ -32,6 +42,7 @@ __export(exports_dependency_manager, {
   DependencyManager: () => DependencyManager
 });
 module.exports = __toCommonJS(exports_dependency_manager);
+var import_engine_snapshot = require("../engine-snapshot.cjs");
 var import_evaluation_context = require("../../evaluator/evaluation-context.cjs");
 var import_utils = require("../utils.cjs");
 var import_ast_evaluation_node = require("../../evaluator/dependency-nodes/ast-evaluation-node.cjs");
@@ -42,6 +53,7 @@ var import_range_evaluation_node = require("../../evaluator/range-evaluation-nod
 var import_formatter = require("../../parser/formatter.cjs");
 var import_virtual_cell_value_node = require("../../evaluator/dependency-nodes/virtual-cell-value-node.cjs");
 var import_parser = require("../../parser/parser.cjs");
+var import_resource_dependency_node = require("../../evaluator/dependency-nodes/resource-dependency-node.cjs");
 
 class DependencyManager {
   cacheManager;
@@ -52,10 +64,175 @@ class DependencyManager {
   virtualCellValueNodes = new Map;
   _spilledValues = new Map;
   ranges = new Map;
+  resourceNodes = new Map;
+  hardDependents = new Map;
+  frontierDependents = new Map;
+  registeredDependencies = new Map;
+  coverageWatchersBySheet = new Map;
+  frontierWatchersBySheet = new Map;
   constructor(cacheManager, workbookManager) {
     this.cacheManager = cacheManager;
     this.workbookManager = workbookManager;
   }
+  getSheetWatcherKey(address) {
+    return `${address.workbookName}:${address.sheetName}`;
+  }
+  addReverseEdge(map, dependency, dependent) {
+    const dependents = map.get(dependency) ?? new Set;
+    dependents.add(dependent);
+    map.set(dependency, dependents);
+  }
+  removeReverseEdge(map, dependency, dependent) {
+    const dependents = map.get(dependency);
+    if (!dependents) {
+      return;
+    }
+    dependents.delete(dependent);
+    if (dependents.size === 0) {
+      map.delete(dependency);
+    }
+  }
+  getWatcherRange(node) {
+    return node instanceof import_range_evaluation_node.RangeEvaluationNode ? node.address : node.getFrontierRange();
+  }
+  addWatcher(map, node) {
+    const watcherKey = this.getSheetWatcherKey(this.getWatcherRange(node));
+    const watchers = map.get(watcherKey) ?? new Set;
+    watchers.add(node);
+    map.set(watcherKey, watchers);
+  }
+  removeWatcher(map, node) {
+    const watcherKey = this.getSheetWatcherKey(this.getWatcherRange(node));
+    const watchers = map.get(watcherKey);
+    if (!watchers) {
+      return;
+    }
+    watchers.delete(node);
+    if (watchers.size === 0) {
+      map.delete(watcherKey);
+    }
+  }
+  registerWatcherNode(node) {
+    this.addWatcher(this.coverageWatchersBySheet, node);
+    this.addWatcher(this.frontierWatchersBySheet, node);
+  }
+  unregisterWatcherNode(node) {
+    this.removeWatcher(this.coverageWatchersBySheet, node);
+    this.removeWatcher(this.frontierWatchersBySheet, node);
+  }
+  isWatcherNodeResolved(node) {
+    return node instanceof import_range_evaluation_node.RangeEvaluationNode ? node.result.type !== "awaiting-evaluation" : node.evaluationResult.type !== "awaiting-evaluation";
+  }
+  getAllPersistentNodes() {
+    const astNodes = [];
+    for (const astEntries of this.asts.values()) {
+      for (const astEntry of astEntries.entries.values()) {
+        astNodes.push(astEntry.evalNode);
+      }
+    }
+    return [
+      ...this.cellNodes.values(),
+      ...this.spillMetaNodes.values(),
+      ...this.emptyCells.values(),
+      ...this.ranges.values(),
+      ...this.resourceNodes.values(),
+      ...astNodes
+    ];
+  }
+  getExistingCellValueNode(nodeKey) {
+    return this.cellNodes.get(nodeKey);
+  }
+  getExistingSpillMetaNode(nodeKey) {
+    return this.spillMetaNodes.get(nodeKey);
+  }
+  getExistingEmptyCellNode(nodeKey) {
+    return this.emptyCells.get(nodeKey);
+  }
+  collectExistingNodesForCell(address) {
+    const baseKey = import_utils.cellAddressToKey(address);
+    const nodes = [
+      this.getExistingCellValueNode(baseKey),
+      this.getExistingEmptyCellNode(baseKey.replace(/^cell-value:/, "empty:")),
+      this.getExistingSpillMetaNode(baseKey.replace(/^cell-value:/, "spill-meta:"))
+    ];
+    return nodes.filter((node) => node !== undefined);
+  }
+  collectSpillOriginsAffectingCell(address) {
+    const affected = new Set;
+    for (const [spillOriginKey, spilledValue] of this._spilledValues.entries()) {
+      if (spilledValue.origin.workbookName !== address.workbookName || spilledValue.origin.sheetName !== address.sheetName) {
+        continue;
+      }
+      const isOriginCell = spilledValue.origin.colIndex === address.colIndex && spilledValue.origin.rowIndex === address.rowIndex;
+      if (isOriginCell || !import_utils.isCellInRange(address, spilledValue.spillOnto)) {
+        continue;
+      }
+      const cellValueNode = this.cellNodes.get(`cell-value:${spillOriginKey}`);
+      if (cellValueNode) {
+        affected.add(cellValueNode);
+      }
+      const spillMetaNode = this.spillMetaNodes.get(`spill-meta:${spillOriginKey}`);
+      if (spillMetaNode) {
+        affected.add(spillMetaNode);
+      }
+    }
+    return affected;
+  }
+  getLinkedSpillMetaNode(node) {
+    if (node instanceof import_spill_meta_node.SpillMetaNode) {
+      return node;
+    }
+    return this.spillMetaNodes.get(node.key.replace(/^cell-value:/, "spill-meta:"));
+  }
+  getLinkedCellValueNode(node) {
+    if (node instanceof import_cell_value_node.CellValueNode) {
+      return node;
+    }
+    return this.cellNodes.get(node.key.replace(/^spill-meta:/, "cell-value:"));
+  }
+  registerNode(node) {
+    this.unregisterNode(node);
+    const hardDependencies = new Set(node.getDependencies());
+    const frontierDependencies = node instanceof import_range_evaluation_node.RangeEvaluationNode || node instanceof import_empty_cell_evaluation_node.EmptyCellEvaluationNode ? new Set(node.getFrontierDependencies()) : new Set;
+    this.registeredDependencies.set(node, {
+      hard: hardDependencies,
+      frontier: frontierDependencies
+    });
+    for (const dependency of hardDependencies) {
+      this.addReverseEdge(this.hardDependents, dependency, node);
+    }
+    for (const dependency of frontierDependencies) {
+      this.addReverseEdge(this.frontierDependents, dependency, node);
+    }
+    if ((node instanceof import_range_evaluation_node.RangeEvaluationNode || node instanceof import_empty_cell_evaluation_node.EmptyCellEvaluationNode) && this.isWatcherNodeResolved(node)) {
+      this.registerWatcherNode(node);
+    }
+  }
+  unregisterNode(node) {
+    const registration = this.registeredDependencies.get(node);
+    if (registration) {
+      for (const dependency of registration.hard) {
+        this.removeReverseEdge(this.hardDependents, dependency, node);
+      }
+      for (const dependency of registration.frontier) {
+        this.removeReverseEdge(this.frontierDependents, dependency, node);
+      }
+      this.registeredDependencies.delete(node);
+    }
+    if (node instanceof import_range_evaluation_node.RangeEvaluationNode || node instanceof import_empty_cell_evaluation_node.EmptyCellEvaluationNode) {
+      this.unregisterWatcherNode(node);
+    }
+  }
+  rebuildRuntimeIndexes() {
+    this.hardDependents.clear();
+    this.frontierDependents.clear();
+    this.registeredDependencies.clear();
+    this.coverageWatchersBySheet.clear();
+    this.frontierWatchersBySheet.clear();
+    for (const node of this.getAllPersistentNodes()) {
+      this.registerNode(node);
+    }
+  }
   get spilledValues() {
     return this._spilledValues.values();
   }
@@ -109,7 +286,272 @@ class DependencyManager {
     this.asts.clear();
     this.spillMetaNodes.clear();
     this.ranges.clear();
+    this.resourceNodes.clear();
     this._spilledValues.clear();
+    this.hardDependents.clear();
+    this.frontierDependents.clear();
+    this.registeredDependencies.clear();
+    this.coverageWatchersBySheet.clear();
+    this.frontierWatchersBySheet.clear();
+  }
+  toSnapshot(evaluationManager) {
+    const isNodeSnapshotEligible = (node) => {
+      if (node instanceof import_resource_dependency_node.ResourceDependencyNode) {
+        return true;
+      }
+      if (node instanceof import_range_evaluation_node.RangeEvaluationNode) {
+        return node.result.type !== "awaiting-evaluation";
+      }
+      return node.evaluationResult.type !== "awaiting-evaluation";
+    };
+    const astNodes = new Set;
+    for (const astEntries of this.asts.values()) {
+      for (const { evalNode } of astEntries.entries.values()) {
+        if (isNodeSnapshotEligible(evalNode)) {
+          astNodes.add(evalNode);
+        }
+      }
+    }
+    const resolvedNodes = [
+      ...Array.from(this.cellNodes.values()).filter(isNodeSnapshotEligible),
+      ...Array.from(this.spillMetaNodes.values()).filter(isNodeSnapshotEligible),
+      ...Array.from(this.emptyCells.values()).filter(isNodeSnapshotEligible),
+      ...Array.from(this.ranges.values()).filter(isNodeSnapshotEligible),
+      ...Array.from(this.resourceNodes.values()).filter(isNodeSnapshotEligible),
+      ...Array.from(astNodes.values())
+    ];
+    const allNodeSnapshotIds = new Map;
+    for (const node of resolvedNodes) {
+      if (node instanceof import_ast_evaluation_node.AstEvaluationNode) {
+        allNodeSnapshotIds.set(node, import_engine_snapshot.getAstNodeSnapshotId(node));
+      } else {
+        allNodeSnapshotIds.set(node, node.key);
+      }
+    }
+    const getAllNodeSnapshotId = (node) => {
+      const snapshotId = allNodeSnapshotIds.get(node);
+      if (!snapshotId) {
+        throw new Error(`Missing snapshot id for dependency node ${node.key}`);
+      }
+      return snapshotId;
+    };
+    const nodeSnapshots = [];
+    const includedSnapshotIds = new Set;
+    for (const node of resolvedNodes) {
+      const snapshot = this.serializeNodeSnapshot(node, evaluationManager, getAllNodeSnapshotId, allNodeSnapshotIds);
+      if (!snapshot) {
+        continue;
+      }
+      includedSnapshotIds.add(snapshot.snapshotId);
+      nodeSnapshots.push(snapshot);
+    }
+    const filteredNodeSnapshots = nodeSnapshots.map((snapshot) => {
+      const dependencies = snapshot.dependencies.filter((dependency2) => includedSnapshotIds.has(dependency2));
+      if (snapshot.kind === "cell-value") {
+        return {
+          ...snapshot,
+          dependencies,
+          spillMetaSnapshotId: snapshot.spillMetaSnapshotId && includedSnapshotIds.has(snapshot.spillMetaSnapshotId) ? snapshot.spillMetaSnapshotId : undefined
+        };
+      }
+      return {
+        ...snapshot,
+        dependencies
+      };
+    });
+    const dependency = {
+      nodes: filteredNodeSnapshots,
+      spilledValues: Array.from(this._spilledValues.entries())
+    };
+    const cache = this.cacheManager.toSnapshot((node) => {
+      const snapshotId = allNodeSnapshotIds.get(node);
+      if (!snapshotId || !includedSnapshotIds.has(snapshotId)) {
+        return;
+      }
+      return snapshotId;
+    });
+    return { dependency, cache };
+  }
+  restoreFromSnapshot(snapshots, evaluationManager) {
+    this.clearEvaluationCache();
+    const nodesBySnapshotId = new Map;
+    for (const snapshot of snapshots.dependency.nodes) {
+      const node = this.createNodeFromSnapshot(snapshot);
+      nodesBySnapshotId.set(snapshot.snapshotId, node);
+    }
+    const resolveNodeSnapshotId = (snapshotId) => nodesBySnapshotId.get(snapshotId);
+    const resolveRequiredNodeSnapshotId = (snapshotId) => {
+      const node = resolveNodeSnapshotId(snapshotId);
+      if (!node) {
+        throw new Error(`Unknown node snapshot id: ${snapshotId}`);
+      }
+      return node;
+    };
+    for (const snapshot of snapshots.dependency.nodes) {
+      const dependencies = new Set(snapshot.dependencies.map(resolveNodeSnapshotId).filter((node2) => node2 !== undefined));
+      if (snapshot.kind === "cell-value") {
+        const node2 = nodesBySnapshotId.get(snapshot.snapshotId);
+        node2.restoreResolvedSnapshot({
+          dependencies,
+          evaluationResult: evaluationManager.deserializeSingleEvaluationResultSnapshot(snapshot.evaluationResult, resolveRequiredNodeSnapshotId)
+        });
+        if (snapshot.spillMetaSnapshotId) {
+          const spillMetaNode = resolveNodeSnapshotId(snapshot.spillMetaSnapshotId);
+          if (spillMetaNode instanceof import_spill_meta_node.SpillMetaNode) {
+            node2.setSpillMetaNode(spillMetaNode);
+          }
+        }
+        continue;
+      }
+      if (snapshot.kind === "spill-meta") {
+        const node2 = nodesBySnapshotId.get(snapshot.snapshotId);
+        node2.restoreResolvedSnapshot({
+          dependencies,
+          evaluationResult: evaluationManager.deserializeSpillMetaEvaluationResultSnapshot(snapshot.evaluationResult, resolveRequiredNodeSnapshotId)
+        });
+        continue;
+      }
+      if (snapshot.kind === "empty") {
+        const node2 = nodesBySnapshotId.get(snapshot.snapshotId);
+        node2.restoreResolvedSnapshot({
+          dependencies,
+          evaluationResult: evaluationManager.deserializeSingleEvaluationResultSnapshot(snapshot.evaluationResult, resolveRequiredNodeSnapshotId)
+        });
+        continue;
+      }
+      if (snapshot.kind === "range") {
+        const node2 = nodesBySnapshotId.get(snapshot.snapshotId);
+        node2.restoreResolvedSnapshot({
+          dependencies,
+          result: evaluationManager.deserializeEvaluateAllCellsResultSnapshot(snapshot.result, resolveRequiredNodeSnapshotId)
+        });
+        continue;
+      }
+      if (snapshot.kind === "resource") {
+        continue;
+      }
+      const node = nodesBySnapshotId.get(snapshot.snapshotId);
+      node.restoreResolvedSnapshot({
+        dependencies,
+        evaluationResult: evaluationManager.deserializeFunctionEvaluationResultSnapshot(snapshot.evaluationResult, resolveRequiredNodeSnapshotId)
+      });
+      this.saveAstNode(node, snapshot.contextDependency);
+    }
+    this._spilledValues = new Map(snapshots.dependency.spilledValues);
+    this.rebuildRuntimeIndexes();
+    this.cacheManager.restoreFromSnapshot(snapshots.cache, resolveNodeSnapshotId);
+  }
+  serializeNodeSnapshot(node, evaluationManager, getNodeSnapshotId, allNodeSnapshotIds) {
+    const snapshotId = getNodeSnapshotId(node);
+    const dependencies = Array.from(node.getDependencies()).map((dependency) => allNodeSnapshotIds.get(dependency)).filter((dependency) => dependency !== undefined);
+    if (node instanceof import_cell_value_node.CellValueNode) {
+      const evaluationResult2 = evaluationManager.serializeSingleEvaluationResultSnapshot(node.evaluationResult, getNodeSnapshotId);
+      if (!evaluationResult2) {
+        return;
+      }
+      return {
+        kind: "cell-value",
+        snapshotId,
+        key: node.key,
+        dependencies,
+        evaluationResult: evaluationResult2,
+        spillMetaSnapshotId: node.spillMeta ? allNodeSnapshotIds.get(node.spillMeta) : undefined
+      };
+    }
+    if (node instanceof import_spill_meta_node.SpillMetaNode) {
+      const evaluationResult2 = evaluationManager.serializeSpillMetaEvaluationResultSnapshot(node.evaluationResult, {
+        sourceNode: node,
+        getNodeSnapshotId
+      });
+      if (!evaluationResult2) {
+        return;
+      }
+      return {
+        kind: "spill-meta",
+        snapshotId,
+        key: node.key,
+        dependencies,
+        evaluationResult: evaluationResult2
+      };
+    }
+    if (node instanceof import_empty_cell_evaluation_node.EmptyCellEvaluationNode) {
+      const evaluationResult2 = evaluationManager.serializeSingleEvaluationResultSnapshot(node.evaluationResult, getNodeSnapshotId);
+      if (!evaluationResult2) {
+        return;
+      }
+      return {
+        kind: "empty",
+        snapshotId,
+        key: node.key,
+        dependencies,
+        evaluationResult: evaluationResult2
+      };
+    }
+    if (node instanceof import_range_evaluation_node.RangeEvaluationNode) {
+      const result = evaluationManager.serializeEvaluateAllCellsResultSnapshot(node.result, getNodeSnapshotId);
+      if (!result) {
+        return;
+      }
+      return {
+        kind: "range",
+        snapshotId,
+        key: node.key,
+        dependencies,
+        result
+      };
+    }
+    if (node instanceof import_resource_dependency_node.ResourceDependencyNode) {
+      return {
+        kind: "resource",
+        snapshotId,
+        key: node.key,
+        dependencies
+      };
+    }
+    const evaluationResult = evaluationManager.serializeFunctionEvaluationResultSnapshot(node.evaluationResult, {
+      sourceNode: node,
+      getNodeSnapshotId
+    });
+    if (!evaluationResult) {
+      return;
+    }
+    return {
+      kind: "ast",
+      snapshotId,
+      key: node.key,
+      dependencies,
+      contextDependency: node.getContextDependency(),
+      evaluationResult
+    };
+  }
+  createNodeFromSnapshot(snapshot) {
+    if (snapshot.kind === "cell-value") {
+      const node2 = new import_cell_value_node.CellValueNode(snapshot.key);
+      this.cellNodes.set(snapshot.key, node2);
+      return node2;
+    }
+    if (snapshot.kind === "spill-meta") {
+      const node2 = new import_spill_meta_node.SpillMetaNode(snapshot.key);
+      this.spillMetaNodes.set(snapshot.key, node2);
+      return node2;
+    }
+    if (snapshot.kind === "empty") {
+      const node2 = new import_empty_cell_evaluation_node.EmptyCellEvaluationNode(snapshot.key, this, this.workbookManager, { skipInitialBuild: true });
+      this.emptyCells.set(snapshot.key, node2);
+      return node2;
+    }
+    if (snapshot.kind === "range") {
+      const node2 = new import_range_evaluation_node.RangeEvaluationNode(snapshot.key, this, this.workbookManager, { skipInitialBuild: true });
+      this.ranges.set(snapshot.key, node2);
+      return node2;
+    }
+    if (snapshot.kind === "resource") {
+      const node2 = new import_resource_dependency_node.ResourceDependencyNode(snapshot.key);
+      this.resourceNodes.set(snapshot.key, node2);
+      return node2;
+    }
+    const node = new import_ast_evaluation_node.AstEvaluationNode(import_parser.parseFormula(snapshot.key.slice(4)), snapshot.contextDependency);
+    return node;
   }
   setSpilledValue(nodeKey, spilledValue) {
     this._spilledValues.set(nodeKey.replace(/^[^:]+:/, ""), spilledValue);
@@ -117,6 +559,9 @@ class DependencyManager {
   getSpilledValue(nodeKey) {
     return this._spilledValues.get(nodeKey.replace(/^[^:]+:/, ""));
   }
+  deleteSpilledValue(nodeKey) {
+    this._spilledValues.delete(nodeKey.replace(/^[^:]+:/, ""));
+  }
   getEmptyCellNode(nodeKey) {
     if (!nodeKey.startsWith("empty:")) {
       throw new Error("Invalid empty cell node key: " + nodeKey);
@@ -150,6 +595,14 @@ class DependencyManager {
     }
     return this.cellNodes.get(nodeKey);
   }
+  getResourceNode(resourceKey) {
+    if (!this.resourceNodes.has(resourceKey)) {
+      const node = new import_resource_dependency_node.ResourceDependencyNode(resourceKey);
+      this.resourceNodes.set(resourceKey, node);
+      return node;
+    }
+    return this.resourceNodes.get(resourceKey);
+  }
   getCellValueOrEmptyCellNode(nodeKey) {
     const cellAddress = import_utils.keyToCellAddress(nodeKey);
     const emptyKey = nodeKey.replace(/^[^:]+:/, "empty:");
@@ -236,6 +689,241 @@ class DependencyManager {
       });
     }
   }
+  isFiniteEndAfter(value, end) {
+    return end.type === "infinity" || value < end.value;
+  }
+  doesAddressAffectWatcherFrontier(address, watcher) {
+    const watcherRange = this.getWatcherRange(watcher).range;
+    const rowWithinRange = address.rowIndex >= watcherRange.start.row && (watcherRange.end.row.type === "infinity" || address.rowIndex <= watcherRange.end.row.value);
+    const colWithinRange = address.colIndex >= watcherRange.start.col && (watcherRange.end.col.type === "infinity" || address.colIndex <= watcherRange.end.col.value);
+    const canReachFurtherRows = this.isFiniteEndAfter(address.rowIndex, watcherRange.end.row);
+    const canReachFurtherCols = this.isFiniteEndAfter(address.colIndex, watcherRange.end.col);
+    return rowWithinRange && canReachFurtherCols || colWithinRange && canReachFurtherRows || canReachFurtherRows && canReachFurtherCols;
+  }
+  collectCoverageWatchers(address) {
+    const watchers = this.coverageWatchersBySheet.get(this.getSheetWatcherKey(address)) ?? new Set;
+    const affected = new Set;
+    for (const watcher of watchers) {
+      if (import_utils.isCellInRange(address, this.getWatcherRange(watcher).range)) {
+        affected.add(watcher);
+      }
+    }
+    return affected;
+  }
+  collectFrontierWatchers(address) {
+    const watchers = this.frontierWatchersBySheet.get(this.getSheetWatcherKey(address)) ?? new Set;
+    const affected = new Set;
+    for (const watcher of watchers) {
+      if (this.doesAddressAffectWatcherFrontier(address, watcher)) {
+        affected.add(watcher);
+      }
+    }
+    return affected;
+  }
+  collectWatchersIntersectingRange(address) {
+    const watchers = this.coverageWatchersBySheet.get(this.getSheetWatcherKey(address)) ?? new Set;
+    const affected = new Set;
+    for (const watcher of watchers) {
+      if (import_utils.checkRangeIntersection(address.range, this.getWatcherRange(watcher).range)) {
+        affected.add(watcher);
+      }
+    }
+    return affected;
+  }
+  getNodeDependents(node) {
+    return (this.hardDependents.get(node) ?? new Set).union(this.frontierDependents.get(node) ?? new Set);
+  }
+  collectInvalidationExtras(node) {
+    const extras = new Set;
+    if (node instanceof import_cell_value_node.CellValueNode || node instanceof import_spill_meta_node.SpillMetaNode) {
+      const spillMetaNode = this.getLinkedSpillMetaNode(node);
+      if (spillMetaNode) {
+        extras.add(spillMetaNode);
+      }
+      const cellNode = this.getLinkedCellValueNode(node);
+      if (cellNode) {
+        extras.add(cellNode);
+      }
+      const spill = this.getSpilledValue(node.key);
+      if (spill) {
+        for (const watcher of this.collectWatchersIntersectingRange({
+          workbookName: spill.origin.workbookName,
+          sheetName: spill.origin.sheetName,
+          range: spill.spillOnto
+        })) {
+          extras.add(watcher);
+        }
+      }
+      const cellAddress = node.cellAddress;
+      for (const watcher of this.collectCoverageWatchers(cellAddress)) {
+        extras.add(watcher);
+      }
+      for (const watcher of this.collectFrontierWatchers(cellAddress)) {
+        extras.add(watcher);
+      }
+    }
+    return extras;
+  }
+  invalidateNodeState(node, invalidatedKeys) {
+    this.unregisterNode(node);
+    invalidatedKeys.add(node.key);
+    if (node instanceof import_cell_value_node.CellValueNode) {
+      node.clearSpillMetaNode();
+      this.deleteSpilledValue(node.key);
+      node.invalidate();
+      return;
+    }
+    if (node instanceof import_spill_meta_node.SpillMetaNode) {
+      this.deleteSpilledValue(node.key);
+      this.getLinkedCellValueNode(node)?.clearSpillMetaNode();
+      node.invalidate();
+      return;
+    }
+    if (node instanceof import_empty_cell_evaluation_node.EmptyCellEvaluationNode || node instanceof import_range_evaluation_node.RangeEvaluationNode || node instanceof import_ast_evaluation_node.AstEvaluationNode) {
+      node.invalidate();
+      return;
+    }
+    if (node instanceof import_resource_dependency_node.ResourceDependencyNode) {
+      return;
+    }
+  }
+  isResourceNodeInRemovedScope(resourceKey, scope) {
+    if (scope.type === "workbook") {
+      return resourceKey === `resource:workbook:${scope.workbookName}` || resourceKey.startsWith(`resource:sheet:${scope.workbookName}:`) || resourceKey.startsWith(`resource:table:${scope.workbookName}:`) || resourceKey.startsWith(`resource:named:workbook:${scope.workbookName}:`) || resourceKey.startsWith(`resource:named:sheet:${scope.workbookName}:`);
+    }
+    return resourceKey === `resource:sheet:${scope.workbookName}:${scope.sheetName}` || resourceKey.startsWith(`resource:named:sheet:${scope.workbookName}:${scope.sheetName}:`);
+  }
+  isNodeInRemovedScope(node, scope) {
+    if (node instanceof import_resource_dependency_node.ResourceDependencyNode) {
+      return this.isResourceNodeInRemovedScope(node.key, scope);
+    }
+    if (node instanceof import_ast_evaluation_node.AstEvaluationNode) {
+      const contextDependency = node.getContextDependency();
+      if (scope.type === "workbook") {
+        return contextDependency.workbookName === scope.workbookName;
+      }
+      return contextDependency.workbookName === scope.workbookName && contextDependency.sheetName === scope.sheetName;
+    }
+    const workbookName = node instanceof import_range_evaluation_node.RangeEvaluationNode ? node.address.workbookName : node.cellAddress.workbookName;
+    const sheetName = node instanceof import_range_evaluation_node.RangeEvaluationNode ? node.address.sheetName : node.cellAddress.sheetName;
+    if (scope.type === "workbook") {
+      return workbookName === scope.workbookName;
+    }
+    return workbookName === scope.workbookName && sheetName === scope.sheetName;
+  }
+  collectNodesForRemovedScopes(removedScopes) {
+    const affected = new Set;
+    for (const node of this.getAllPersistentNodes()) {
+      if (removedScopes.some((scope) => this.isNodeInRemovedScope(node, scope))) {
+        affected.add(node);
+      }
+    }
+    return affected;
+  }
+  purgeRemovedScopes(removedScopes) {
+    const shouldRemoveAddress = (address) => removedScopes.some((scope) => scope.type === "workbook" ? address.workbookName === scope.workbookName : address.workbookName === scope.workbookName && address.sheetName === scope.sheetName);
+    for (const [key, node] of Array.from(this.cellNodes.entries())) {
+      if (shouldRemoveAddress(node.cellAddress)) {
+        this.unregisterNode(node);
+        this.cellNodes.delete(key);
+      }
+    }
+    for (const [key, node] of Array.from(this.spillMetaNodes.entries())) {
+      if (shouldRemoveAddress(node.cellAddress)) {
+        this.unregisterNode(node);
+        this.spillMetaNodes.delete(key);
+      }
+    }
+    for (const [key, node] of Array.from(this.emptyCells.entries())) {
+      if (shouldRemoveAddress(node.cellAddress)) {
+        this.unregisterNode(node);
+        this.emptyCells.delete(key);
+      }
+    }
+    for (const [key, node] of Array.from(this.ranges.entries())) {
+      if (shouldRemoveAddress({
+        workbookName: node.address.workbookName,
+        sheetName: node.address.sheetName
+      })) {
+        this.unregisterNode(node);
+        this.ranges.delete(key);
+      }
+    }
+    for (const [key, node] of Array.from(this.resourceNodes.entries())) {
+      if (removedScopes.some((scope) => this.isResourceNodeInRemovedScope(key, scope))) {
+        this.unregisterNode(node);
+        this.resourceNodes.delete(key);
+      }
+    }
+    for (const [astKey, astEntries] of Array.from(this.asts.entries())) {
+      for (const [contextKey, astEntry] of Array.from(astEntries.entries.entries())) {
+        if (removedScopes.some((scope) => this.isNodeInRemovedScope(astEntry.evalNode, scope))) {
+          this.unregisterNode(astEntry.evalNode);
+          astEntries.entries.delete(contextKey);
+        }
+      }
+      if (astEntries.entries.size === 0) {
+        this.asts.delete(astKey);
+      }
+    }
+    for (const [spillOriginKey, spilledValue] of Array.from(this._spilledValues.entries())) {
+      if (shouldRemoveAddress({
+        workbookName: spilledValue.origin.workbookName,
+        sheetName: spilledValue.origin.sheetName
+      })) {
+        this._spilledValues.delete(spillOriginKey);
+      }
+    }
+  }
+  invalidateFromMutation(footprint) {
+    const queue = [];
+    const visited = new Set;
+    const invalidatedNodeKeys = new Set;
+    for (const touchedCell of footprint.touchedCells) {
+      for (const node of this.collectExistingNodesForCell(touchedCell.address)) {
+        queue.push(node);
+      }
+      for (const node of this.collectSpillOriginsAffectingCell(touchedCell.address)) {
+        queue.push(node);
+      }
+      for (const watcher of this.collectCoverageWatchers(touchedCell.address)) {
+        queue.push(watcher);
+      }
+      for (const watcher of this.collectFrontierWatchers(touchedCell.address)) {
+        queue.push(watcher);
+      }
+    }
+    for (const resourceKey of footprint.resourceKeys) {
+      const resourceNode = this.resourceNodes.get(resourceKey);
+      if (resourceNode) {
+        queue.push(resourceNode);
+      }
+    }
+    if (footprint.removedScopes?.length) {
+      for (const node of this.collectNodesForRemovedScopes(footprint.removedScopes)) {
+        queue.push(node);
+      }
+    }
+    while (queue.length > 0) {
+      const node = queue.pop();
+      if (!node || visited.has(node)) {
+        continue;
+      }
+      visited.add(node);
+      for (const dependent of this.getNodeDependents(node)) {
+        queue.push(dependent);
+      }
+      for (const extra of this.collectInvalidationExtras(node)) {
+        queue.push(extra);
+      }
+      this.invalidateNodeState(node, invalidatedNodeKeys);
+    }
+    this.cacheManager.deleteEvaluationOrders(invalidatedNodeKeys);
+    this.cacheManager.clearSCCCache();
+    if (footprint.removedScopes?.length) {
+      this.purgeRemovedScopes(footprint.removedScopes);
+    }
+  }
   getTransitiveDepsForEvalOrder(node, visited = new Set) {
     if (visited.has(node)) {
       return new Set;
@@ -610,4 +1298,4 @@ class DependencyManager {
   }
 }
 
-//# debugId=4467033E0678751664756E2164756E21
+//# debugId=88CA47D7AF9DA3D664756E2164756E21