@ricsam/formula-engine 0.0.1

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

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/core/managers/dependency-manager.ts"],
+  "sourcesContent": [
+    "import {\n  contextDependencyKeys,\n  eligibleKeysForContext,\n  getContextDependencyKey,\n  type ContextDependency,\n  type ContextDependencyType,\n} from \"src/evaluator/evaluation-context\";\nimport {\n  type CellAddress,\n  type EvaluationOrder,\n  type SpilledValue,\n} from \"../types.cjs\";\nimport { isCellInRange, keyToCellAddress } from \"../utils.cjs\";\n\nimport { AstEvaluationNode } from \"src/evaluator/dependency-nodes/ast-evaluation-node\";\nimport { CellValueNode } from \"src/evaluator/dependency-nodes/cell-value-node\";\nimport { EmptyCellEvaluationNode } from \"src/evaluator/dependency-nodes/empty-cell-evaluation-node\";\nimport { RangeEvaluationNode } from \"src/evaluator/range-evaluation-node\";\nimport type { ASTNode } from \"src/parser/ast\";\nimport { astToString } from \"src/parser/formatter\";\nimport { CacheManager } from \"./cache-manager.cjs\";\nimport type {\n  CellNodeKeyDictionary,\n  CellNodeType,\n  DependencyNode,\n} from \"./dependency-node.cjs\";\nimport { WorkbookManager } from \"./workbook-manager.cjs\";\nimport { SpillMetaNode } from \"src/evaluator/dependency-nodes/spill-meta-node\";\nimport { flags } from \"src/debug/flags\";\n\nexport interface DependencyTreeNode {\n  type: \"cell\" | \"range\" | \"empty\";\n  circular?: boolean;\n  key: string;\n  directDepsUpdated?: boolean;\n  resolved?: boolean;\n  canResolve: boolean;\n  resultType:\n    | \"awaiting-evaluation\"\n    | \"spilled-values\"\n    | \"value\"\n    | \"range\"\n    | \"error\"\n    | \"does-not-spill\";\n  deps?: DependencyTreeNode[];\n  frontierDependencies?: DependencyTreeNode[];\n  self?: boolean;\n  _debug?: {\n    rawFrontierDependencies?: string[];\n    discardedFrontierDependencies?: string[];\n    activeFrontierDependencies?: string[];\n  };\n}\n\n/**\n * The DependencyManager is responsible for storing the evaluated values and their dependencies.\n */\nexport class DependencyManager {\n  /**\n   * The dependency graph\n   */\n  private evaluatedNodes: Map<\n    /**\n     * key is the cell key, from cellAddressToKey\n     */\n    string,\n    CellValueNode\n  > = new Map();\n\n  private spillMetaNodes: Map<string, SpillMetaNode> = new Map();\n\n  private emptyCells: Map<string, EmptyCellEvaluationNode> = new Map();\n\n  /**\n   * registry of spilled values\n   */\n  private _spilledValues: Map<\n    /**\n     * key is the dependency node key, from dependencyNodeToKey for the origin cell\n     */\n    string,\n    SpilledValue\n  > = new Map();\n\n  /**\n   * Key is workbook:sheetName:rangeKey, e.g. Workbook1:Sheet1:A1:D10, from rangeAddressToKey\n   */\n  private ranges: Map<string, RangeEvaluationNode> = new Map();\n\n  constructor(\n    private cacheManager: CacheManager,\n    private workbookManager: WorkbookManager\n  ) {}\n\n  public get spilledValues(): IterableIterator<SpilledValue> {\n    return this._spilledValues.values();\n  }\n\n  isSpillOrigin(cellAddress: CellAddress): boolean {\n    for (const spilledValue of this._spilledValues.values()) {\n      if (\n        spilledValue.origin.sheetName !== cellAddress.sheetName ||\n        spilledValue.origin.workbookName !== cellAddress.workbookName\n      ) {\n        continue;\n      }\n      if (\n        spilledValue.origin.colIndex === cellAddress.colIndex &&\n        spilledValue.origin.rowIndex === cellAddress.rowIndex\n      ) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  getSpillValue(cellAddress: CellAddress): SpilledValue | undefined {\n    for (const spilledValue of this._spilledValues.values()) {\n      if (\n        spilledValue.origin.sheetName !== cellAddress.sheetName ||\n        spilledValue.origin.workbookName !== cellAddress.workbookName\n      ) {\n        continue;\n      }\n      if (\n        spilledValue.origin.colIndex === cellAddress.colIndex &&\n        spilledValue.origin.rowIndex === cellAddress.rowIndex\n      ) {\n        return undefined;\n      }\n      if (isCellInRange(cellAddress, spilledValue.spillOnto)) {\n        return spilledValue;\n      }\n    }\n    return undefined;\n  }\n\n  getSpilledAddress(\n    cellAddress: CellAddress,\n    /**\n     * if the spilled value is already available, we can use it to get the source address\n     */\n    passedSpilledValue?: SpilledValue\n  ): { address: CellAddress; spillOffset: { x: number; y: number } } {\n    const spilledValue = passedSpilledValue ?? this.getSpillValue(cellAddress);\n    if (!spilledValue) {\n      throw new Error(\"Cell is not spilled\");\n    }\n    const offsetLeft = cellAddress.colIndex - spilledValue.origin.colIndex;\n    const offsetTop = cellAddress.rowIndex - spilledValue.origin.rowIndex;\n    const address: CellAddress = {\n      ...cellAddress,\n      colIndex: spilledValue.origin.colIndex + offsetLeft,\n      rowIndex: spilledValue.origin.rowIndex + offsetTop,\n    };\n    if (offsetLeft === 0 && offsetTop === 0) {\n      throw new Error(\n        \"Spilled value is the same as the cell address! The origin has a pre-calculated value that can be used\"\n      );\n    }\n    return { address, spillOffset: { x: offsetLeft, y: offsetTop } };\n  }\n\n  clearEvaluationCache(): void {\n    this.cacheManager.clear();\n    this.evaluatedNodes.clear();\n    this.emptyCells.clear();\n    this.asts.clear();\n    this.spillMetaNodes.clear();\n    this.ranges.clear();\n    this._spilledValues.clear();\n  }\n\n  setSpilledValue(nodeKey: string, spilledValue: SpilledValue): void {\n    this._spilledValues.set(nodeKey.replace(/^[^:]+:/, \"\"), spilledValue);\n  }\n\n  getSpilledValue(nodeKey: string): SpilledValue | undefined {\n    return this._spilledValues.get(nodeKey.replace(/^[^:]+:/, \"\"));\n  }\n\n  getEmptyCellNode(nodeKey: string): EmptyCellEvaluationNode {\n    if (!nodeKey.startsWith(\"empty:\")) {\n      throw new Error(\"Invalid empty cell node key: \" + nodeKey);\n    }\n    if (!this.emptyCells.has(nodeKey)) {\n      const node = new EmptyCellEvaluationNode(\n        nodeKey,\n        this,\n        this.workbookManager\n      );\n      this.emptyCells.set(nodeKey, node);\n      return node;\n    }\n    return this.emptyCells.get(nodeKey)!;\n  }\n\n  getSpillMetaNode(nodeKey: string): SpillMetaNode {\n    if (!nodeKey.startsWith(\"spill-meta:\")) {\n      throw new Error(\"Invalid spill meta node key: \" + nodeKey);\n    }\n    if (!this.spillMetaNodes.has(nodeKey)) {\n      const node = new SpillMetaNode(nodeKey);\n      this.spillMetaNodes.set(nodeKey, node);\n      return node;\n    }\n    return this.spillMetaNodes.get(nodeKey)!;\n  }\n\n  getCellValueNode(nodeKey: string): CellValueNode {\n    if (!nodeKey.startsWith(\"cell-value:\")) {\n      throw new Error(\"Invalid cell value node key: \" + nodeKey);\n    }\n    if (!this.evaluatedNodes.has(nodeKey)) {\n      const node = new CellValueNode(nodeKey);\n      this.evaluatedNodes.set(nodeKey, node);\n      return node;\n    }\n    return this.evaluatedNodes.get(nodeKey)!;\n  }\n\n  getCellValueOrEmptyCellNode(\n    nodeKey: string\n  ): CellValueNode | EmptyCellEvaluationNode {\n    const cellAddress = keyToCellAddress(nodeKey);\n\n    const emptyKey = nodeKey.replace(/^[^:]+:/, \"empty:\");\n    const cellValueKey = nodeKey.replace(/^[^:]+:/, \"cell-value:\");\n\n    if (this.workbookManager.isCellEmpty(cellAddress)) {\n      return this.getEmptyCellNode(emptyKey);\n    }\n\n    return this.getCellValueNode(cellValueKey);\n  }\n\n  getSpillMetaOrEmptySpillMetaNode(\n    nodeKey: string\n  ): SpillMetaNode | EmptyCellEvaluationNode {\n    const cellAddress = keyToCellAddress(nodeKey);\n\n    const emptyKey = nodeKey.replace(/^[^:]+:/, \"empty:\");\n    const spillMetaKey = nodeKey.replace(/^[^:]+:/, \"spill-meta:\");\n\n    if (this.workbookManager.isCellEmpty(cellAddress)) {\n      return this.getEmptyCellNode(emptyKey);\n    }\n\n    return this.getSpillMetaNode(spillMetaKey);\n  }\n\n  lookupCellNode<T extends CellNodeType>(\n    nodeKey: string,\n    types: T[]\n  ): CellNodeKeyDictionary[T][] {\n    const cellAddress = keyToCellAddress(nodeKey);\n\n    const emptyKey = nodeKey.replace(/^[^:]+:/, \"empty:\");\n    const cellValueKey = nodeKey.replace(/^[^:]+:/, \"cell-value:\");\n    const cellValueNode = this.evaluatedNodes.get(cellValueKey);\n    const cellMetaKey = nodeKey.replace(/^[^:]+:/, \"cell-meta:\");\n    const cellMetaNode = this.evaluatedNodes.get(cellMetaKey);\n\n    if (this.workbookManager.isCellEmpty(cellAddress)) {\n      if ((types as string[]).includes(\"empty\")) {\n        return [this.getEmptyCellNode(emptyKey) as any];\n      } else {\n        return [];\n      }\n    }\n\n    const results: any[] = [];\n\n    if ((types as string[]).includes(\"cell\")) {\n      if (cellValueNode) {\n        results.push(cellValueNode);\n      } else {\n        results.push(this.getCellValueNode(cellValueKey));\n      }\n    }\n\n    if (this.workbookManager.isFormulaCell(cellAddress)) {\n      if ((types as string[]).includes(\"spill-meta\")) {\n        if (cellMetaNode) {\n          results.push(cellMetaNode);\n        } else {\n          results.push(this.getSpillMetaNode(cellValueKey));\n        }\n      }\n    }\n\n    return results;\n  }\n\n  getRangeNode(rangeKey: string): RangeEvaluationNode {\n    if (!rangeKey.startsWith(\"range:\")) {\n      throw new Error(\"Invalid range node key: \" + rangeKey);\n    }\n    if (!this.ranges.has(rangeKey)) {\n      const node = new RangeEvaluationNode(\n        rangeKey,\n        this,\n        this.workbookManager\n      );\n      this.ranges.set(rangeKey, node);\n      return node;\n    }\n    return this.ranges.get(rangeKey)!;\n  }\n\n  asts: Map<\n    /**\n     * ast key\n     */\n    string,\n    {\n      entries: Map<\n        /**\n         * context dependency key\n         */\n        string,\n        {\n          evalNode: AstEvaluationNode;\n          contextDependency: ContextDependency;\n        }\n      >;\n    }\n  > = new Map();\n\n  getAstNode(\n    ast: ASTNode,\n    currentContext: Omit<Required<ContextDependency>, \"tableName\"> & {\n      tableName?: string;\n    }\n  ): AstEvaluationNode {\n    const astKey = `ast:${astToString(ast)}`; // cache normalize this later\n    const astEntries = this.asts.get(astKey);\n\n    const keys = eligibleKeysForContext(currentContext);\n\n    for (const key of keys) {\n      const astEntry = astEntries?.entries.get(key);\n      if (astEntry) {\n        return astEntry.evalNode;\n      }\n    }\n\n    // if any of the ast entries match the current context, then we can return the ast node\n    // otherwise we have to evalute the ast node to understand if it is context dependent\n    // and later it will be saved using saveAstNode\n    // if (astEntries) {\n    //   for (const entry of astEntries.entries.values()) {\n    //     // e.g. we have a row dependent ast dependency, dependent on row 1, and the current context dependency has rowIndex 1\n    //     // then we will get a match\n    //     const matches = Object.entries(entry.contextDependency).every(\n    //       ([key, value]) => {\n    //         if (typeof value === \"undefined\") {\n    //           return true;\n    //         }\n    //         return currentContext[key as keyof ContextDependency] === value;\n    //       }\n    //     );\n    //     if (matches) {\n    //       return entry.evalNode;\n    //     }\n    //   }\n    // }\n\n    // by default the ast node is cell specific\n    // but later, setContextDependency is called with a more open context dependency\n    const node = new AstEvaluationNode(ast, currentContext);\n    // initially we store it as a cell, sheet, workbook and table dependent node\n    // but later, once resolved, we can store it under a looser dependency key, e.g. only sheet, workbook and table dependent\n    this.saveAstNode(node, currentContext);\n    return node;\n  }\n\n  /**\n   * Once an AST node is evaluated, we know if it is context dependent\n   * and will thus save it under the correct cache key according to its\n   * contextDependency\n   *\n   * only resolved ast nodes can be saved\n   */\n  private saveAstNode(\n    ast: AstEvaluationNode,\n    contextDependency: ContextDependency\n  ) {\n    const astKey = ast.key;\n    const contextDependencyKey = getContextDependencyKey(contextDependency);\n    const astEntries = this.asts.get(astKey);\n\n    if (astEntries) {\n      // if we don't already have an entry, then let's add it\n      astEntries.entries.set(contextDependencyKey, {\n        evalNode: ast,\n        contextDependency,\n      });\n    } else {\n      this.asts.set(astKey, {\n        entries: new Map([\n          [contextDependencyKey, { evalNode: ast, contextDependency }],\n        ]),\n      });\n    }\n  }\n\n  getEvaluatedNodes(): Map<string, CellValueNode> {\n    return this.evaluatedNodes;\n  }\n\n  //#region dependency graph methods\n\n  /**\n   * Get transitive dependencies and transitive frontier dependencies\n   * This is only used by buildEvaluationOrder, so we'll optimize it there\n   */\n  getTransitiveDepsForEvalOrder(\n    node: DependencyNode,\n    visited: Set<DependencyNode> = new Set()\n  ): Set<DependencyNode> {\n    // Prevent infinite recursion\n    if (visited.has(node)) {\n      return new Set();\n    }\n\n    // If the node is resolved, then we don't need to evaluate it\n    if (node && node.resolved) {\n      return new Set();\n    }\n\n    // Mark this node as visited for cycle detection\n    visited.add(node);\n\n    const allNodes = new Set<DependencyNode>();\n    allNodes.add(node);\n\n    // Get direct dependencies (regular + frontier)\n    const directDeps = node.getDependencies();\n\n    // Recursively get transitive dependencies for each direct dependency\n    for (const dep of directDeps) {\n      if (!visited.has(dep)) {\n        const depTransitiveDeps = this.getTransitiveDepsForEvalOrder(\n          dep,\n          visited\n        );\n        for (const transitiveDep of depTransitiveDeps) {\n          allNodes.add(transitiveDep);\n        }\n      }\n    }\n\n    // Remove this node from visited set for other branches\n    visited.delete(node);\n\n    return allNodes;\n  }\n\n  /**\n   * Build evaluation order for a cell using SCC-based condensation DAG approach\n   *\n   * Algorithm:\n   * 1. Discover all transitive dependencies (skipping resolved nodes)\n   * 2. Find SCCs using Tarjan's algorithm\n   * 3. Create condensation DAG from SCCs\n   * 4. Topologically sort the condensation DAG using Kahn's algorithm\n   * 5. For each SCC, create internal evaluation order with cycle breaking\n   * 6. Join the sorted SCC evaluation orders to create final evaluation order\n   */\n  buildEvaluationOrder(\n    node: CellValueNode | EmptyCellEvaluationNode\n  ): EvaluationOrder {\n    if (node.resolved && this.cacheManager.getEvaluationOrder(node.key)) {\n      return this.cacheManager.getEvaluationOrder(node.key)!;\n    }\n\n    // Phase 1: Discover all transitive dependencies (skipping resolved nodes)\n    const allNodes = new Map<string, DependencyNode>();\n    const visitedForDiscovery = new Set<DependencyNode>();\n\n    const discoverNodes = (currentNode: DependencyNode) => {\n      if (currentNode && currentNode.resolved) {\n        return;\n      }\n\n      if (!allNodes.has(currentNode.key)) {\n        allNodes.set(currentNode.key, currentNode);\n      }\n\n      if (visitedForDiscovery.has(currentNode)) {\n        return;\n      }\n\n      visitedForDiscovery.add(currentNode);\n\n      const allDeps = currentNode.getAllDependencies();\n      for (const dep of allDeps) {\n        discoverNodes(dep);\n      }\n    };\n\n    discoverNodes(node);\n\n    if (allNodes.size === 0 && node && node.resolved) {\n      const result: EvaluationOrder = {\n        evaluationOrder: new Set([node]),\n        hasCycle: false,\n        hash: this.computeHash(new Set([node])),\n      };\n\n      if (node && node.resolved) {\n        this.cacheManager.setEvaluationOrder(node.key, result);\n      }\n\n      return result;\n    }\n\n    // Phase 2: Find SCCs using Tarjan's algorithm\n    // Build SCCs considering ALL dependencies (soft + hard edges)\n    const sccs = this.findSCCs(allNodes, true);\n\n    // Phase 3: Create condensation DAG and check for cached SCCs\n    const nodeToSCCId = new Map<DependencyNode, number>();\n    const sccList: import(\"../types.cjs\").SCC[] = [];\n\n    for (let i = 0; i < sccs.length; i++) {\n      const sccNodes = sccs[i]!;\n\n      // Check if all nodes in this SCC are resolved\n      const allResolved = Array.from(sccNodes).every((n) => n.resolved);\n\n      // Create SCC hash for caching\n      const sccHash = Array.from(sccNodes)\n        .map((n) => n.key)\n        .sort()\n        .join(\"|\");\n\n      // Try to get cached SCC if it's resolved\n      let scc: import(\"../types.cjs\").SCC;\n      const cachedSCC = allResolved\n        ? this.cacheManager.getSCC(sccHash)\n        : undefined;\n\n      if (cachedSCC) {\n        scc = cachedSCC;\n      } else {\n        // Build evaluation order for this SCC with cycle breaking\n        const sccEvalOrder = this.buildSCCEvaluationOrder(sccNodes);\n\n        // Find hard-edge SCCs within this soft-edge SCC\n        // Hard-edge SCCs are formed by only regular dependencies\n        const hardEdgeSCCs = this.findSCCs(\n          new Map(Array.from(sccNodes).map((n) => [n.key, n])),\n          false // Use only hard edges (regular dependencies)\n        );\n\n        scc = {\n          id: i,\n          nodes: sccNodes,\n          evaluationOrder: sccEvalOrder,\n          resolved: allResolved,\n          hardEdgeSCCs,\n        };\n\n        // Cache if resolved\n        if (allResolved) {\n          this.cacheManager.setSCC(sccHash, scc);\n        }\n      }\n\n      sccList.push(scc);\n\n      for (const n of sccNodes) {\n        nodeToSCCId.set(n, i);\n      }\n    }\n\n    // Build SCC dependency graph\n    // Edge from A to B means A depends on B, so B must be evaluated before A\n    const sccGraph = new Map<number, Set<number>>();\n    for (let i = 0; i < sccList.length; i++) {\n      sccGraph.set(i, new Set());\n    }\n\n    for (const [_, n] of allNodes) {\n      const nSCCId = nodeToSCCId.get(n)!;\n      // Use ALL dependencies (regular + frontier) for the condensation DAG\n      // This ensures proper evaluation order even with frontier dependencies\n      const deps = n.getAllDependencies();\n\n      for (const dep of deps) {\n        if (!allNodes.has(dep.key)) continue;\n\n        const depSCCId = nodeToSCCId.get(dep)!;\n        // n depends on dep, so dep's SCC must come before n's SCC\n        // Add edge from dep's SCC to n's SCC\n        if (nSCCId !== depSCCId) {\n          sccGraph.get(depSCCId)!.add(nSCCId);\n        }\n      }\n    }\n\n    // Phase 4: Topologically sort SCCs using Kahn's algorithm\n    const inDegree = new Map<number, number>();\n    for (let i = 0; i < sccList.length; i++) {\n      inDegree.set(i, 0);\n    }\n\n    for (const [_, deps] of sccGraph) {\n      for (const toId of deps) {\n        inDegree.set(toId, inDegree.get(toId)! + 1);\n      }\n    }\n\n    const queue: number[] = [];\n    for (let i = 0; i < sccList.length; i++) {\n      if (inDegree.get(i) === 0) {\n        queue.push(i);\n      }\n    }\n\n    const sortedSCCIds: number[] = [];\n    while (queue.length > 0) {\n      const sccId = queue.shift()!;\n      sortedSCCIds.push(sccId);\n\n      const deps = sccGraph.get(sccId)!;\n      for (const depId of deps) {\n        const newInDegree = inDegree.get(depId)! - 1;\n        inDegree.set(depId, newInDegree);\n        if (newInDegree === 0) {\n          queue.push(depId);\n        }\n      }\n    }\n\n    // Phase 5: Join evaluation orders from sorted SCCs\n    const evaluationOrderArray: DependencyNode[] = [];\n    for (const sccId of sortedSCCIds) {\n      const scc = sccList[sccId]!;\n      evaluationOrderArray.push(...scc.evaluationOrder);\n    }\n\n    const evaluationOrder = new Set(evaluationOrderArray);\n\n    // Identify cycle nodes from hard-edge SCCs\n    const cycleNodes = new Set<DependencyNode>();\n    for (const scc of sccList) {\n      for (const hardEdgeSCC of scc.hardEdgeSCCs) {\n        // A hard-edge SCC with multiple nodes or a self-loop indicates a real cycle\n        if (hardEdgeSCC.size > 1) {\n          for (const n of hardEdgeSCC) {\n            cycleNodes.add(n);\n          }\n        } else if (hardEdgeSCC.size === 1) {\n          const node = Array.from(hardEdgeSCC)[0]!;\n          if (node.getDependencies().has(node)) {\n            cycleNodes.add(node);\n          }\n        }\n      }\n    }\n\n    const hasCycle = cycleNodes.size > 0;\n    const result: EvaluationOrder = {\n      evaluationOrder,\n      hasCycle,\n      ...(hasCycle && { cycleNodes }),\n      hash: this.computeGraphHash(allNodes, sccList),\n      sccDAG: {\n        sccList,\n        sccGraph,\n      },\n    };\n\n    if (node && node.resolved) {\n      this.cacheManager.setEvaluationOrder(node.key, result);\n    }\n\n    return result;\n  }\n\n  /**\n   * Find strongly connected components using Tarjan's algorithm\n   * @param nodes - Map of nodes to analyze\n   * @param includeFrontier - If true, use getAllDependencies(); if false, use getDependencies()\n   * @returns Array of SCCs (each SCC is a Set of nodes)\n   */\n  private findSCCs(\n    nodes: Map<string, DependencyNode>,\n    includeFrontier: boolean\n  ): Set<DependencyNode>[] {\n    const index = new Map<DependencyNode, number>();\n    const lowlink = new Map<DependencyNode, number>();\n    const onStack = new Set<DependencyNode>();\n    const stack: DependencyNode[] = [];\n    const sccs: Set<DependencyNode>[] = [];\n    let currentIndex = 0;\n\n    const strongConnect = (v: DependencyNode) => {\n      index.set(v, currentIndex);\n      lowlink.set(v, currentIndex);\n      currentIndex++;\n      stack.push(v);\n      onStack.add(v);\n\n      // Use either all dependencies or just regular dependencies\n      const successors = includeFrontier\n        ? v.getAllDependencies()\n        : v.getDependencies();\n\n      for (const w of successors) {\n        if (!nodes.has(w.key)) {\n          continue;\n        }\n\n        if (!index.has(w)) {\n          strongConnect(w);\n          lowlink.set(v, Math.min(lowlink.get(v)!, lowlink.get(w)!));\n        } else if (onStack.has(w)) {\n          lowlink.set(v, Math.min(lowlink.get(v)!, index.get(w)!));\n        }\n      }\n\n      if (lowlink.get(v) === index.get(v)) {\n        const scc = new Set<DependencyNode>();\n        let w: DependencyNode;\n        do {\n          w = stack.pop()!;\n          onStack.delete(w);\n          scc.add(w);\n        } while (w !== v);\n\n        sccs.push(scc);\n      }\n    };\n\n    for (const [_, n] of nodes) {\n      if (!index.has(n)) {\n        strongConnect(n);\n      }\n    }\n\n    return sccs;\n  }\n\n  /**\n   * Build evaluation order within a single SCC using DFS with cycle breaking\n   * Uses all dependencies (including frontier) for proper evaluation ordering\n   */\n  private buildSCCEvaluationOrder(\n    sccNodes: Set<DependencyNode>\n  ): DependencyNode[] {\n    const visited = new Set<DependencyNode>();\n    const visiting = new Set<DependencyNode>();\n    const result: DependencyNode[] = [];\n\n    const dfs = (n: DependencyNode) => {\n      if (visited.has(n)) {\n        return;\n      }\n\n      if (visiting.has(n)) {\n        // Cycle detected (from any edge type), break it\n        return;\n      }\n\n      visiting.add(n);\n\n      // Use all dependencies for evaluation ordering (regular + frontier)\n      const deps = n.getAllDependencies();\n      for (const dep of deps) {\n        if (sccNodes.has(dep) && !visited.has(dep)) {\n          dfs(dep);\n        }\n      }\n\n      visiting.delete(n);\n      visited.add(n);\n      result.push(n);\n    };\n\n    // Sort nodes by key for deterministic ordering\n    const sortedNodes = Array.from(sccNodes).sort((a, b) =>\n      a.key.localeCompare(b.key)\n    );\n\n    for (const n of sortedNodes) {\n      if (!visited.has(n)) {\n        dfs(n);\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * Compute hash representing the graph structure including SCC information\n   */\n  private computeGraphHash(\n    allNodes: Map<string, DependencyNode>,\n    sccList: import(\"../types.cjs\").SCC[]\n  ): string {\n    const parts: string[] = [];\n\n    // Hash nodes and their dependencies\n    for (const [key, node] of Array.from(allNodes.entries()).sort()) {\n      const deps = Array.from(node.getAllDependencies())\n        .map((d) => d.key)\n        .sort()\n        .join(\",\");\n      parts.push(`${key}:[${deps}]`);\n    }\n\n    // Add SCC structure\n    for (const scc of sccList) {\n      const nodeKeys = Array.from(scc.nodes)\n        .map((n) => n.key)\n        .sort()\n        .join(\",\");\n      parts.push(`SCC${scc.id}:{${nodeKeys}}`);\n    }\n\n    return parts.join(\"|\");\n  }\n\n  /**\n   * Compute a hash representing the current state of evaluated nodes\n   * This hash changes when dependencies, frontier dependencies, or discarded frontier dependencies change\n   */\n  private computeHash(allNodes: Set<DependencyNode>): string {\n    const nodeStates: string[] = [];\n\n    for (const node of Array.from(allNodes).sort()) {\n      if (node) {\n        const deps = Array.from(node.getDependencies() || [])\n          .map((dep) => dep.key)\n          .sort()\n          .join(\",\");\n\n        // Handle frontier dependencies (Map<string, Set<string>>)\n        const frontierDeps: string = Array.from(node.getFrontierDependencies())\n          .map((dep) => dep.key)\n          .sort()\n          .join(\";\");\n\n        const nodeState = `${node.key}:{deps:[${deps}],frontier:[${frontierDeps}]}`;\n        nodeStates.push(nodeState);\n      }\n    }\n\n    return nodeStates.join(\"|\");\n  }\n\n  /**\n   * Get a hierarchical dependency tree for a node\n   */\n  getDependencyTree(node: DependencyNode): DependencyTreeNode {\n    const visited = new Set<DependencyNode>();\n\n    const nodeToType = (node: DependencyNode): \"cell\" | \"range\" | \"empty\" => {\n      if (node instanceof RangeEvaluationNode) {\n        return \"range\";\n      }\n      if (node instanceof EmptyCellEvaluationNode) {\n        return \"empty\";\n      }\n      return \"cell\";\n    };\n\n    const buildTree = (\n      node: DependencyNode,\n      isSelf = false\n    ): DependencyTreeNode => {\n      const cellRef: string = node.toString();\n\n      // Handle self-reference to avoid infinite recursion\n      if (isSelf) {\n        return {\n          type: nodeToType(node),\n          resultType:\n            node instanceof RangeEvaluationNode\n              ? \"range\"\n              : node.evaluationResult\n                ? node.evaluationResult.type\n                : \"awaiting-evaluation\",\n          canResolve: node.canResolve(),\n          key: cellRef,\n          directDepsUpdated: node.directDepsUpdated,\n          resolved: node.resolved,\n          self: true,\n          circular: true,\n        };\n      }\n\n      // Avoid infinite recursion for circular dependencies\n      if (visited.has(node)) {\n        return {\n          type: nodeToType(node),\n          resultType:\n            node instanceof RangeEvaluationNode\n              ? \"range\"\n              : node.evaluationResult\n                ? node.evaluationResult.type\n                : \"awaiting-evaluation\",\n          canResolve: node.canResolve(),\n          key: cellRef,\n          directDepsUpdated: node.directDepsUpdated,\n          resolved: node.resolved,\n          circular: true,\n        };\n      }\n\n      visited.add(node);\n\n      const directDeps = Array.from(node.getDependencies());\n      let frontierDeps = Array.from(node.getFrontierDependencies());\n\n      // Get regular dependencies\n      const deps: DependencyTreeNode[] = directDeps.map((dep) =>\n        buildTree(dep, dep.key === node.key)\n      );\n\n      const frontierDependencies: DependencyTreeNode[] = frontierDeps.map(\n        (dep) => buildTree(dep, false)\n      );\n\n      visited.delete(node);\n\n      const result: DependencyTreeNode = {\n        type: nodeToType(node),\n        resultType:\n          node instanceof RangeEvaluationNode\n            ? \"range\"\n            : node.evaluationResult\n              ? node.evaluationResult.type\n              : \"awaiting-evaluation\",\n        canResolve: node.canResolve(),\n        key: cellRef,\n        directDepsUpdated: node.directDepsUpdated,\n        resolved: node.resolved,\n      };\n\n      // Only include deps and frontierDependencies if they have content\n      if (deps.length > 0) {\n        result.deps = deps;\n      }\n      if (frontierDependencies.length > 0) {\n        result.frontierDependencies = frontierDependencies;\n      }\n\n      return result;\n    };\n\n    return buildTree(node);\n  }\n  //#endregion\n\n  markResolvedNodes(node: DependencyNode): void {\n    // Track visited nodes to avoid infinite loops in circular dependencies\n    const visited = new Set<DependencyNode>();\n    visited.add(node); // Don't revisit the current cell\n\n    const areTransitiveDepsResolved = (nodes: Set<DependencyNode>): boolean => {\n      let canResolve = true;\n      for (const node of nodes) {\n        if (visited.has(node) || node.resolved) {\n          continue;\n        }\n        visited.add(node);\n\n        // Check the node's dependencies to not cause cycles with frontier dependencies\n        const directDeps = node.getDependencies();\n\n        const a = areTransitiveDepsResolved(directDeps);\n        const b = node.canResolve();\n\n        if (!a || !b) {\n          canResolve = false;\n        }\n        if (a && b) {\n          node.resolve();\n          // if an ast node is resolved, it will get removed from the dependency graph\n          // and thus never reach evaluateNode in formula evaluator\n          // so we need to save it here. The latest context dependency is the correct one.\n          if (node instanceof AstEvaluationNode) {\n            this.saveAstNode(node, node.getContextDependency());\n          }\n        }\n      }\n      return canResolve;\n    };\n\n    if (\n      areTransitiveDepsResolved(node.getDependencies()) &&\n      node.canResolve()\n    ) {\n      node.resolve();\n      if (node instanceof AstEvaluationNode) {\n        this.saveAstNode(node, node.getContextDependency());\n      }\n    }\n  }\n\n  /**\n   * Update SCCs in cache to mark them as resolved if all their nodes are resolved\n   */\n  public updateResolvedSCCs(evalOrder: EvaluationOrder): void {\n    if (!evalOrder.sccDAG) {\n      return;\n    }\n\n    // Check each SCC and update cache if all nodes are resolved\n    for (const scc of evalOrder.sccDAG.sccList) {\n      const allResolved = Array.from(scc.nodes).every((n) => n.resolved);\n\n      if (allResolved && !scc.resolved) {\n        // Create updated SCC with resolved flag\n        const updatedSCC: import(\"../types.cjs\").SCC = {\n          ...scc,\n          resolved: true,\n        };\n\n        // Update cache\n        const sccHash = Array.from(scc.nodes)\n          .map((n) => n.key)\n          .sort()\n          .join(\"|\");\n\n        this.cacheManager.setSCC(sccHash, updatedSCC);\n      }\n    }\n  }\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "62F68ED5F4FB614764756E2164756E21",
+  "names": []
+}

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

