@ricsam/formula-engine 0.0.1

package/dist/mjs/core/managers/dependency-manager.mjs.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.mjs\";\nimport { isCellInRange, keyToCellAddress } from \"../utils.mjs\";\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.mjs\";\nimport type {\n  CellNodeKeyDictionary,\n  CellNodeType,\n  DependencyNode,\n} from \"./dependency-node.mjs\";\nimport { WorkbookManager } from \"./workbook-manager.mjs\";\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.mjs\").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.mjs\").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.mjs\").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.mjs\").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": "D496BB6F54AC889364756E2164756E21",
+  "names": []
+}

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

@@ -0,0 +1,2 @@
+
+//# debugId=C117BE2E22F5DB9864756E2164756E21

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

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

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

@@ -0,0 +1,415 @@
+// src/core/managers/evaluation-manager.ts
+import { flags } from "src/debug/flags";
+import { AstEvaluationNode } from "src/evaluator/dependency-nodes/ast-evaluation-node";
+import { CellValueNode } from "src/evaluator/dependency-nodes/cell-value-node";
+import { EvaluationContext } from "src/evaluator/evaluation-context";
+import {
+  EvaluationError,
+  SheetNotFoundError
+} from "src/evaluator/evaluation-error";
+import { RangeEvaluationNode } from "src/evaluator/range-evaluation-node";
+import { normalizeSerializedCellValue } from "src/parser/formatter";
+import {
+  FormulaError
+} from "../types.mjs";
+import {
+  captureEvaluationErrors,
+  cellAddressToKey,
+  checkRangeIntersection,
+  getCellReference,
+  isCellInRange,
+  parseCellReference
+} from "../utils.mjs";
+import { SpillMetaNode } from "src/evaluator/dependency-nodes/spill-meta-node";
+import { EmptyCellEvaluationNode } from "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 === 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 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 = 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 = 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 = 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 = checkRangeIntersection(spillArea, entry.address.range);
+                if (intersects) {
+                  const ctx = new 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 = 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 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 EvaluationContext(this.tableManager, node, node.cellAddress);
+    if (node instanceof 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: FormulaError.ERROR,
+        message: "Syntax error",
+        errAddress: node
+      };
+      node.setEvaluationResult(evaluationResult);
+      return;
+    }
+    if (typeof content !== "string" || !content.startsWith("=")) {
+      if (node instanceof SpillMetaNode) {
+        node.setEvaluationResult({
+          type: "does-not-spill"
+        });
+        return;
+      }
+      const result = {
+        type: "value",
+        result: this.convertScalarValueToCellValue(content)
+      };
+      node.setEvaluationResult(result);
+      return;
+    }
+    let evaluation = 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: FormulaError.SPILL,
+          message: "Cannot spill - area is blocked",
+          errAddress: node
+        };
+      } else {
+        this.dependencyManager.setSpilledValue(node.key, {
+          spillOnto: spillArea,
+          origin: node.cellAddress
+        });
+      }
+      if (node instanceof 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 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 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 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 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: 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 RangeEvaluationNode)) {
+              if (node2 instanceof AstEvaluationNode) {
+                node2.setEvaluationResult(evaluationResult);
+              } else {
+                node2.setEvaluationResult(evaluationResult);
+              }
+            }
+          }
+        }
+        this.isEvaluating = false;
+      }
+      const timeStart = performance.now();
+      const durations = [];
+      let numResolved = 0;
+      if (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 (flags.isProfiling && evaluationPlan.evaluationOrder.size > -1) {
+          durations.push({ duration: end - start, key: dependency.key });
+        }
+      });
+      if (flags.isProfiling && evaluationPlan.evaluationOrder.size > -1) {}
+      if (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 SheetNotFoundError(spillCandidate.sheetName);
+    }
+    const cellId = getCellReference(spillCandidate);
+    const content = sheet.content.get(cellId);
+    if (!content) {
+      throw new EvaluationError(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 (checkRangeIntersection(spillArea, spilledValue.spillOnto)) {
+        return false;
+      }
+    }
+    for (const key of sheet.content.keys()) {
+      const cellAddress = 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 (normalizeSerializedCellValue(sheet.content.get(key)) !== undefined) {
+            return false;
+          }
+        }
+      }
+    }
+    return true;
+  }
+  getCellEvaluationResult(cellAddress) {
+    if (this.isEvaluating) {
+      throw new Error("Evaluation in progress");
+    }
+    const nodeKey = cellAddressToKey(cellAddress);
+    const node = this.dependencyManager.getCellValueOrEmptyCellNode(nodeKey);
+    const sheet = this.workbookManager.getSheet(cellAddress);
+    if (!sheet) {
+      throw new SheetNotFoundError(cellAddress.sheetName);
+    }
+    if (node.evaluationResult.type === "awaiting-evaluation") {
+      this.evaluateCell(node);
+    }
+    const result = node.evaluationResult;
+    return result;
+  }
+}
+export {
+  EvaluationManager
+};
+
+//# debugId=4C5D74A0388D284A64756E2164756E21

package/dist/mjs/core/managers/evaluation-manager.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/core/managers/evaluation-manager.ts"],
+  "sourcesContent": [
+    "import { flags } from \"src/debug/flags\";\nimport { AstEvaluationNode } from \"src/evaluator/dependency-nodes/ast-evaluation-node\";\nimport { CellValueNode } from \"src/evaluator/dependency-nodes/cell-value-node\";\nimport { EvaluationContext } from \"src/evaluator/evaluation-context\";\nimport {\n  EvaluationError,\n  SheetNotFoundError,\n} from \"src/evaluator/evaluation-error\";\nimport { RangeEvaluationNode } from \"src/evaluator/range-evaluation-node\";\nimport { normalizeSerializedCellValue } from \"src/parser/formatter\";\nimport { FormulaEvaluator } from \"../../evaluator/formula-evaluator.mjs\";\nimport {\n  FormulaError,\n  type CellAddress,\n  type CellInRangeResult,\n  type CellValue,\n  type ErrorEvaluationResult,\n  type EvaluateAllCellsResult,\n  type EvaluationOrder,\n  type FunctionEvaluationResult,\n  type SerializedCellValue,\n  type SingleEvaluationResult,\n  type SpreadsheetRange,\n  type TableDefinition,\n  type ValueEvaluationResult,\n} from \"../types.mjs\";\nimport {\n  captureEvaluationErrors,\n  cellAddressToKey,\n  checkRangeIntersection,\n  getCellReference,\n  isCellInRange,\n  isRangeOneCell,\n  keyToCellAddress,\n  parseCellReference,\n} from \"../utils.mjs\";\nimport type { DependencyManager } from \"./dependency-manager.mjs\";\nimport type { WorkbookManager } from \"./workbook-manager.mjs\";\nimport { SpillMetaNode } from \"src/evaluator/dependency-nodes/spill-meta-node\";\nimport { EmptyCellEvaluationNode } from \"src/evaluator/dependency-nodes/empty-cell-evaluation-node\";\nimport type { TableManager } from \"./table-manager.mjs\";\n\nexport class EvaluationManager {\n  private isEvaluating = false;\n\n  constructor(\n    private workbookManager: WorkbookManager,\n    private tableManager: TableManager,\n    private formulaEvaluator: FormulaEvaluator,\n    private dependencyManager: DependencyManager\n  ) {}\n\n  clearEvaluationCache(): void {\n    this.dependencyManager.clearEvaluationCache();\n  }\n\n  evaluationResultToSerializedValue(\n    evaluation: SingleEvaluationResult,\n    cellAddress: CellAddress,\n    debug?: boolean\n  ): SerializedCellValue {\n    if (\n      evaluation.type !== \"error\" &&\n      evaluation.type !== \"awaiting-evaluation\"\n    ) {\n      const value = evaluation.result;\n\n      return value.type === \"infinity\"\n        ? value.sign === \"positive\"\n          ? \"INFINITY\"\n          : \"-INFINITY\"\n        : value.value;\n    }\n\n    if (evaluation.type === \"awaiting-evaluation\") {\n      return (\n        evaluation.errAddress.key +\n        \" is awaiting evaluation of \" +\n        evaluation.waitingFor.key\n      );\n    }\n\n    if (debug) {\n      const errAddress = evaluation.errAddress.key;\n      if (errAddress === cellAddressToKey(cellAddress)) {\n        return evaluation.err + \" \" + evaluation.message;\n      }\n      return (\n        evaluation.err +\n        \" in \" +\n        evaluation.errAddress.key +\n        \" \" +\n        evaluation.message\n      );\n    }\n\n    return evaluation.err;\n  }\n\n  evaluateEmptyCell(node: EmptyCellEvaluationNode): void {\n    node.resetDirectDepsUpdated();\n\n    if (node.resolved) {\n      const result = node.evaluationResult;\n      if (result && result.type !== \"awaiting-evaluation\") {\n        return;\n      }\n    }\n\n    const ctx = new EvaluationContext(\n      this.tableManager,\n      node,\n      node.cellAddress\n    );\n    const inSpilled = this.dependencyManager.getSpillValue(node.cellAddress);\n\n    if (inSpilled) {\n      // if we are spilling then we can just add the spill origin as a dependency and evaluate the spilled value\n      const spillTarget = this.dependencyManager.getSpilledAddress(\n        node.cellAddress,\n        inSpilled\n      );\n      const spillOriginKey = cellAddressToKey(inSpilled.origin).replace(\n        /^[^:]+:/,\n        \"spill-meta:\"\n      );\n      const spillMetaNode =\n        this.dependencyManager.getSpillMetaNode(spillOriginKey);\n      node.addDependency(spillMetaNode);\n      const result = spillMetaNode.evaluationResult;\n      if (result.type === \"spilled-values\") {\n        // let's evaluate the spilled value to extract dependencies\n        const evaluation = captureEvaluationErrors(spillMetaNode, () => {\n          return result.evaluate(spillTarget.spillOffset, ctx);\n        });\n        node.setEvaluationResult(evaluation);\n      }\n    } else {\n      // upgrade any frontier dependencies that spill into the range\n      node.upgradeFrontierDependencies();\n\n      const evaluationResult: SingleEvaluationResult = {\n        type: \"value\",\n        result: this.convertScalarValueToCellValue(\"\"),\n      };\n      // for now let's just store the empty value, the next time the cell is evaluated isSpilled will be true and the spilled value will be evaluated\n      node.setEvaluationResult(evaluationResult);\n    }\n  }\n\n  evaluateRangeNode(node: RangeEvaluationNode): void {\n    if (node.resolved) {\n      return;\n    }\n\n    node.resetDirectDepsUpdated();\n\n    const result = captureEvaluationErrors(node, (): EvaluateAllCellsResult => {\n      node.upgradeFrontierDependencies();\n\n      const evalOrder = node.getRangeEvalOrder();\n\n      const results: CellInRangeResult[] = [];\n\n      for (const entry of evalOrder) {\n        if (entry.type === \"value\") {\n          const entryAddress = entry.address;\n          const result = entry.node.evaluationResult;\n\n          const relativePos = {\n            x: entryAddress.colIndex - node.address.range.start.col,\n            y: entryAddress.rowIndex - node.address.range.start.row,\n          };\n\n          results.push({ result: result, relativePos });\n        } else if (\n          entry.type === \"empty_cell\" ||\n          entry.type === \"empty_range\"\n        ) {\n          for (const candidateNode of entry.candidates) {\n            if (candidateNode.evaluationResult.type === \"spilled-values\") {\n              const spillArea = candidateNode.evaluationResult.spillArea(\n                candidateNode.cellAddress\n              );\n              if (entry.type === \"empty_range\") {\n                const intersects = checkRangeIntersection(\n                  spillArea,\n                  entry.address.range\n                );\n                if (intersects) {\n                  // When a spilled range intersects with our target range, we need to evaluate\n                  // only the cells that fall within the intersection area.\n                  //\n                  // Example: If cell A10 contains a spilled range that covers A10:B11,\n                  // and our target range is B10:INFINITY, then we only want to evaluate\n                  // the intersection B10:B11 from the spilled range.\n                  //\n                  // The evaluateAllCells method expects the intersection to be passed\n                  // so it can limit evaluation to only the relevant cells.\n                  const ctx = new EvaluationContext(\n                    this.tableManager,\n                    node,\n                    candidateNode.cellAddress\n                  );\n                  const spilledResults =\n                    candidateNode.evaluationResult.evaluateAllCells.call(\n                      this.formulaEvaluator,\n                      {\n                        context: ctx,\n                        evaluate: candidateNode.evaluationResult.evaluate,\n                        intersection: entry.address.range,\n                        origin: candidateNode.cellAddress,\n                        lookupOrder: \"col-major\",\n                      }\n                    );\n\n                  if (spilledResults.type === \"values\") {\n                    results.push(...spilledResults.values);\n                  } else {\n                    return spilledResults;\n                  }\n                }\n              } else {\n                const intersects = isCellInRange(entry.address, spillArea);\n                if (intersects) {\n                  // When a spilled range intersects with our target range, we need to evaluate\n                  // only the cells that fall within the intersection area.\n                  //\n                  // Example: If cell A10 contains a spilled range that covers A10:B11,\n                  // and our target range is B10:INFINITY, then we only want to evaluate\n                  // the intersection B10:B11 from the spilled range.\n                  //\n                  // The evaluateAllCells method expects the intersection to be passed\n                  // so it can limit evaluation to only the relevant cells.\n\n                  const relativePos = {\n                    x:\n                      entry.address.colIndex -\n                      candidateNode.cellAddress.colIndex,\n                    y:\n                      entry.address.rowIndex -\n                      candidateNode.cellAddress.rowIndex,\n                  };\n                  const ctx = new EvaluationContext(\n                    this.tableManager,\n                    node,\n                    candidateNode.cellAddress\n                  );\n                  const spilledResult = candidateNode.evaluationResult.evaluate(\n                    relativePos,\n                    ctx\n                  );\n\n                  results.push({\n                    relativePos: {\n                      x: entry.address.colIndex - node.address.range.start.col,\n                      y: entry.address.rowIndex - node.address.range.start.row,\n                    },\n                    result: spilledResult,\n                  });\n                }\n              }\n            }\n          }\n        }\n      }\n\n      return {\n        type: \"values\",\n        values: results,\n      };\n    });\n\n    node.setResult(result);\n  }\n\n  evaluateCellNode(node: CellValueNode | SpillMetaNode): void {\n    // Enable caching for resolved nodes\n    if (node.resolved) {\n      return;\n    }\n\n    node.resetDirectDepsUpdated();\n\n    const ctx = new EvaluationContext(\n      this.tableManager,\n      node,\n      node.cellAddress\n    );\n\n    if (node instanceof CellValueNode && node.spillMeta) {\n      // we are evaluating a e.g. A1 in A1=SEQUENCE(10), where we want the value in the cell in A1, i.e. 1\n      // As A1 is already pointing to a spill meta node, everything has been setup already,\n      // we just need to evaluate the spill origin and assign the result to the currentDepNode\n      const spillOrigin = node.spillMeta;\n      if (spillOrigin.evaluationResult.type === \"spilled-values\") {\n        const result = spillOrigin.evaluationResult.evaluate(\n          { x: 0, y: 0 },\n          ctx\n        );\n        node.setEvaluationResult(result);\n        return;\n      }\n    }\n\n    let content: SerializedCellValue;\n    try {\n      content = this.workbookManager.getSerializedCellValue(node.cellAddress);\n    } catch (err) {\n      const evaluationResult: ErrorEvaluationResult = {\n        type: \"error\",\n        err: FormulaError.ERROR,\n        message: \"Syntax error\",\n        errAddress: node,\n      };\n      node.setEvaluationResult(evaluationResult);\n      return;\n    }\n\n    if (typeof content !== \"string\" || !content.startsWith(\"=\")) {\n      if (node instanceof SpillMetaNode) {\n        node.setEvaluationResult({\n          type: \"does-not-spill\",\n        });\n        return;\n      }\n      // Static value cells cannot have frontier dependencies\n      const result: ValueEvaluationResult = {\n        type: \"value\",\n        result: this.convertScalarValueToCellValue(content),\n      };\n      node.setEvaluationResult(result);\n      return;\n    }\n\n    let evaluation: FunctionEvaluationResult = captureEvaluationErrors(\n      node,\n      () => this.formulaEvaluator.evaluateFormula(content.slice(1), ctx)\n    );\n\n    // the evaluated cell IS A spilling formula, e.g. if dependencyKey points to A1, then the formula is e.g. A1=SEQUENCE(10), or A1=A3:B5\n    if (evaluation.type === \"spilled-values\") {\n      const spillArea = evaluation.spillArea(node.cellAddress);\n\n      if (!this.canSpill(node.cellAddress, spillArea)) {\n        // Override evaluation with SPILL error, but continue execution to set up nodes\n        evaluation = {\n          type: \"error\",\n          err: FormulaError.SPILL,\n          message: \"Cannot spill - area is blocked\",\n          errAddress: node,\n        };\n      } else {\n        // Spill succeeds - register it\n        this.dependencyManager.setSpilledValue(node.key, {\n          spillOnto: spillArea,\n          origin: node.cellAddress,\n        });\n      }\n\n      // Set up spill meta node and evaluation results (even if spill failed)\n      if (node instanceof SpillMetaNode) {\n        // we have already setup an origin/spill meta node relationship,\n        // so we are just reevaluating the spill meta node here\n        node.setEvaluationResult(evaluation);\n      } else {\n        const spillMetaNode = this.dependencyManager.getSpillMetaNode(\n          node.key.replace(/^[^:]+:/, \"spill-meta:\")\n        );\n\n        node.addDependency(spillMetaNode);\n        node.setSpillMetaNode(spillMetaNode);\n        spillMetaNode.setEvaluationResult(evaluation);\n\n        if (evaluation.type === \"spilled-values\") {\n          const originResult = evaluation.evaluate({ x: 0, y: 0 }, ctx);\n          node.setEvaluationResult(originResult);\n        } else {\n          // Spill failed - set error on origin cell\n          node.setEvaluationResult(evaluation);\n        }\n      }\n      return;\n    }\n\n    if (evaluation.type === \"value\") {\n      if (node instanceof SpillMetaNode) {\n        node.setEvaluationResult({\n          type: \"does-not-spill\",\n        });\n        return;\n      } else {\n        node.setEvaluationResult(evaluation);\n        return;\n      }\n    }\n\n    node.setEvaluationResult(evaluation);\n  }\n\n  evaluateDependencyNode(dependencyKey: string): void {\n    if (dependencyKey.startsWith(\"empty:\")) {\n      this.evaluateEmptyCell(\n        this.dependencyManager.getEmptyCellNode(dependencyKey)\n      );\n      return;\n    }\n    if (dependencyKey.startsWith(\"range:\")) {\n      this.evaluateRangeNode(\n        this.dependencyManager.getRangeNode(dependencyKey)\n      );\n      return;\n    }\n    if (dependencyKey.startsWith(\"cell-value:\")) {\n      const node =\n        this.dependencyManager.getCellValueOrEmptyCellNode(dependencyKey);\n      if (node instanceof EmptyCellEvaluationNode) {\n        this.evaluateEmptyCell(node);\n        return;\n      }\n      this.evaluateCellNode(node);\n      return;\n    }\n    if (dependencyKey.startsWith(\"ast:\")) {\n      // let the evaluateCellNode handle the evaluation\n      // through formulaEvaluator.evaluateNode,\n      // because an AST node must be evaluated in the context of the cell it is in\n      return;\n    }\n    if (dependencyKey.startsWith(\"spill-meta:\")) {\n      const node =\n        this.dependencyManager.getSpillMetaOrEmptySpillMetaNode(dependencyKey);\n      if (node instanceof EmptyCellEvaluationNode) {\n        this.evaluateEmptyCell(node);\n        return;\n      }\n      this.evaluateCellNode(node);\n      return;\n    }\n    throw new Error(\"Invalid dependency key: \" + dependencyKey);\n  }\n\n  /**\n   * Evaluates a cell by building the evaluation order and evaluating the dependencies in order\n   */\n  evaluateCell(node: CellValueNode | EmptyCellEvaluationNode): void {\n    if (this.isEvaluating) {\n      throw new Error(\"Evaluation in progress\");\n    }\n    this.isEvaluating = true;\n    const sheet = this.workbookManager.getSheet(node.cellAddress);\n    if (!sheet) {\n      this.isEvaluating = false;\n      throw new SheetNotFoundError(node.cellAddress.sheetName);\n    }\n\n    let precalculatedPlan: EvaluationOrder | undefined;\n\n    let requiresReRun = true;\n    while (requiresReRun) {\n      requiresReRun = false;\n\n      // Use DependencyManager to build evaluation order\n      const evaluationPlan =\n        precalculatedPlan ?? this.dependencyManager.buildEvaluationOrder(node);\n\n      if (evaluationPlan.hasCycle) {\n        const evaluationResult: ErrorEvaluationResult = {\n          type: \"error\",\n          err: FormulaError.CYCLE,\n          message: Array.from(evaluationPlan.cycleNodes ?? [])\n            .map((node) => node.key)\n            .join(\" -> \"),\n          errAddress: node,\n        };\n        // cycle detected\n        if (evaluationPlan.cycleNodes) {\n          for (const node of evaluationPlan.cycleNodes) {\n            if (!(node instanceof RangeEvaluationNode)) {\n              if (node instanceof AstEvaluationNode) {\n                node.setEvaluationResult(evaluationResult);\n              } else {\n                node.setEvaluationResult(evaluationResult);\n              }\n            }\n          }\n        }\n        this.isEvaluating = false;\n      }\n\n      // Evaluate all dependencies in order\n      const timeStart = performance.now();\n      const durations: { duration: number; key: string }[] = [];\n      let numResolved = 0;\n      if (flags.isProfiling && evaluationPlan.evaluationOrder.size > -1) {\n        // console.profile();\n      }\n      evaluationPlan.evaluationOrder.forEach((dependency) => {\n        const start = performance.now();\n        if (dependency.resolved) {\n          numResolved++;\n        }\n        this.evaluateDependencyNode(dependency.key);\n\n        const end = performance.now();\n        if (flags.isProfiling && evaluationPlan.evaluationOrder.size > -1) {\n          durations.push({ duration: end - start, key: dependency.key });\n        }\n      });\n      if (flags.isProfiling && evaluationPlan.evaluationOrder.size > -1) {\n        // console.profileEnd();\n      }\n      if (flags.isProfiling && evaluationPlan.evaluationOrder.size > -1) {\n        const percentResolved = Math.round(\n          (100 * numResolved) / evaluationPlan.evaluationOrder.size\n        );\n        const avgDuration =\n          durations.reduce((a, b) => a + b.duration, 0) / durations.length || 0;\n        console.log(\n          `%c[Evaluation] %c${evaluationPlan.evaluationOrder.size} deps | %c${(performance.now() - timeStart).toFixed(1)}ms | %c${percentResolved}% resolved | %c${avgDuration.toFixed(2)}ms avg`,\n          \"color:#83aaff;font-weight:bold;\",\n          \"color:#fff;font-weight:bold;\",\n          \"color:#7fff9e\",\n          \"color:#85baff\",\n          \"color:#ffdfa3\"\n        );\n      }\n\n      this.dependencyManager.markResolvedNodes(node);\n\n      const nextEvaluationPlan =\n        this.dependencyManager.buildEvaluationOrder(node);\n\n      this.dependencyManager.updateResolvedSCCs(nextEvaluationPlan);\n\n      precalculatedPlan = nextEvaluationPlan;\n\n      // Check if new dependencies were discovered during evaluation\n      if (nextEvaluationPlan.hash !== evaluationPlan.hash) {\n        requiresReRun = true;\n      } else {\n        this.isEvaluating = false;\n        return;\n      }\n    }\n    this.isEvaluating = false;\n  }\n\n  convertScalarValueToCellValue(val: SerializedCellValue): CellValue {\n    if (typeof val === \"number\") {\n      return { type: \"number\", value: val };\n    }\n    if (typeof val === \"boolean\") {\n      return { type: \"boolean\", value: val };\n    }\n    if (typeof val === \"undefined\") {\n      return { type: \"string\", value: \"\" };\n    }\n    return { type: \"string\", value: val };\n  }\n\n  // todo optimize using workbook manager\n  canSpill(spillCandidate: CellAddress, spillArea: SpreadsheetRange): boolean {\n    const sheet = this.workbookManager.getSheet(spillCandidate);\n    if (!sheet) {\n      throw new SheetNotFoundError(spillCandidate.sheetName);\n    }\n    const cellId = getCellReference(spillCandidate);\n    const content = sheet.content.get(cellId);\n    if (!content) {\n      throw new EvaluationError(FormulaError.REF, `Cell not found: ${cellId}`);\n    }\n    for (const spilledValue of this.dependencyManager.spilledValues) {\n      if (\n        spilledValue.origin.workbookName !== spillCandidate.workbookName ||\n        spilledValue.origin.sheetName !== spillCandidate.sheetName\n      ) {\n        continue;\n      }\n      if (\n        spilledValue.origin.colIndex === spillCandidate.colIndex &&\n        spilledValue.origin.rowIndex === spillCandidate.rowIndex\n      ) {\n        // we are already have a spill, this one will be replaced\n        continue;\n      }\n\n      if (checkRangeIntersection(spillArea, spilledValue.spillOnto)) {\n        return false;\n      }\n    }\n    // let's just check the raw data if there is something in the range\n    for (const key of sheet.content.keys()) {\n      const cellAddress = parseCellReference(key);\n      const endCol = spillArea.end.col;\n      const endRow = spillArea.end.row;\n\n      if (\n        cellAddress.colIndex === spillCandidate.colIndex &&\n        cellAddress.rowIndex === spillCandidate.rowIndex\n      ) {\n        continue;\n      }\n\n      if (endCol.type === \"number\" && endRow.type === \"number\") {\n        if (\n          cellAddress.colIndex >= spillArea.start.col &&\n          cellAddress.colIndex <= endCol.value &&\n          cellAddress.rowIndex >= spillArea.start.row &&\n          cellAddress.rowIndex <= endRow.value\n        ) {\n          if (\n            normalizeSerializedCellValue(sheet.content.get(key)) !== undefined\n          ) {\n            // there is something in the range, so we can't spill\n            return false;\n          }\n        }\n      }\n    }\n\n    return true;\n  }\n\n  getCellEvaluationResult(\n    cellAddress: CellAddress\n  ): SingleEvaluationResult | undefined {\n    if (this.isEvaluating) {\n      throw new Error(\"Evaluation in progress\");\n    }\n\n    const nodeKey = cellAddressToKey(cellAddress);\n    const node = this.dependencyManager.getCellValueOrEmptyCellNode(nodeKey);\n\n    const sheet = this.workbookManager.getSheet(cellAddress);\n    if (!sheet) {\n      throw new SheetNotFoundError(cellAddress.sheetName);\n    }\n\n    if (node.evaluationResult.type === \"awaiting-evaluation\") {\n      // if (cellAddressToKey(cellAddress).includes(\"G10\")) {\n      //   console.group(\"Evaluation of G10\");\n      //   flags.isProfiling = true;\n      //   console.time(\"Evaluation of G10\");\n      //   console.profile(\"Evaluation of G10\");\n      // }\n      this.evaluateCell(node);\n      // if (flags.isProfiling) {\n      //   flags.isProfiling = false;\n      //   console.timeEnd(\"Evaluation of G10\");\n      //   console.profileEnd(\"Evaluation of G10\");\n      //   console.groupEnd();\n      // }\n    }\n\n    const result = node.evaluationResult;\n\n    return result;\n  }\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "4C5D74A0388D284A64756E2164756E21",
+  "names": []
+}

package/dist/mjs/core/managers/event-manager.mjs

@@ -0,0 +1,18 @@
+// src/core/managers/event-manager.ts
+class EventManager {
+  updateListeners = new Set;
+  onUpdate(listener) {
+    this.updateListeners.add(listener);
+    return () => {
+      this.updateListeners.delete(listener);
+    };
+  }
+  emitUpdate() {
+    this.updateListeners.forEach((listener) => listener());
+  }
+}
+export {
+  EventManager
+};
+
+//# debugId=7F4C0E4D9A28D7D564756E2164756E21