@@ -0,0 +1,24 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.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
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+
+// src/core/managers/dependency-node.ts
+var exports_dependency_node = {};
+module.exports = __toCommonJS(exports_dependency_node);
+
+//# debugId=A0317A58371FD5EC64756E2164756E21

package/dist/cjs/core/managers/dependency-node.cjs.map

@@ -0,0 +1,9 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [
+  ],
+  "mappings": "",
+  "debugId": "A0317A58371FD5EC64756E2164756E21",
+  "names": []
+}

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

@@ -0,0 +1,433 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.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
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/core/managers/evaluation-manager.ts
+var exports_evaluation_manager = {};
+__export(exports_evaluation_manager, {
+  EvaluationManager: () => EvaluationManager
+});
+module.exports = __toCommonJS(exports_evaluation_manager);
+var import_flags = require("src/debug/flags");
+var import_ast_evaluation_node = require("src/evaluator/dependency-nodes/ast-evaluation-node");
+var import_cell_value_node = require("src/evaluator/dependency-nodes/cell-value-node");
+var import_evaluation_context = require("src/evaluator/evaluation-context");
+var import_evaluation_error = require("src/evaluator/evaluation-error");
+var import_range_evaluation_node = require("src/evaluator/range-evaluation-node");
+var import_formatter = require("src/parser/formatter");
+var import_types = require("../types.cjs");
+var import_utils = require("../utils.cjs");
+var import_spill_meta_node = require("src/evaluator/dependency-nodes/spill-meta-node");
+var import_empty_cell_evaluation_node = require("src/evaluator/dependency-nodes/empty-cell-evaluation-node");
+
+class EvaluationManager {
+  workbookManager;
+  tableManager;
+  formulaEvaluator;
+  dependencyManager;
+  isEvaluating = false;
+  constructor(workbookManager, tableManager, formulaEvaluator, dependencyManager) {
+    this.workbookManager = workbookManager;
+    this.tableManager = tableManager;
+    this.formulaEvaluator = formulaEvaluator;
+    this.dependencyManager = dependencyManager;
+  }
+  clearEvaluationCache() {
+    this.dependencyManager.clearEvaluationCache();
+  }
+  evaluationResultToSerializedValue(evaluation, cellAddress, debug) {
+    if (evaluation.type !== "error" && evaluation.type !== "awaiting-evaluation") {
+      const value = evaluation.result;
+      return value.type === "infinity" ? value.sign === "positive" ? "INFINITY" : "-INFINITY" : value.value;
+    }
+    if (evaluation.type === "awaiting-evaluation") {
+      return evaluation.errAddress.key + " is awaiting evaluation of " + evaluation.waitingFor.key;
+    }
+    if (debug) {
+      const errAddress = evaluation.errAddress.key;
+      if (errAddress === import_utils.cellAddressToKey(cellAddress)) {
+        return evaluation.err + " " + evaluation.message;
+      }
+      return evaluation.err + " in " + evaluation.errAddress.key + " " + evaluation.message;
+    }
+    return evaluation.err;
+  }
+  evaluateEmptyCell(node) {
+    node.resetDirectDepsUpdated();
+    if (node.resolved) {
+      const result = node.evaluationResult;
+      if (result && result.type !== "awaiting-evaluation") {
+        return;
+      }
+    }
+    const ctx = new import_evaluation_context.EvaluationContext(this.tableManager, node, node.cellAddress);
+    const inSpilled = this.dependencyManager.getSpillValue(node.cellAddress);
+    if (inSpilled) {
+      const spillTarget = this.dependencyManager.getSpilledAddress(node.cellAddress, inSpilled);
+      const spillOriginKey = import_utils.cellAddressToKey(inSpilled.origin).replace(/^[^:]+:/, "spill-meta:");
+      const spillMetaNode = this.dependencyManager.getSpillMetaNode(spillOriginKey);
+      node.addDependency(spillMetaNode);
+      const result = spillMetaNode.evaluationResult;
+      if (result.type === "spilled-values") {
+        const evaluation = import_utils.captureEvaluationErrors(spillMetaNode, () => {
+          return result.evaluate(spillTarget.spillOffset, ctx);
+        });
+        node.setEvaluationResult(evaluation);
+      }
+    } else {
+      node.upgradeFrontierDependencies();
+      const evaluationResult = {
+        type: "value",
+        result: this.convertScalarValueToCellValue("")
+      };
+      node.setEvaluationResult(evaluationResult);
+    }
+  }
+  evaluateRangeNode(node) {
+    if (node.resolved) {
+      return;
+    }
+    node.resetDirectDepsUpdated();
+    const result = import_utils.captureEvaluationErrors(node, () => {
+      node.upgradeFrontierDependencies();
+      const evalOrder = node.getRangeEvalOrder();
+      const results = [];
+      for (const entry of evalOrder) {
+        if (entry.type === "value") {
+          const entryAddress = entry.address;
+          const result2 = entry.node.evaluationResult;
+          const relativePos = {
+            x: entryAddress.colIndex - node.address.range.start.col,
+            y: entryAddress.rowIndex - node.address.range.start.row
+          };
+          results.push({ result: result2, relativePos });
+        } else if (entry.type === "empty_cell" || entry.type === "empty_range") {
+          for (const candidateNode of entry.candidates) {
+            if (candidateNode.evaluationResult.type === "spilled-values") {
+              const spillArea = candidateNode.evaluationResult.spillArea(candidateNode.cellAddress);
+              if (entry.type === "empty_range") {
+                const intersects = import_utils.checkRangeIntersection(spillArea, entry.address.range);
+                if (intersects) {
+                  const ctx = new import_evaluation_context.EvaluationContext(this.tableManager, node, candidateNode.cellAddress);
+                  const spilledResults = candidateNode.evaluationResult.evaluateAllCells.call(this.formulaEvaluator, {
+                    context: ctx,
+                    evaluate: candidateNode.evaluationResult.evaluate,
+                    intersection: entry.address.range,
+                    origin: candidateNode.cellAddress,
+                    lookupOrder: "col-major"
+                  });
+                  if (spilledResults.type === "values") {
+                    results.push(...spilledResults.values);
+                  } else {
+                    return spilledResults;
+                  }
+                }
+              } else {
+                const intersects = import_utils.isCellInRange(entry.address, spillArea);
+                if (intersects) {
+                  const relativePos = {
+                    x: entry.address.colIndex - candidateNode.cellAddress.colIndex,
+                    y: entry.address.rowIndex - candidateNode.cellAddress.rowIndex
+                  };
+                  const ctx = new import_evaluation_context.EvaluationContext(this.tableManager, node, candidateNode.cellAddress);
+                  const spilledResult = candidateNode.evaluationResult.evaluate(relativePos, ctx);
+                  results.push({
+                    relativePos: {
+                      x: entry.address.colIndex - node.address.range.start.col,
+                      y: entry.address.rowIndex - node.address.range.start.row
+                    },
+                    result: spilledResult
+                  });
+                }
+              }
+            }
+          }
+        }
+      }
+      return {
+        type: "values",
+        values: results
+      };
+    });
+    node.setResult(result);
+  }
+  evaluateCellNode(node) {
+    if (node.resolved) {
+      return;
+    }
+    node.resetDirectDepsUpdated();
+    const ctx = new import_evaluation_context.EvaluationContext(this.tableManager, node, node.cellAddress);
+    if (node instanceof import_cell_value_node.CellValueNode && node.spillMeta) {
+      const spillOrigin = node.spillMeta;
+      if (spillOrigin.evaluationResult.type === "spilled-values") {
+        const result = spillOrigin.evaluationResult.evaluate({ x: 0, y: 0 }, ctx);
+        node.setEvaluationResult(result);
+        return;
+      }
+    }
+    let content;
+    try {
+      content = this.workbookManager.getSerializedCellValue(node.cellAddress);
+    } catch (err) {
+      const evaluationResult = {
+        type: "error",
+        err: import_types.FormulaError.ERROR,
+        message: "Syntax error",
+        errAddress: node
+      };
+      node.setEvaluationResult(evaluationResult);
+      return;
+    }
+    if (typeof content !== "string" || !content.startsWith("=")) {
+      if (node instanceof import_spill_meta_node.SpillMetaNode) {
+        node.setEvaluationResult({
+          type: "does-not-spill"
+        });
+        return;
+      }
+      const result = {
+        type: "value",
+        result: this.convertScalarValueToCellValue(content)
+      };
+      node.setEvaluationResult(result);
+      return;
+    }
+    let evaluation = import_utils.captureEvaluationErrors(node, () => this.formulaEvaluator.evaluateFormula(content.slice(1), ctx));
+    if (evaluation.type === "spilled-values") {
+      const spillArea = evaluation.spillArea(node.cellAddress);
+      if (!this.canSpill(node.cellAddress, spillArea)) {
+        evaluation = {
+          type: "error",
+          err: import_types.FormulaError.SPILL,
+          message: "Cannot spill - area is blocked",
+          errAddress: node
+        };
+      } else {
+        this.dependencyManager.setSpilledValue(node.key, {
+          spillOnto: spillArea,
+          origin: node.cellAddress
+        });
+      }
+      if (node instanceof import_spill_meta_node.SpillMetaNode) {
+        node.setEvaluationResult(evaluation);
+      } else {
+        const spillMetaNode = this.dependencyManager.getSpillMetaNode(node.key.replace(/^[^:]+:/, "spill-meta:"));
+        node.addDependency(spillMetaNode);
+        node.setSpillMetaNode(spillMetaNode);
+        spillMetaNode.setEvaluationResult(evaluation);
+        if (evaluation.type === "spilled-values") {
+          const originResult = evaluation.evaluate({ x: 0, y: 0 }, ctx);
+          node.setEvaluationResult(originResult);
+        } else {
+          node.setEvaluationResult(evaluation);
+        }
+      }
+      return;
+    }
+    if (evaluation.type === "value") {
+      if (node instanceof import_spill_meta_node.SpillMetaNode) {
+        node.setEvaluationResult({
+          type: "does-not-spill"
+        });
+        return;
+      } else {
+        node.setEvaluationResult(evaluation);
+        return;
+      }
+    }
+    node.setEvaluationResult(evaluation);
+  }
+  evaluateDependencyNode(dependencyKey) {
+    if (dependencyKey.startsWith("empty:")) {
+      this.evaluateEmptyCell(this.dependencyManager.getEmptyCellNode(dependencyKey));
+      return;
+    }
+    if (dependencyKey.startsWith("range:")) {
+      this.evaluateRangeNode(this.dependencyManager.getRangeNode(dependencyKey));
+      return;
+    }
+    if (dependencyKey.startsWith("cell-value:")) {
+      const node = this.dependencyManager.getCellValueOrEmptyCellNode(dependencyKey);
+      if (node instanceof import_empty_cell_evaluation_node.EmptyCellEvaluationNode) {
+        this.evaluateEmptyCell(node);
+        return;
+      }
+      this.evaluateCellNode(node);
+      return;
+    }
+    if (dependencyKey.startsWith("ast:")) {
+      return;
+    }
+    if (dependencyKey.startsWith("spill-meta:")) {
+      const node = this.dependencyManager.getSpillMetaOrEmptySpillMetaNode(dependencyKey);
+      if (node instanceof import_empty_cell_evaluation_node.EmptyCellEvaluationNode) {
+        this.evaluateEmptyCell(node);
+        return;
+      }
+      this.evaluateCellNode(node);
+      return;
+    }
+    throw new Error("Invalid dependency key: " + dependencyKey);
+  }
+  evaluateCell(node) {
+    if (this.isEvaluating) {
+      throw new Error("Evaluation in progress");
+    }
+    this.isEvaluating = true;
+    const sheet = this.workbookManager.getSheet(node.cellAddress);
+    if (!sheet) {
+      this.isEvaluating = false;
+      throw new import_evaluation_error.SheetNotFoundError(node.cellAddress.sheetName);
+    }
+    let precalculatedPlan;
+    let requiresReRun = true;
+    while (requiresReRun) {
+      requiresReRun = false;
+      const evaluationPlan = precalculatedPlan ?? this.dependencyManager.buildEvaluationOrder(node);
+      if (evaluationPlan.hasCycle) {
+        const evaluationResult = {
+          type: "error",
+          err: import_types.FormulaError.CYCLE,
+          message: Array.from(evaluationPlan.cycleNodes ?? []).map((node2) => node2.key).join(" -> "),
+          errAddress: node
+        };
+        if (evaluationPlan.cycleNodes) {
+          for (const node2 of evaluationPlan.cycleNodes) {
+            if (!(node2 instanceof import_range_evaluation_node.RangeEvaluationNode)) {
+              if (node2 instanceof import_ast_evaluation_node.AstEvaluationNode) {
+                node2.setEvaluationResult(evaluationResult);
+              } else {
+                node2.setEvaluationResult(evaluationResult);
+              }
+            }
+          }
+        }
+        this.isEvaluating = false;
+      }
+      const timeStart = performance.now();
+      const durations = [];
+      let numResolved = 0;
+      if (import_flags.flags.isProfiling && evaluationPlan.evaluationOrder.size > -1) {}
+      evaluationPlan.evaluationOrder.forEach((dependency) => {
+        const start = performance.now();
+        if (dependency.resolved) {
+          numResolved++;
+        }
+        this.evaluateDependencyNode(dependency.key);
+        const end = performance.now();
+        if (import_flags.flags.isProfiling && evaluationPlan.evaluationOrder.size > -1) {
+          durations.push({ duration: end - start, key: dependency.key });
+        }
+      });
+      if (import_flags.flags.isProfiling && evaluationPlan.evaluationOrder.size > -1) {}
+      if (import_flags.flags.isProfiling && evaluationPlan.evaluationOrder.size > -1) {
+        const percentResolved = Math.round(100 * numResolved / evaluationPlan.evaluationOrder.size);
+        const avgDuration = durations.reduce((a, b) => a + b.duration, 0) / durations.length || 0;
+        console.log(`%c[Evaluation] %c${evaluationPlan.evaluationOrder.size} deps | %c${(performance.now() - timeStart).toFixed(1)}ms | %c${percentResolved}% resolved | %c${avgDuration.toFixed(2)}ms avg`, "color:#83aaff;font-weight:bold;", "color:#fff;font-weight:bold;", "color:#7fff9e", "color:#85baff", "color:#ffdfa3");
+      }
+      this.dependencyManager.markResolvedNodes(node);
+      const nextEvaluationPlan = this.dependencyManager.buildEvaluationOrder(node);
+      this.dependencyManager.updateResolvedSCCs(nextEvaluationPlan);
+      precalculatedPlan = nextEvaluationPlan;
+      if (nextEvaluationPlan.hash !== evaluationPlan.hash) {
+        requiresReRun = true;
+      } else {
+        this.isEvaluating = false;
+        return;
+      }
+    }
+    this.isEvaluating = false;
+  }
+  convertScalarValueToCellValue(val) {
+    if (typeof val === "number") {
+      return { type: "number", value: val };
+    }
+    if (typeof val === "boolean") {
+      return { type: "boolean", value: val };
+    }
+    if (typeof val === "undefined") {
+      return { type: "string", value: "" };
+    }
+    return { type: "string", value: val };
+  }
+  canSpill(spillCandidate, spillArea) {
+    const sheet = this.workbookManager.getSheet(spillCandidate);
+    if (!sheet) {
+      throw new import_evaluation_error.SheetNotFoundError(spillCandidate.sheetName);
+    }
+    const cellId = import_utils.getCellReference(spillCandidate);
+    const content = sheet.content.get(cellId);
+    if (!content) {
+      throw new import_evaluation_error.EvaluationError(import_types.FormulaError.REF, `Cell not found: ${cellId}`);
+    }
+    for (const spilledValue of this.dependencyManager.spilledValues) {
+      if (spilledValue.origin.workbookName !== spillCandidate.workbookName || spilledValue.origin.sheetName !== spillCandidate.sheetName) {
+        continue;
+      }
+      if (spilledValue.origin.colIndex === spillCandidate.colIndex && spilledValue.origin.rowIndex === spillCandidate.rowIndex) {
+        continue;
+      }
+      if (import_utils.checkRangeIntersection(spillArea, spilledValue.spillOnto)) {
+        return false;
+      }
+    }
+    for (const key of sheet.content.keys()) {
+      const cellAddress = import_utils.parseCellReference(key);
+      const endCol = spillArea.end.col;
+      const endRow = spillArea.end.row;
+      if (cellAddress.colIndex === spillCandidate.colIndex && cellAddress.rowIndex === spillCandidate.rowIndex) {
+        continue;
+      }
+      if (endCol.type === "number" && endRow.type === "number") {
+        if (cellAddress.colIndex >= spillArea.start.col && cellAddress.colIndex <= endCol.value && cellAddress.rowIndex >= spillArea.start.row && cellAddress.rowIndex <= endRow.value) {
+          if (import_formatter.normalizeSerializedCellValue(sheet.content.get(key)) !== undefined) {
+            return false;
+          }
+        }
+      }
+    }
+    return true;
+  }
+  getCellEvaluationResult(cellAddress) {
+    if (this.isEvaluating) {
+      throw new Error("Evaluation in progress");
+    }
+    const nodeKey = import_utils.cellAddressToKey(cellAddress);
+    const node = this.dependencyManager.getCellValueOrEmptyCellNode(nodeKey);
+    const sheet = this.workbookManager.getSheet(cellAddress);
+    if (!sheet) {
+      throw new import_evaluation_error.SheetNotFoundError(cellAddress.sheetName);
+    }
+    if (node.evaluationResult.type === "awaiting-evaluation") {
+      this.evaluateCell(node);
+    }
+    const result = node.evaluationResult;
+    return result;
+  }
+}
+
+//# debugId=ED71727AFAD08E2464756E2164756E21