@rowsncolumns/spreadsheet-state 28.0.66

package/dist/cjs/hooks/use-calculation.js

@@ -0,0 +1,2735 @@
+import { __awaiter, __generator, __read, __spreadArray, __values } from "tslib";
+import { Calculator, cellCoordsToCellCoordinate, DataSource, } from "@rowsncolumns/calculator";
+import { isCellCoordinateWithinCellRange, StaticNode } from "@rowsncolumns/dag";
+import { CellRangeNode, isCellCoordinate, isCellNode, isCellRangeNode, isStaticNode, isStaticReference, makeKey, } from "@rowsncolumns/dag";
+import { CellNode } from "@rowsncolumns/dag";
+import { FormulaError } from "@rowsncolumns/fast-formula-parser";
+import { isAreasEqual } from "@rowsncolumns/grid";
+import { ERROR_COLOR, useCallbackRef } from "@rowsncolumns/spreadsheet";
+import { useIsomorphicLayoutEffect } from "@rowsncolumns/ui";
+import { alpha2number, debug, error, isAFormula, isBareFormulaExpression, isNil, scheduleAfterPaint, } from "@rowsncolumns/utils";
+import { useCallback, useEffect, useMemo, useRef } from "react";
+import { getFunctionNamesFromFormula } from "../api/immer-utils";
+import { isEqualPosition } from "../api/range";
+import { AWAITING_CALCULATION, isCellRange } from "../helpers";
+import { computeDelta } from "../helpers/iterative-calculation";
+import { useCalculationProcessArray } from "./use-calculation-process-array";
+import { useDeferredCalculationFlush } from "./use-deferred-calculation-flush";
+import { useIdleScheduler } from "./use-idle-scheduler";
+var rangesOverlap = function (left, right) {
+    if (left.sheet !== right.sheet) {
+        return false;
+    }
+    return (left.from.row <= right.to.row &&
+        left.to.row >= right.from.row &&
+        left.from.col <= right.to.col &&
+        left.to.col >= right.from.col);
+};
+var isErrorResult = function (value) {
+    if (value instanceof FormulaError) {
+        return true;
+    }
+    return (!!value &&
+        typeof value === "object" &&
+        (value.type === "Error" ||
+            value.type === "Invalid"));
+};
+var isDerivedCellPosition = function (position) {
+    return position.conditionalFormatId !== undefined ||
+        position.dataValidationId !== undefined;
+};
+var findCircularKeys = function (nodes) {
+    var e_1, _a, e_2, _b, e_3, _c, e_4, _d, e_5, _e, e_6, _f;
+    var _g;
+    if (!nodes.length) {
+        return new Set();
+    }
+    var nodeMap = new Map();
+    var nodesBySheet = new Map();
+    try {
+        for (var nodes_1 = __values(nodes), nodes_1_1 = nodes_1.next(); !nodes_1_1.done; nodes_1_1 = nodes_1.next()) {
+            var node = nodes_1_1.value;
+            nodeMap.set(node.key, node);
+            var bucket = nodesBySheet.get(node.position.sheetId);
+            if (bucket) {
+                bucket.push(node);
+            }
+            else {
+                nodesBySheet.set(node.position.sheetId, [node]);
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (nodes_1_1 && !nodes_1_1.done && (_a = nodes_1.return)) _a.call(nodes_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    var adjacency = new Map();
+    try {
+        for (var nodes_2 = __values(nodes), nodes_2_1 = nodes_2.next(); !nodes_2_1.done; nodes_2_1 = nodes_2.next()) {
+            var node = nodes_2_1.value;
+            var edges = new Set();
+            try {
+                for (var _h = (e_3 = void 0, __values(node.inputKeys)), _j = _h.next(); !_j.done; _j = _h.next()) {
+                    var input = _j.value;
+                    if (isCellNode(input)) {
+                        var cellInput = input;
+                        if (nodeMap.has(cellInput.key)) {
+                            edges.add(cellInput.key);
+                        }
+                        continue;
+                    }
+                    if (isCellRangeNode(input)) {
+                        var rangeInput = input;
+                        var candidates = nodesBySheet.get(rangeInput.position.sheetId);
+                        if (!candidates) {
+                            continue;
+                        }
+                        try {
+                            for (var candidates_1 = (e_4 = void 0, __values(candidates)), candidates_1_1 = candidates_1.next(); !candidates_1_1.done; candidates_1_1 = candidates_1.next()) {
+                                var candidate = candidates_1_1.value;
+                                if (isCellNode(candidate) &&
+                                    !isDerivedCellPosition(candidate.position) &&
+                                    isCellCoordinateWithinCellRange(candidate.position, rangeInput)) {
+                                    edges.add(candidate.key);
+                                }
+                            }
+                        }
+                        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                        finally {
+                            try {
+                                if (candidates_1_1 && !candidates_1_1.done && (_d = candidates_1.return)) _d.call(candidates_1);
+                            }
+                            finally { if (e_4) throw e_4.error; }
+                        }
+                    }
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (_j && !_j.done && (_c = _h.return)) _c.call(_h);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            adjacency.set(node.key, edges);
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (nodes_2_1 && !nodes_2_1.done && (_b = nodes_2.return)) _b.call(nodes_2);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    var indexMap = new Map();
+    var lowLink = new Map();
+    var stack = [];
+    var onStack = new Set();
+    var index = 0;
+    var components = [];
+    var strongConnect = function (key) {
+        var e_7, _a;
+        var _b;
+        indexMap.set(key, index);
+        lowLink.set(key, index);
+        index++;
+        stack.push(key);
+        onStack.add(key);
+        try {
+            for (var _c = __values((_b = adjacency.get(key)) !== null && _b !== void 0 ? _b : []), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var neighbor = _d.value;
+                if (!indexMap.has(neighbor)) {
+                    strongConnect(neighbor);
+                    lowLink.set(key, Math.min(lowLink.get(key), lowLink.get(neighbor)));
+                }
+                else if (onStack.has(neighbor)) {
+                    lowLink.set(key, Math.min(lowLink.get(key), indexMap.get(neighbor)));
+                }
+            }
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_7) throw e_7.error; }
+        }
+        if (lowLink.get(key) === indexMap.get(key)) {
+            var component = [];
+            var candidate = void 0;
+            do {
+                candidate = stack.pop();
+                onStack.delete(candidate);
+                component.push(candidate);
+            } while (candidate !== key);
+            components.push(component);
+        }
+    };
+    try {
+        for (var _k = __values(nodeMap.keys()), _l = _k.next(); !_l.done; _l = _k.next()) {
+            var key = _l.value;
+            if (!indexMap.has(key)) {
+                strongConnect(key);
+            }
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (_l && !_l.done && (_e = _k.return)) _e.call(_k);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+    var circular = new Set();
+    try {
+        for (var components_1 = __values(components), components_1_1 = components_1.next(); !components_1_1.done; components_1_1 = components_1.next()) {
+            var component = components_1_1.value;
+            if (!component.length)
+                continue;
+            if (component.length === 1 &&
+                !((_g = adjacency.get(component[0])) === null || _g === void 0 ? void 0 : _g.has(component[0]))) {
+                continue;
+            }
+            component.forEach(function (key) { return circular.add(key); });
+        }
+    }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (components_1_1 && !components_1_1.done && (_f = components_1.return)) _f.call(components_1);
+        }
+        finally { if (e_6) throw e_6.error; }
+    }
+    return circular;
+};
+// List of ephemeral functions
+// Ephemeral functions are always recalculated when
+// a cell changes
+export var EPHEMERAL_FUNCTIONS = new Set([
+    "NOW",
+    "TODAY",
+    "RAND",
+    "RANDARRAY",
+    "RANDBETWEEN",
+    "SHEET",
+    "SHEETS",
+    "OFFSET",
+    "INDIRECT",
+]);
+var DEFAULT_BATCH_WEIGHT = 600;
+var ARRAY_FORMULA_WEIGHT = 300;
+var LARGE_RANGE_MIN_CELLS = 100;
+var MAX_CHUNK_DURATION_MS = 16;
+var getTimestamp = function () {
+    return typeof performance !== "undefined" && typeof performance.now === "function"
+        ? performance.now()
+        : Date.now();
+};
+var yieldToBrowser = function () {
+    return new Promise(function (resolve) {
+        scheduleAfterPaint(resolve);
+    });
+};
+var parseCellReference = function (reference) {
+    var match = /^\$?([A-Z]{1,3})\$?(\d+)$/i.exec(reference.trim());
+    if (!match) {
+        return null;
+    }
+    var column = alpha2number(match[1].toUpperCase());
+    if (column == null) {
+        return null;
+    }
+    var row = Number.parseInt(match[2], 10);
+    if (Number.isNaN(row)) {
+        return null;
+    }
+    return { column: column, row: row };
+};
+var toValidRange = function (range) {
+    var startRowIndex = Math.max(1, range.startRowIndex);
+    var endRowIndex = Math.max(startRowIndex, range.endRowIndex);
+    var startColumnIndex = Math.max(1, range.startColumnIndex);
+    var endColumnIndex = Math.max(startColumnIndex, range.endColumnIndex);
+    if (endRowIndex < startRowIndex || endColumnIndex < startColumnIndex) {
+        return null;
+    }
+    return {
+        sheetId: range.sheetId,
+        startRowIndex: startRowIndex,
+        endRowIndex: endRowIndex,
+        startColumnIndex: startColumnIndex,
+        endColumnIndex: endColumnIndex,
+    };
+};
+var getInvalidationRangeFromStructureChange = function (change) {
+    switch (change.kind) {
+        case "delete-row":
+        case "insert-row":
+            return toValidRange({
+                sheetId: change.sheetId,
+                startRowIndex: change.index,
+                endRowIndex: change.rowCount,
+                startColumnIndex: 1,
+                endColumnIndex: change.columnCount,
+            });
+        case "delete-column":
+        case "insert-column":
+            return toValidRange({
+                sheetId: change.sheetId,
+                startRowIndex: 1,
+                endRowIndex: change.rowCount,
+                startColumnIndex: change.index,
+                endColumnIndex: change.columnCount,
+            });
+        case "delete-cells-shift-up":
+        case "insert-cells-shift-down":
+            return toValidRange({
+                sheetId: change.sheetId,
+                startRowIndex: change.startRowIndex,
+                endRowIndex: change.rowCount,
+                startColumnIndex: change.startColumnIndex,
+                endColumnIndex: change.endColumnIndex,
+            });
+        case "delete-cells-shift-left":
+        case "insert-cells-shift-right":
+            return toValidRange({
+                sheetId: change.sheetId,
+                startRowIndex: change.startRowIndex,
+                endRowIndex: change.endRowIndex,
+                startColumnIndex: change.startColumnIndex,
+                endColumnIndex: change.columnCount,
+            });
+        case "delete-table-row":
+        case "insert-table-row":
+            return toValidRange({
+                sheetId: change.sheetId,
+                startRowIndex: change.index,
+                endRowIndex: change.rowCount,
+                startColumnIndex: change.startColumnIndex,
+                endColumnIndex: change.endColumnIndex,
+            });
+        case "delete-table-column":
+        case "insert-table-column":
+            return toValidRange({
+                sheetId: change.sheetId,
+                startRowIndex: change.startRowIndex,
+                endRowIndex: change.endRowIndex,
+                startColumnIndex: change.index,
+                endColumnIndex: change.columnCount,
+            });
+        case "invalidate-range":
+            return toValidRange({
+                sheetId: change.sheetId,
+                startRowIndex: change.startRowIndex,
+                endRowIndex: change.endRowIndex,
+                startColumnIndex: change.startColumnIndex,
+                endColumnIndex: change.endColumnIndex,
+            });
+        default:
+            return null;
+    }
+};
+var hasFullColumnReference = function (formula) {
+    var pattern = /(^|[^A-Z0-9_])(\$?[A-Z]{1,3})(?!\d)\s*:\s*(\$?[A-Z]{1,3})(?!\d)/gi;
+    return pattern.test(formula);
+};
+var hasFullRowReference = function (formula) {
+    var pattern = /(^|[^A-Z0-9_])(\$?\d+)\s*:\s*(\$?\d+)(?!\d)/gi;
+    return pattern.test(formula);
+};
+var hasLargeExplicitRange = function (formula) {
+    var pattern = /(\$?[A-Z]{1,3}\$?\d+)\s*:\s*(\$?[A-Z]{1,3}\$?\d+)/gi;
+    var match;
+    while ((match = pattern.exec(formula))) {
+        var start = parseCellReference(match[1]);
+        var end = parseCellReference(match[2]);
+        if (!start || !end) {
+            continue;
+        }
+        var rowCount = Math.abs(end.row - start.row) + 1;
+        var columnCount = Math.abs(end.column - start.column) + 1;
+        if (rowCount * columnCount >= LARGE_RANGE_MIN_CELLS) {
+            return true;
+        }
+    }
+    return false;
+};
+var isHeavyArrayFormula = function (formula) {
+    if (!formula)
+        return false;
+    return (hasFullColumnReference(formula) ||
+        hasFullRowReference(formula) ||
+        hasLargeExplicitRange(formula));
+};
+var cellPromises = new Map();
+export var useCalculation = function (_a) {
+    var locale = _a.locale, functions = _a.functions, iterativeCalculation = _a.iterativeCalculation, onDemandFormulaPattern = _a.onDemandFormulaPattern, activeSheetId = _a.activeSheetId, onSuccess = _a.onSuccess, onChangeDependencyGraph = _a.onChangeDependencyGraph, getSheetId = _a.getSheetId, getSheetName = _a.getSheetName, getSheetIndex = _a.getSheetIndex, getSheetCount = _a.getSheetCount, getActiveSheetId = _a.getActiveSheetId, getEffectiveValue = _a.getEffectiveValue, getUserEnteredValue = _a.getUserEnteredValue, getConditionalFormatFormula = _a.getConditionalFormatFormula, getDataValidationFormula = _a.getDataValidationFormula, getSheetProperties = _a.getSheetProperties, getCellData = _a.getCellData, onStructuredReference = _a.onStructuredReference, onNamedRange = _a.onNamedRange, namedRanges = _a.namedRanges, onChangeStaticReference = _a.onChangeStaticReference, onBeginCalculation = _a.onBeginCalculation, getEffectiveStructuredValue = _a.getEffectiveStructuredValue, isRowHidden = _a.isRowHidden, isRowHiddenByFilter = _a.isRowHiddenByFilter, _b = _a.enableLazyCalculation, enableLazyCalculation = _b === void 0 ? true : _b, _c = _a.enabled, enabled = _c === void 0 ? true : _c;
+    // Convert string pattern to RegExp if provided
+    var onDemandPattern = useMemo(function () {
+        if (!onDemandFormulaPattern)
+            return undefined;
+        return new RegExp(onDemandFormulaPattern, "gi");
+    }, [onDemandFormulaPattern]);
+    var calculator = useRef(undefined);
+    var computationCache = useRef(undefined);
+    var iterativeCalculationRef = useRef(iterativeCalculation);
+    iterativeCalculationRef.current = iterativeCalculation;
+    var operationQueue = useRef([]);
+    var graphOperationQueue = useRef([]);
+    // Results queue
+    var resultsQueueRef = useRef(new Map());
+    var resultsFlushPendingRef = useRef(false);
+    var isFullRecalcRef = useRef(false);
+    var staticNodeArrayRef = useRef([]);
+    var initialCalculationArrayRef = useRef([]);
+    var getSheetNameStable = useCallbackRef(getSheetName);
+    var getSheetIdStable = useCallbackRef(getSheetId);
+    var getSheetIndexStable = useCallbackRef(getSheetIndex);
+    var getSheetCountStable = useCallbackRef(getSheetCount);
+    var getCellDataStable = useCallbackRef(getCellData);
+    var onStructuredReferenceStable = useCallbackRef(onStructuredReference);
+    var getUserEnteredValueStable = useCallbackRef(getUserEnteredValue);
+    var isRowHiddenStable = useCallbackRef(isRowHidden);
+    var isRowHiddenByFilterStable = useCallbackRef(isRowHiddenByFilter);
+    var initialArrayResults = useRef(new Map());
+    var ephemeralCellsRef = useRef(new Map());
+    var forceRecalcKeys = useRef(new Set());
+    // Keys actually consumed (evaluated with fresh state) during the current
+    // calculation cycle. Only these are cleared in `onAfterCalculation`; keys
+    // added concurrently (e.g. by a paste RAF while a calc was mid-flight, with
+    // stale closures) survive into the next cycle so they aren't dropped.
+    var consumedForceRecalcKeys = useRef(new Set());
+    // Position for each force key, so unconsumed keys can be re-dirtied + rescheduled.
+    var forceRecalcPositions = useRef(new Map());
+    // Guards the reschedule loop against an unconsumable key spinning forever.
+    var rescheduleCount = useRef(0);
+    var rafTimerMapRef = useRef(new Map());
+    var deferredOperationsBySheetRef = useRef(new Map());
+    var pendingStartResultsRef = useRef(new Map());
+    var pendingRecalculatedPositionRef = useRef(undefined);
+    var startCalculationRef = useRef(null);
+    var scheduleStartCalculationIdle = useIdleScheduler().schedule;
+    // Add to ephemeral function if required
+    var addToEphemeralFunction = useCallback(function (formulaValue, position) {
+        var fns = getFunctionNamesFromFormula(formulaValue);
+        if (fns.some(function (fn) { return EPHEMERAL_FUNCTIONS.has(fn.toUpperCase()); })) {
+            ephemeralCellsRef.current.set(makeKey(position), position);
+        }
+    }, []);
+    // Remove from ephemeral function if required
+    var removeFromEphemeralFunction = useCallback(function (position) {
+        ephemeralCellsRef.current.delete(makeKey(position));
+    }, []);
+    // Get all ephemeral functions
+    var getEphemeralCells = useCallback(function () {
+        var ephemeralCellsToRecalc = __spreadArray([], __read(ephemeralCellsRef.current.values()), false).map(function (position) {
+            return {
+                type: "add",
+                position: position,
+            };
+        });
+        debug("Recalculation ephemeral cells", ephemeralCellsToRecalc);
+        return ephemeralCellsToRecalc;
+    }, []);
+    // Get computation cache
+    // Used for the current calculation frame
+    var getComputationCache = useCallback(function () {
+        if (computationCache.current === undefined) {
+            computationCache.current = new Map();
+        }
+        return computationCache.current;
+    }, []);
+    // Clear cache
+    var onAfterCalculation = useCallback(function () {
+        // Remove cached values
+        getComputationCache().clear();
+        // Cleanup the graph, so we dont have
+        // any stale nodes
+        getCalculator().cleanupGraph();
+        // Only clear keys that were actually consumed during this calculation cycle.
+        // Keys added concurrently (e.g. by a paste RAF while this calculation was
+        // running) must survive so the next cycle can evaluate them.
+        consumedForceRecalcKeys.current.forEach(function (key) {
+            forceRecalcKeys.current.delete(key);
+            forceRecalcPositions.current.delete(key);
+        });
+        consumedForceRecalcKeys.current.clear();
+    }, []);
+    var getFunctions = useCallback(function () {
+        return functions;
+    }, [functions]);
+    var overridesRef = useRef(null);
+    // Get user entered value
+    var getFinalUserEnteredValue = function (position) {
+        var conditionalFormatId = position.conditionalFormatId, dataValidationId = position.dataValidationId;
+        if (!isNil(conditionalFormatId)) {
+            return getConditionalFormatFormula(position.sheetId, position.rowIndex, position.columnIndex, conditionalFormatId);
+        }
+        if (!isNil(dataValidationId)) {
+            return getDataValidationFormula(position.sheetId, position.rowIndex, position.columnIndex, dataValidationId);
+        }
+        // Read through the stable ref so a calc-captured closure (e.g. a paste RAF
+        // that ran with a pre-paste render's `getUserEnteredValue`) still resolves
+        // the latest user-entered value rather than a stale snapshot.
+        return getUserEnteredValueStable(position.sheetId, position.rowIndex, position.columnIndex);
+    };
+    var deferCalculationNodes = function (positions) {
+        var e_8, _a;
+        var _b;
+        if (!positions.length) {
+            return;
+        }
+        try {
+            for (var positions_1 = __values(positions), positions_1_1 = positions_1.next(); !positions_1_1.done; positions_1_1 = positions_1.next()) {
+                var position = positions_1_1.value;
+                var key = makeKey(position);
+                var sheetId = position.sheetId;
+                var existing = (_b = deferredOperationsBySheetRef.current.get(sheetId)) !== null && _b !== void 0 ? _b : new Map();
+                existing.set(key, {
+                    type: "dirty",
+                    position: position,
+                    force: forceRecalcKeys.current.has(key),
+                });
+                deferredOperationsBySheetRef.current.set(sheetId, existing);
+                getCalculator().unMarkAsDirty(position);
+            }
+        }
+        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+        finally {
+            try {
+                if (positions_1_1 && !positions_1_1.done && (_a = positions_1.return)) _a.call(positions_1);
+            }
+            finally { if (e_8) throw e_8.error; }
+        }
+    };
+    var filterDirtyCellsForActiveSheet = function (cells, rootSheetId) {
+        var e_9, _a, e_10, _b, e_11, _c, e_12, _d, e_13, _e, e_14, _f, e_15, _g;
+        if (!cells.length) {
+            return { included: cells, deferred: [] };
+        }
+        var cellNodeByKey = new Map();
+        var dirtyNodesBySheet = new Map();
+        try {
+            for (var cells_1 = __values(cells), cells_1_1 = cells_1.next(); !cells_1_1.done; cells_1_1 = cells_1.next()) {
+                var node = cells_1_1.value;
+                cellNodeByKey.set(node.key, node);
+                var list = dirtyNodesBySheet.get(node.position.sheetId);
+                if (list) {
+                    list.push(node);
+                }
+                else {
+                    dirtyNodesBySheet.set(node.position.sheetId, [node]);
+                }
+            }
+        }
+        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+        finally {
+            try {
+                if (cells_1_1 && !cells_1_1.done && (_a = cells_1.return)) _a.call(cells_1);
+            }
+            finally { if (e_9) throw e_9.error; }
+        }
+        // Find cells that are inputs to static references (charts, etc.)
+        // These cells should not be deferred even if they're on other sheets
+        var staticInputKeys = new Set();
+        var staticInputs = getCalculator().getStaticReferenceInputs();
+        try {
+            for (var staticInputs_1 = __values(staticInputs), staticInputs_1_1 = staticInputs_1.next(); !staticInputs_1_1.done; staticInputs_1_1 = staticInputs_1.next()) {
+                var inputNode = staticInputs_1_1.value;
+                if (isCellNode(inputNode)) {
+                    staticInputKeys.add(inputNode.key);
+                }
+                else if (isCellRangeNode(inputNode)) {
+                    // For range inputs, check which dirty cells fall within the range
+                    var rangeInput = inputNode;
+                    try {
+                        for (var cells_2 = (e_11 = void 0, __values(cells)), cells_2_1 = cells_2.next(); !cells_2_1.done; cells_2_1 = cells_2.next()) {
+                            var cell = cells_2_1.value;
+                            if (!isDerivedCellPosition(cell.position) &&
+                                isCellCoordinateWithinCellRange(cell.position, rangeInput)) {
+                                staticInputKeys.add(cell.key);
+                            }
+                        }
+                    }
+                    catch (e_11_1) { e_11 = { error: e_11_1 }; }
+                    finally {
+                        try {
+                            if (cells_2_1 && !cells_2_1.done && (_c = cells_2.return)) _c.call(cells_2);
+                        }
+                        finally { if (e_11) throw e_11.error; }
+                    }
+                }
+            }
+        }
+        catch (e_10_1) { e_10 = { error: e_10_1 }; }
+        finally {
+            try {
+                if (staticInputs_1_1 && !staticInputs_1_1.done && (_b = staticInputs_1.return)) _b.call(staticInputs_1);
+            }
+            finally { if (e_10) throw e_10.error; }
+        }
+        var includedKeys = new Set();
+        var forcedKeys = forceRecalcKeys.current;
+        var stack = [];
+        try {
+            for (var cells_3 = __values(cells), cells_3_1 = cells_3.next(); !cells_3_1.done; cells_3_1 = cells_3.next()) {
+                var node = cells_3_1.value;
+                if (forcedKeys.has(node.key) ||
+                    node.position.sheetId === rootSheetId ||
+                    staticInputKeys.has(node.key)) {
+                    includedKeys.add(node.key);
+                    stack.push(node);
+                }
+            }
+        }
+        catch (e_12_1) { e_12 = { error: e_12_1 }; }
+        finally {
+            try {
+                if (cells_3_1 && !cells_3_1.done && (_d = cells_3.return)) _d.call(cells_3);
+            }
+            finally { if (e_12) throw e_12.error; }
+        }
+        while (stack.length) {
+            var current = stack.pop();
+            if (!current) {
+                continue;
+            }
+            var userEnteredValue = getFinalUserEnteredValue(current.position);
+            if (!isAFormula(userEnteredValue) || !userEnteredValue) {
+                continue;
+            }
+            var formulaValue = String(userEnteredValue).slice(1);
+            var dependencies = getCalculator().dependencies(formulaValue, current.position);
+            try {
+                for (var dependencies_1 = (e_13 = void 0, __values(dependencies)), dependencies_1_1 = dependencies_1.next(); !dependencies_1_1.done; dependencies_1_1 = dependencies_1.next()) {
+                    var dependency = dependencies_1_1.value;
+                    // Named-range refs (StaticReference) come back as deps too
+                    // now that the DAG is unified, but this code path is
+                    // chasing grid-level cell/range dependencies for the
+                    // active-sheet filter. Skip them.
+                    if (isStaticReference(dependency))
+                        continue;
+                    if (isCellCoordinate(dependency)) {
+                        var depKey = makeKey(dependency);
+                        var depNode = cellNodeByKey.get(depKey);
+                        if (depNode && !includedKeys.has(depKey)) {
+                            includedKeys.add(depKey);
+                            stack.push(depNode);
+                        }
+                        continue;
+                    }
+                    var candidates = dirtyNodesBySheet.get(dependency.sheetId);
+                    if (!candidates) {
+                        continue;
+                    }
+                    try {
+                        for (var candidates_2 = (e_14 = void 0, __values(candidates)), candidates_2_1 = candidates_2.next(); !candidates_2_1.done; candidates_2_1 = candidates_2.next()) {
+                            var candidate = candidates_2_1.value;
+                            if (includedKeys.has(candidate.key)) {
+                                continue;
+                            }
+                            if (isCellRangeNode(dependency) &&
+                                !isDerivedCellPosition(candidate.position) &&
+                                isCellCoordinateWithinCellRange(candidate.position, dependency)) {
+                                includedKeys.add(candidate.key);
+                                stack.push(candidate);
+                            }
+                        }
+                    }
+                    catch (e_14_1) { e_14 = { error: e_14_1 }; }
+                    finally {
+                        try {
+                            if (candidates_2_1 && !candidates_2_1.done && (_f = candidates_2.return)) _f.call(candidates_2);
+                        }
+                        finally { if (e_14) throw e_14.error; }
+                    }
+                }
+            }
+            catch (e_13_1) { e_13 = { error: e_13_1 }; }
+            finally {
+                try {
+                    if (dependencies_1_1 && !dependencies_1_1.done && (_e = dependencies_1.return)) _e.call(dependencies_1);
+                }
+                finally { if (e_13) throw e_13.error; }
+            }
+        }
+        var included = [];
+        var deferred = [];
+        try {
+            for (var cells_4 = __values(cells), cells_4_1 = cells_4.next(); !cells_4_1.done; cells_4_1 = cells_4.next()) {
+                var node = cells_4_1.value;
+                if (includedKeys.has(node.key)) {
+                    included.push(node);
+                }
+                else {
+                    deferred.push(node);
+                }
+            }
+        }
+        catch (e_15_1) { e_15 = { error: e_15_1 }; }
+        finally {
+            try {
+                if (cells_4_1 && !cells_4_1.done && (_g = cells_4.return)) _g.call(cells_4);
+            }
+            finally { if (e_15) throw e_15.error; }
+        }
+        return { included: included, deferred: deferred };
+    };
+    var scheduleStartCalculation = useCallback(function (results, recalculatedPosition) {
+        var e_16, _a;
+        if (results && results.size) {
+            try {
+                for (var results_1 = __values(results), results_1_1 = results_1.next(); !results_1_1.done; results_1_1 = results_1.next()) {
+                    var entry = results_1_1.value;
+                    pendingStartResultsRef.current.set(entry[0], entry[1]);
+                }
+            }
+            catch (e_16_1) { e_16 = { error: e_16_1 }; }
+            finally {
+                try {
+                    if (results_1_1 && !results_1_1.done && (_a = results_1.return)) _a.call(results_1);
+                }
+                finally { if (e_16) throw e_16.error; }
+            }
+        }
+        if (recalculatedPosition) {
+            pendingRecalculatedPositionRef.current = recalculatedPosition;
+        }
+        scheduleStartCalculationIdle(function () {
+            var _a;
+            var pendingResults = pendingStartResultsRef.current;
+            pendingStartResultsRef.current = new Map();
+            var position = pendingRecalculatedPositionRef.current;
+            pendingRecalculatedPositionRef.current = undefined;
+            (_a = startCalculationRef.current) === null || _a === void 0 ? void 0 : _a.call(startCalculationRef, pendingResults, position);
+        });
+    }, [scheduleStartCalculationIdle]);
+    // Calculator instance
+    var getCalculator = function () {
+        if (!calculator.current) {
+            var overrideValuesRef_1 = overridesRef;
+            calculator.current = new Calculator({
+                locale: locale,
+                getSheetId: getSheetIdStable,
+                getSheetIndex: getSheetIndexStable,
+                getSheetCount: getSheetCountStable,
+                getSheetProperties: function (sheetId) {
+                    if (sheetId === void 0) { sheetId = getActiveSheetId(); }
+                    return getSheetProperties(sheetId);
+                },
+                getSheetName: getSheetNameStable,
+                isRowHidden: isRowHidden ? isRowHiddenStable : undefined,
+                isRowHiddenByFilter: isRowHiddenByFilter
+                    ? isRowHiddenByFilterStable
+                    : undefined,
+                getCellValue: function (sheetId, rowIndex, columnIndex, property) {
+                    var _a;
+                    var key = makeKey({
+                        sheetId: sheetId,
+                        rowIndex: rowIndex,
+                        columnIndex: columnIndex,
+                    });
+                    if ((_a = overrideValuesRef_1.current) === null || _a === void 0 ? void 0 : _a.has(key)) {
+                        var result = overrideValuesRef_1.current.get(key);
+                        if (property) {
+                            return getEffectiveStructuredValue === null || getEffectiveStructuredValue === void 0 ? void 0 : getEffectiveStructuredValue(result, property);
+                        }
+                        return result;
+                    }
+                    var cachedValue = getComputationCache().has(key)
+                        ? getComputationCache().get(key)
+                        : null;
+                    if (cachedValue !== null) {
+                        // Cached structured value
+                        if (cachedValue &&
+                            typeof cachedValue === "object" &&
+                            cachedValue.kind &&
+                            getEffectiveStructuredValue) {
+                            return getEffectiveStructuredValue === null || getEffectiveStructuredValue === void 0 ? void 0 : getEffectiveStructuredValue(cachedValue, property);
+                        }
+                        return cachedValue;
+                    }
+                    return getEffectiveValue(sheetId, rowIndex, columnIndex, property);
+                },
+                functions: getFunctions(),
+                onStructuredReference: onStructuredReferenceStable,
+                onVariable: onNamedRange,
+                onRecalculation: onRecalculation,
+                markAsQueued: markAsQueued,
+                markAsLoading: markAsLoading,
+                markAsError: markAsError,
+                getCellData: function (coords) {
+                    if (isCellRange(coords)) {
+                        var arr = [];
+                        var sheetId = coords.sheet
+                            ? getSheetIdStable(coords.sheet)
+                            : getActiveSheetId();
+                        for (var rowIndex = coords.from.row; rowIndex <= coords.to.row; rowIndex++) {
+                            for (var columnIndex = coords.from.col; columnIndex <= coords.to.col; columnIndex++) {
+                                arr.push(getCellDataStable(sheetId, rowIndex, columnIndex));
+                            }
+                        }
+                        return arr;
+                    }
+                    else {
+                        var position = cellCoordsToCellCoordinate(coords, coords.sheet
+                            ? getSheetIdStable(coords.sheet)
+                            : getActiveSheetId());
+                        return getCellDataStable(position.sheetId, position.rowIndex, position.columnIndex);
+                    }
+                },
+            });
+        }
+        return calculator.current;
+    };
+    // Cleanup
+    useIsomorphicLayoutEffect(function () {
+        return function () {
+            var _a;
+            (_a = calculator.current) === null || _a === void 0 ? void 0 : _a.cleanup();
+        };
+    }, []);
+    // Phase 9 — virtual-cell named ranges. Sync the host's named-range
+    // list with the calculator's registered set. Each formula-typed
+    // named range becomes a DAG node; range-typed ones go straight
+    // through `onNamedRange` and are skipped here.
+    //
+    // Excel-correctness requires named ranges to be registered BEFORE
+    // any cell formula is parsed — otherwise the dep parser sees the
+    // name as `#NAME?` and no DAG edge to the static node is created.
+    // We do this via a callable `applyNamedRanges` that's invoked
+    // synchronously by the init hook at the top of its calculate
+    // pass (before walking sheetData), AND from a useEffect so
+    // ongoing changes (Name Manager edits) propagate too. Both paths
+    // are idempotent: the diff against `registeredNamedRangeFormulasRef`
+    // means re-calling with the same list is a no-op.
+    // Track both formula AND scope so we re-register when scope flips
+    // (workbook ↔ sheet) even if the formula text is unchanged. Scope
+    // is the numeric sheetId — names can be renamed, ids are stable.
+    var registeredNamedRangeFormulasRef = useRef(new Map());
+    // Diff the provided list against what's already registered and
+    // apply only the delta. Pure function over its arg — no implicit
+    // ref reads — so the init hook can call it with the same
+    // namedRanges prop it has, and tests can call it directly with
+    // any list.
+    var applyNamedRanges = useCallbackRef(function (list) {
+        var e_17, _a, e_18, _b, e_19, _c;
+        var _d, _e;
+        if (!enabled)
+            return;
+        var calc = getCalculator();
+        // Map key combines lowercase name + scope so workbook-scoped
+        // and sheet-scoped names with the same display name don't
+        // collide (Excel treats them as separate defined names).
+        var scopeKey = function (name, sheetId) {
+            return "".concat(sheetId == null ? "wb" : String(sheetId), ":").concat(name.toLowerCase());
+        };
+        var next = new Map();
+        try {
+            for (var _f = __values(list !== null && list !== void 0 ? list : []), _g = _f.next(); !_g.done; _g = _f.next()) {
+                var nr = _g.value;
+                var value = nr === null || nr === void 0 ? void 0 : nr.value;
+                if (typeof value !== "string")
+                    continue;
+                // Accept both shapes: "=OFFSET(...)" (spreadsheet convention)
+                // and bare "OFFSET(...)" (OOXML definedName convention).
+                // Static literals and plain references are not registered —
+                // they resolve through the host's onNamedRange fallback.
+                var trimmedValue = value.trim();
+                var formula = void 0;
+                if (trimmedValue.startsWith("=")) {
+                    formula = trimmedValue.slice(1).trim();
+                }
+                else if (isBareFormulaExpression(trimmedValue)) {
+                    formula = trimmedValue;
+                }
+                else {
+                    continue;
+                }
+                if (!formula)
+                    continue;
+                // Sheet-scoped if NamedRange.range.sheetId is present; else
+                // workbook-scoped. sheetId is stable across sheet renames.
+                var sheetId = (_e = (_d = nr.range) === null || _d === void 0 ? void 0 : _d.sheetId) !== null && _e !== void 0 ? _e : undefined;
+                next.set(scopeKey(nr.name, sheetId), {
+                    name: nr.name,
+                    formula: formula,
+                    sheetId: sheetId,
+                });
+            }
+        }
+        catch (e_17_1) { e_17 = { error: e_17_1 }; }
+        finally {
+            try {
+                if (_g && !_g.done && (_a = _f.return)) _a.call(_f);
+            }
+            finally { if (e_17) throw e_17.error; }
+        }
+        var prev = registeredNamedRangeFormulasRef.current;
+        try {
+            // Removals: in prev, not in next.
+            for (var prev_1 = __values(prev), prev_1_1 = prev_1.next(); !prev_1_1.done; prev_1_1 = prev_1.next()) {
+                var _h = __read(prev_1_1.value, 2), key = _h[0], prevEntry = _h[1];
+                if (!next.has(key)) {
+                    // The map key is `<scope>:<name>`; recover the name by
+                    // slicing past the first colon and pass the tracked
+                    // sheetId so we hit the right scoped registration.
+                    calc.unregisterNamedRange(key.slice(key.indexOf(":") + 1), prevEntry.sheetId);
+                }
+            }
+        }
+        catch (e_18_1) { e_18 = { error: e_18_1 }; }
+        finally {
+            try {
+                if (prev_1_1 && !prev_1_1.done && (_b = prev_1.return)) _b.call(prev_1);
+            }
+            finally { if (e_18) throw e_18.error; }
+        }
+        // Collect adds + updates. Compare formula AND scope so a
+        // scope-only change still re-registers (scope changes also
+        // flip the map key, so they hit removal+add — defensive
+        // equality check kept for robustness).
+        var toApply = [];
+        var nextPrev = new Map();
+        try {
+            for (var next_1 = __values(next), next_1_1 = next_1.next(); !next_1_1.done; next_1_1 = next_1.next()) {
+                var _j = __read(next_1_1.value, 2), key = _j[0], _k = _j[1], name_1 = _k.name, formula = _k.formula, sheetId = _k.sheetId;
+                var prevEntry = prev.get(key);
+                nextPrev.set(key, { formula: formula, sheetId: sheetId });
+                if ((prevEntry === null || prevEntry === void 0 ? void 0 : prevEntry.formula) === formula && prevEntry.sheetId === sheetId) {
+                    continue;
+                }
+                toApply.push({ name: name_1, formula: formula, sheetId: sheetId });
+            }
+        }
+        catch (e_19_1) { e_19 = { error: e_19_1 }; }
+        finally {
+            try {
+                if (next_1_1 && !next_1_1.done && (_c = next_1.return)) _c.call(next_1);
+            }
+            finally { if (e_19) throw e_19.error; }
+        }
+        // Order-independent batch: cross-name edges
+        // (`fullPrice = price * 1.08`) get wired correctly regardless
+        // of the order the names appear in the host's array.
+        if (toApply.length)
+            calc.registerNamedRanges(toApply);
+        registeredNamedRangeFormulasRef.current = nextPrev;
+    });
+    // Re-apply whenever the host's namedRanges list changes.
+    useEffect(function () {
+        applyNamedRanges(namedRanges);
+    }, [namedRanges, enabled, applyNamedRanges]);
+    // Hook for processing arrays
+    var _d = __read(useCalculationProcessArray({
+        locale: locale,
+        getCalculator: getCalculator,
+        getSheetId: getSheetIdStable,
+        getComputationCache: getComputationCache,
+        getUserEnteredValue: getUserEnteredValue,
+        getCellData: getCellDataStable,
+    }), 3), processArrayResults = _d[0], createArraySideEffectsAndGetResults = _d[1], getErrorResultsFromArrayPosition = _d[2];
+    /**
+     * Mark a cell
+     */
+    var markCell = useCallback(function (coords, value, formatting) {
+        var results = new Map();
+        var position = cellCoordsToCellCoordinate(coords, coords.sheet ? getSheetIdStable(coords.sheet) : getActiveSheetId());
+        var key = makeKey(position);
+        if (rafTimerMapRef.current.has(key)) {
+            var rafTimerId = rafTimerMapRef.current.get(key);
+            if (!isNil(rafTimerId)) {
+                cancelAnimationFrame(rafTimerId);
+                rafTimerMapRef.current.delete(key);
+            }
+        }
+        results.set(key, [position, value, formatting]);
+        publishResults(results.values());
+    }, []);
+    /**
+     * Mark a position as queue
+     */
+    var markAsQueued = useCallback(function (coords) {
+        markCell(coords, "Queued", {
+            horizontalAlignment: "center",
+        });
+    }, [markCell]);
+    /**
+     * Mark a position as loading
+     */
+    var markAsLoading = useCallback(function (coords) {
+        markCell(coords, "Loading...", {
+            horizontalAlignment: "center",
+        });
+    }, [markCell]);
+    /**
+     * Mark a position as error
+     */
+    var markAsError = useCallback(function (coords, value) {
+        markCell(coords, value, {
+            horizontalAlignment: "center",
+            textFormat: {
+                color: ERROR_COLOR,
+            },
+        });
+    }, [markCell]);
+    // On Recalculation: For dynamically updating calculated values
+    var onRecalculation = function (coords, calculationResults) {
+        var results = new Map();
+        var position = cellCoordsToCellCoordinate(coords, coords.sheet ? getSheetIdStable(coords.sheet) : getActiveSheetId());
+        var key = makeKey(position);
+        /**
+         * Multitenant returns null for
+         * unsubscribe callback
+         */
+        if (calculationResults === null) {
+            return;
+        }
+        // Set this cell as dirty
+        getCalculator().markAsDirty(position);
+        if (Array.isArray(calculationResults)) {
+            var _a = __read(processArrayResults(calculationResults, position, results, getDependents), 2), collides = _a[0], recomputeOperations = _a[1];
+            if (collides) {
+                getCalculator().cleanupPipelineFunction(position);
+            }
+            // New compuete
+            enqueueCalculations(recomputeOperations);
+        }
+        else {
+            // Add it to computation cache
+            getComputationCache().set(key, calculationResults);
+            // Push result to array
+            results.set(key, [position, calculationResults]);
+        }
+        scheduleStartCalculation(results, position);
+    };
+    // Begin calculation
+    var startCalculation = function () {
+        var args_1 = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args_1[_i] = arguments[_i];
+        }
+        return __awaiter(void 0, __spreadArray([], __read(args_1), false), void 0, function (initialResults, recalculatedPosition) {
+            var runCellBatch_1, dirtyCells, _loop_1, err_1, MAX_RESCHEDULE;
+            if (initialResults === void 0) { initialResults = new Map(); }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 4, , 5]);
+                        // Publish initial results
+                        if (initialResults.size) {
+                            publishResults(initialResults.values());
+                        }
+                        runCellBatch_1 = function (input) { return __awaiter(void 0, void 0, void 0, function () {
+                            var cellNodes, rootSheetId, _a, included, deferred, circularKeys_1, results, cellNodes_1, cellNodes_1_1, node, error_1;
+                            var e_20, _b;
+                            var _c;
+                            return __generator(this, function (_d) {
+                                switch (_d.label) {
+                                    case 0:
+                                        cellNodes = input;
+                                        rootSheetId = enableLazyCalculation
+                                            ? getActiveSheetId()
+                                            : undefined;
+                                        if (typeof rootSheetId === "number") {
+                                            _a = filterDirtyCellsForActiveSheet(cellNodes, rootSheetId), included = _a.included, deferred = _a.deferred;
+                                            if (deferred.length) {
+                                                deferCalculationNodes(deferred.map(function (cell) { return cell.position; }));
+                                            }
+                                            cellNodes = included;
+                                        }
+                                        if (!cellNodes.length)
+                                            return [2 /*return*/];
+                                        if (!((_c = iterativeCalculationRef.current) === null || _c === void 0 ? void 0 : _c.enabled)) {
+                                            circularKeys_1 = findCircularKeys(cellNodes);
+                                            if (circularKeys_1.size) {
+                                                results = new Map();
+                                                try {
+                                                    for (cellNodes_1 = __values(cellNodes), cellNodes_1_1 = cellNodes_1.next(); !cellNodes_1_1.done; cellNodes_1_1 = cellNodes_1.next()) {
+                                                        node = cellNodes_1_1.value;
+                                                        if (!circularKeys_1.has(node.key)) {
+                                                            continue;
+                                                        }
+                                                        error_1 = new FormulaError("#REF!", "Circular dependency detected.");
+                                                        getComputationCache().set(node.key, error_1);
+                                                        results.set(node.key, [node.position, error_1]);
+                                                    }
+                                                }
+                                                catch (e_20_1) { e_20 = { error: e_20_1 }; }
+                                                finally {
+                                                    try {
+                                                        if (cellNodes_1_1 && !cellNodes_1_1.done && (_b = cellNodes_1.return)) _b.call(cellNodes_1);
+                                                    }
+                                                    finally { if (e_20) throw e_20.error; }
+                                                }
+                                                publishResults(results.values());
+                                                cellNodes = cellNodes.filter(function (node) { return !circularKeys_1.has(node.key); });
+                                            }
+                                        }
+                                        return [4 /*yield*/, processCells(cellNodes, recalculatedPosition)];
+                                    case 1:
+                                        _d.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); };
+                        dirtyCells = [];
+                        _loop_1 = function () {
+                            var calc, pendingCells, flushPending, dirtyCells_1, dirtyCells_1_1, node, e_21_1;
+                            var e_21, _b;
+                            return __generator(this, function (_c) {
+                                switch (_c.label) {
+                                    case 0:
+                                        calc = getCalculator();
+                                        pendingCells = [];
+                                        flushPending = function () { return __awaiter(void 0, void 0, void 0, function () {
+                                            var batch;
+                                            return __generator(this, function (_a) {
+                                                switch (_a.label) {
+                                                    case 0:
+                                                        if (!pendingCells.length)
+                                                            return [2 /*return*/];
+                                                        batch = pendingCells.slice();
+                                                        pendingCells.length = 0;
+                                                        return [4 /*yield*/, runCellBatch_1(batch)];
+                                                    case 1:
+                                                        _a.sent();
+                                                        return [2 /*return*/];
+                                                }
+                                            });
+                                        }); };
+                                        _c.label = 1;
+                                    case 1:
+                                        _c.trys.push([1, 10, 11, 12]);
+                                        dirtyCells_1 = (e_21 = void 0, __values(dirtyCells)), dirtyCells_1_1 = dirtyCells_1.next();
+                                        _c.label = 2;
+                                    case 2:
+                                        if (!!dirtyCells_1_1.done) return [3 /*break*/, 9];
+                                        node = dirtyCells_1_1.value;
+                                        if (!!node.position) return [3 /*break*/, 7];
+                                        return [4 /*yield*/, flushPending()];
+                                    case 3:
+                                        _c.sent();
+                                        if (!calc.isNamedRangeNodeKey(node.key)) return [3 /*break*/, 5];
+                                        return [4 /*yield*/, calc.evaluateNamedRangeNodeKey(node.key)];
+                                    case 4:
+                                        _c.sent();
+                                        return [3 /*break*/, 6];
+                                    case 5:
+                                        publishStaticCells(node);
+                                        _c.label = 6;
+                                    case 6: return [3 /*break*/, 8];
+                                    case 7:
+                                        if (isCellCoordinate(node.position)) {
+                                            // `isCellCoordinate` narrows `node.position`, not `node`; the cast
+                                            // reflects the shape the guard just confirmed (a cell-coordinate node).
+                                            pendingCells.push(node);
+                                        }
+                                        _c.label = 8;
+                                    case 8:
+                                        dirtyCells_1_1 = dirtyCells_1.next();
+                                        return [3 /*break*/, 2];
+                                    case 9: return [3 /*break*/, 12];
+                                    case 10:
+                                        e_21_1 = _c.sent();
+                                        e_21 = { error: e_21_1 };
+                                        return [3 /*break*/, 12];
+                                    case 11:
+                                        try {
+                                            if (dirtyCells_1_1 && !dirtyCells_1_1.done && (_b = dirtyCells_1.return)) _b.call(dirtyCells_1);
+                                        }
+                                        finally { if (e_21) throw e_21.error; }
+                                        return [7 /*endfinally*/];
+                                    case 12: return [4 /*yield*/, flushPending()];
+                                    case 13:
+                                        _c.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        };
+                        _a.label = 1;
+                    case 1:
+                        if (!((dirtyCells = getCalculator().getDirtyCells()) &&
+                            dirtyCells.length !== 0)) return [3 /*break*/, 3];
+                        return [5 /*yield**/, _loop_1()];
+                    case 2:
+                        _a.sent();
+                        return [3 /*break*/, 1];
+                    case 3: return [3 /*break*/, 5];
+                    case 4:
+                        err_1 = _a.sent();
+                        console.error("[spreadsheet-state] recalculation pass aborted:", err_1);
+                        return [3 /*break*/, 5];
+                    case 5:
+                        // Clear current calculation array results
+                        initialArrayResults.current = new Map();
+                        onAfterCalculation();
+                        // If there are unconsumed forceRecalcKeys (added concurrently by a paste
+                        // RAF while this calculation was running with stale closures), re-dirty
+                        // those cells so the next calculation cycle (with fresh state) can evaluate
+                        // them. Cap reschedules to prevent an infinite loop if a key can never be
+                        // consumed.
+                        if (forceRecalcKeys.current.size > 0) {
+                            MAX_RESCHEDULE = 50;
+                            rescheduleCount.current = (rescheduleCount.current || 0) + 1;
+                            if (rescheduleCount.current <= MAX_RESCHEDULE) {
+                                forceRecalcPositions.current.forEach(function (pos) {
+                                    getCalculator().markAsDirty(pos);
+                                });
+                                scheduleStartCalculation();
+                            }
+                            else {
+                                // Give up — clear to avoid infinite spin.
+                                forceRecalcKeys.current.clear();
+                                forceRecalcPositions.current.clear();
+                                rescheduleCount.current = 0;
+                            }
+                        }
+                        else {
+                            rescheduleCount.current = 0;
+                        }
+                        // Trigger onChange
+                        onChangeDependencyGraph === null || onChangeDependencyGraph === void 0 ? void 0 : onChangeDependencyGraph(getCalculator().graph.toJSON());
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    startCalculationRef.current = startCalculation;
+    // Process async
+    function processCells(cells, recalculatedPosition) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cellMap, cells_5, cells_5_1, cell, adjacency, getDependencies, hasSelfReference, indices, lowlinks, stack, onStack, iterativeGroups, index, strongConnect, cells_6, cells_6_1, cell, key, cells_7, cells_7_1, cell, key, iterativeKeys, iterativeGroups_1, iterativeGroups_1_1, group, group_1, group_1_1, cell, nonIterativeCells, maxIterations, maxChange, iterativeGroups_2, iterativeGroups_2_1, group, group_2, group_2_1, cell, effectiveValue, previousValues, converged, iteration, currentValues, group_3, group_3_1, cell, userEnteredValue, result, key, err_2, error_2, e_22_1, maxDelta, currentValues_1, currentValues_1_1, _a, key, value, delta, finalValues, results, group_4, group_4_1, cell, key, value, _b, arrayErrors, recomputeOperations, arrayErrors_1, arrayErrors_1_1, _c, errorKey, errorValue, _d, collides, recomputeOperations, e_23_1, followUpCells, iterativeGroups_3, iterativeGroups_3_1, group, group_5, group_5_1, cell, dependents, dependents_1, dependents_1_1, dependent, cellDep, depKey;
+            var e_24, _e, e_25, _f, e_26, _g, e_27, _h, e_28, _j, e_23, _k, e_29, _l, e_22, _m, e_30, _o, e_31, _p, e_32, _q, e_33, _r, e_34, _s, e_35, _t;
+            var _u, _v, _w, _x, _y, _z, _0;
+            return __generator(this, function (_1) {
+                switch (_1.label) {
+                    case 0:
+                        if (!((_u = iterativeCalculationRef.current) === null || _u === void 0 ? void 0 : _u.enabled)) {
+                            return [2 /*return*/, processCellsInParallel(cells, recalculatedPosition)];
+                        }
+                        cellMap = new Map();
+                        try {
+                            for (cells_5 = __values(cells), cells_5_1 = cells_5.next(); !cells_5_1.done; cells_5_1 = cells_5.next()) {
+                                cell = cells_5_1.value;
+                                cellMap.set(makeKey(cell.position), cell);
+                            }
+                        }
+                        catch (e_24_1) { e_24 = { error: e_24_1 }; }
+                        finally {
+                            try {
+                                if (cells_5_1 && !cells_5_1.done && (_e = cells_5.return)) _e.call(cells_5);
+                            }
+                            finally { if (e_24) throw e_24.error; }
+                        }
+                        adjacency = new Map();
+                        getDependencies = function (cell) {
+                            var e_36, _a, e_37, _b;
+                            var deps = getCalculator().getPrecedents(cell.position);
+                            var depKeys = new Set();
+                            try {
+                                for (var deps_1 = __values(deps), deps_1_1 = deps_1.next(); !deps_1_1.done; deps_1_1 = deps_1.next()) {
+                                    var dep = deps_1_1.value;
+                                    if (isCellNode(dep)) {
+                                        var depKey = makeKey(dep.position);
+                                        if (cellMap.has(depKey)) {
+                                            depKeys.add(depKey);
+                                        }
+                                        continue;
+                                    }
+                                    if (isCellRangeNode(dep)) {
+                                        var rangeDep = dep;
+                                        try {
+                                            for (var cells_8 = (e_37 = void 0, __values(cells)), cells_8_1 = cells_8.next(); !cells_8_1.done; cells_8_1 = cells_8.next()) {
+                                                var candidate = cells_8_1.value;
+                                                if (!isDerivedCellPosition(candidate.position) &&
+                                                    isCellCoordinateWithinCellRange(candidate.position, rangeDep)) {
+                                                    depKeys.add(makeKey(candidate.position));
+                                                }
+                                            }
+                                        }
+                                        catch (e_37_1) { e_37 = { error: e_37_1 }; }
+                                        finally {
+                                            try {
+                                                if (cells_8_1 && !cells_8_1.done && (_b = cells_8.return)) _b.call(cells_8);
+                                            }
+                                            finally { if (e_37) throw e_37.error; }
+                                        }
+                                    }
+                                }
+                            }
+                            catch (e_36_1) { e_36 = { error: e_36_1 }; }
+                            finally {
+                                try {
+                                    if (deps_1_1 && !deps_1_1.done && (_a = deps_1.return)) _a.call(deps_1);
+                                }
+                                finally { if (e_36) throw e_36.error; }
+                            }
+                            return depKeys;
+                        };
+                        hasSelfReference = function (cell) {
+                            var userEnteredValue = getFinalUserEnteredValue(cell.position);
+                            if (!isAFormula(userEnteredValue) || !userEnteredValue) {
+                                return false;
+                            }
+                            var formulaValue = String(userEnteredValue).slice(1);
+                            try {
+                                var deps = getCalculator().dependencies(formulaValue, cell.position);
+                                return deps.some(function (dep) {
+                                    // Named-range static refs can't self-reference a cell.
+                                    if (isStaticReference(dep))
+                                        return false;
+                                    if (isCellCoordinate(dep)) {
+                                        return isEqualPosition(dep, cell.position);
+                                    }
+                                    return (dep.sheetId === cell.position.sheetId &&
+                                        cell.position.rowIndex >= dep.startRowIndex &&
+                                        cell.position.rowIndex <= dep.endRowIndex &&
+                                        cell.position.columnIndex >= dep.startColumnIndex &&
+                                        cell.position.columnIndex <= dep.endColumnIndex);
+                                });
+                            }
+                            catch (_a) {
+                                return false;
+                            }
+                        };
+                        indices = new Map();
+                        lowlinks = new Map();
+                        stack = [];
+                        onStack = new Set();
+                        iterativeGroups = [];
+                        index = 0;
+                        strongConnect = function (key) {
+                            var e_38, _a;
+                            var _b;
+                            indices.set(key, index);
+                            lowlinks.set(key, index);
+                            index++;
+                            stack.push(key);
+                            onStack.add(key);
+                            var deps = (_b = adjacency.get(key)) !== null && _b !== void 0 ? _b : new Set();
+                            try {
+                                for (var deps_2 = __values(deps), deps_2_1 = deps_2.next(); !deps_2_1.done; deps_2_1 = deps_2.next()) {
+                                    var depKey = deps_2_1.value;
+                                    if (!indices.has(depKey)) {
+                                        strongConnect(depKey);
+                                        lowlinks.set(key, Math.min(lowlinks.get(key), lowlinks.get(depKey)));
+                                    }
+                                    else if (onStack.has(depKey)) {
+                                        lowlinks.set(key, Math.min(lowlinks.get(key), indices.get(depKey)));
+                                    }
+                                }
+                            }
+                            catch (e_38_1) { e_38 = { error: e_38_1 }; }
+                            finally {
+                                try {
+                                    if (deps_2_1 && !deps_2_1.done && (_a = deps_2.return)) _a.call(deps_2);
+                                }
+                                finally { if (e_38) throw e_38.error; }
+                            }
+                            if (lowlinks.get(key) === indices.get(key)) {
+                                var componentKeys = [];
+                                var current = void 0;
+                                do {
+                                    current = stack.pop();
+                                    if (!current) {
+                                        break;
+                                    }
+                                    onStack.delete(current);
+                                    componentKeys.push(current);
+                                } while (current !== key);
+                                if (componentKeys.length > 1) {
+                                    iterativeGroups.push(componentKeys
+                                        .map(function (componentKey) { return cellMap.get(componentKey); })
+                                        .filter(function (cell) { return !!cell; }));
+                                    return;
+                                }
+                                var singleKey = componentKeys[0];
+                                var cell = singleKey ? cellMap.get(singleKey) : undefined;
+                                if (cell && hasSelfReference(cell)) {
+                                    iterativeGroups.push([cell]);
+                                }
+                            }
+                        };
+                        try {
+                            for (cells_6 = __values(cells), cells_6_1 = cells_6.next(); !cells_6_1.done; cells_6_1 = cells_6.next()) {
+                                cell = cells_6_1.value;
+                                key = makeKey(cell.position);
+                                if (!adjacency.has(key)) {
+                                    adjacency.set(key, getDependencies(cell));
+                                }
+                            }
+                        }
+                        catch (e_25_1) { e_25 = { error: e_25_1 }; }
+                        finally {
+                            try {
+                                if (cells_6_1 && !cells_6_1.done && (_f = cells_6.return)) _f.call(cells_6);
+                            }
+                            finally { if (e_25) throw e_25.error; }
+                        }
+                        try {
+                            for (cells_7 = __values(cells), cells_7_1 = cells_7.next(); !cells_7_1.done; cells_7_1 = cells_7.next()) {
+                                cell = cells_7_1.value;
+                                key = makeKey(cell.position);
+                                if (!indices.has(key)) {
+                                    strongConnect(key);
+                                }
+                            }
+                        }
+                        catch (e_26_1) { e_26 = { error: e_26_1 }; }
+                        finally {
+                            try {
+                                if (cells_7_1 && !cells_7_1.done && (_g = cells_7.return)) _g.call(cells_7);
+                            }
+                            finally { if (e_26) throw e_26.error; }
+                        }
+                        if (!iterativeGroups.length) {
+                            return [2 /*return*/, processCellsInParallel(cells, recalculatedPosition)];
+                        }
+                        iterativeKeys = new Set();
+                        try {
+                            for (iterativeGroups_1 = __values(iterativeGroups), iterativeGroups_1_1 = iterativeGroups_1.next(); !iterativeGroups_1_1.done; iterativeGroups_1_1 = iterativeGroups_1.next()) {
+                                group = iterativeGroups_1_1.value;
+                                try {
+                                    for (group_1 = (e_28 = void 0, __values(group)), group_1_1 = group_1.next(); !group_1_1.done; group_1_1 = group_1.next()) {
+                                        cell = group_1_1.value;
+                                        iterativeKeys.add(makeKey(cell.position));
+                                    }
+                                }
+                                catch (e_28_1) { e_28 = { error: e_28_1 }; }
+                                finally {
+                                    try {
+                                        if (group_1_1 && !group_1_1.done && (_j = group_1.return)) _j.call(group_1);
+                                    }
+                                    finally { if (e_28) throw e_28.error; }
+                                }
+                            }
+                        }
+                        catch (e_27_1) { e_27 = { error: e_27_1 }; }
+                        finally {
+                            try {
+                                if (iterativeGroups_1_1 && !iterativeGroups_1_1.done && (_h = iterativeGroups_1.return)) _h.call(iterativeGroups_1);
+                            }
+                            finally { if (e_27) throw e_27.error; }
+                        }
+                        nonIterativeCells = cells.filter(function (cell) { return !iterativeKeys.has(makeKey(cell.position)); });
+                        if (!nonIterativeCells.length) return [3 /*break*/, 2];
+                        return [4 /*yield*/, processCellsInParallel(nonIterativeCells, recalculatedPosition)];
+                    case 1:
+                        _1.sent();
+                        _1.label = 2;
+                    case 2:
+                        maxIterations = Math.max(1, (_w = (_v = iterativeCalculationRef.current) === null || _v === void 0 ? void 0 : _v.maxIterations) !== null && _w !== void 0 ? _w : 100);
+                        maxChange = Math.max(0, (_y = (_x = iterativeCalculationRef.current) === null || _x === void 0 ? void 0 : _x.maxChange) !== null && _y !== void 0 ? _y : 0.001);
+                        _1.label = 3;
+                    case 3:
+                        _1.trys.push([3, 22, 23, 24]);
+                        iterativeGroups_2 = __values(iterativeGroups), iterativeGroups_2_1 = iterativeGroups_2.next();
+                        _1.label = 4;
+                    case 4:
+                        if (!!iterativeGroups_2_1.done) return [3 /*break*/, 21];
+                        group = iterativeGroups_2_1.value;
+                        try {
+                            for (group_2 = (e_29 = void 0, __values(group)), group_2_1 = group_2.next(); !group_2_1.done; group_2_1 = group_2.next()) {
+                                cell = group_2_1.value;
+                                effectiveValue = getEffectiveValue === null || getEffectiveValue === void 0 ? void 0 : getEffectiveValue(cell.position.sheetId, cell.position.rowIndex, cell.position.columnIndex);
+                                if (isErrorResult(effectiveValue)) {
+                                    getComputationCache().set(makeKey(cell.position), 0);
+                                }
+                            }
+                        }
+                        catch (e_29_1) { e_29 = { error: e_29_1 }; }
+                        finally {
+                            try {
+                                if (group_2_1 && !group_2_1.done && (_l = group_2.return)) _l.call(group_2);
+                            }
+                            finally { if (e_29) throw e_29.error; }
+                        }
+                        previousValues = null;
+                        converged = false;
+                        iteration = 0;
+                        _1.label = 5;
+                    case 5:
+                        if (!(iteration < maxIterations)) return [3 /*break*/, 19];
+                        currentValues = new Map();
+                        _1.label = 6;
+                    case 6:
+                        _1.trys.push([6, 15, 16, 17]);
+                        group_3 = (e_22 = void 0, __values(group)), group_3_1 = group_3.next();
+                        _1.label = 7;
+                    case 7:
+                        if (!!group_3_1.done) return [3 /*break*/, 14];
+                        cell = group_3_1.value;
+                        if (recalculatedPosition &&
+                            isEqualPosition(cell.position, recalculatedPosition)) {
+                            return [3 /*break*/, 13];
+                        }
+                        userEnteredValue = getFinalUserEnteredValue(cell.position);
+                        if (!isAFormula(userEnteredValue) || !userEnteredValue) {
+                            return [3 /*break*/, 13];
+                        }
+                        _1.label = 8;
+                    case 8:
+                        _1.trys.push([8, 12, , 13]);
+                        return [4 /*yield*/, getCalculator().calculate(String(userEnteredValue).slice(1), cell.position)];
+                    case 9:
+                        result = _1.sent();
+                        if (!(result instanceof DataSource)) return [3 /*break*/, 11];
+                        return [4 /*yield*/, result.get()];
+                    case 10:
+                        result = _1.sent();
+                        _1.label = 11;
+                    case 11:
+                        key = makeKey(cell.position);
+                        currentValues.set(key, result);
+                        if (!Array.isArray(result)) {
+                            getComputationCache().set(key, result);
+                        }
+                        return [3 /*break*/, 13];
+                    case 12:
+                        err_2 = _1.sent();
+                        error_2 = err_2 instanceof FormulaError
+                            ? err_2
+                            : new FormulaError((_z = err_2 === null || err_2 === void 0 ? void 0 : err_2.name) !== null && _z !== void 0 ? _z : "#ERROR!", (_0 = err_2 === null || err_2 === void 0 ? void 0 : err_2.message) !== null && _0 !== void 0 ? _0 : String(err_2), err_2 === null || err_2 === void 0 ? void 0 : err_2.stack);
+                        currentValues.set(makeKey(cell.position), error_2);
+                        getComputationCache().set(makeKey(cell.position), error_2);
+                        return [3 /*break*/, 13];
+                    case 13:
+                        group_3_1 = group_3.next();
+                        return [3 /*break*/, 7];
+                    case 14: return [3 /*break*/, 17];
+                    case 15:
+                        e_22_1 = _1.sent();
+                        e_22 = { error: e_22_1 };
+                        return [3 /*break*/, 17];
+                    case 16:
+                        try {
+                            if (group_3_1 && !group_3_1.done && (_m = group_3.return)) _m.call(group_3);
+                        }
+                        finally { if (e_22) throw e_22.error; }
+                        return [7 /*endfinally*/];
+                    case 17:
+                        if (previousValues) {
+                            maxDelta = 0;
+                            try {
+                                for (currentValues_1 = (e_30 = void 0, __values(currentValues)), currentValues_1_1 = currentValues_1.next(); !currentValues_1_1.done; currentValues_1_1 = currentValues_1.next()) {
+                                    _a = __read(currentValues_1_1.value, 2), key = _a[0], value = _a[1];
+                                    delta = computeDelta(previousValues.get(key), value);
+                                    if (delta > maxDelta) {
+                                        maxDelta = delta;
+                                    }
+                                }
+                            }
+                            catch (e_30_1) { e_30 = { error: e_30_1 }; }
+                            finally {
+                                try {
+                                    if (currentValues_1_1 && !currentValues_1_1.done && (_o = currentValues_1.return)) _o.call(currentValues_1);
+                                }
+                                finally { if (e_30) throw e_30.error; }
+                            }
+                            previousValues = currentValues;
+                            if (maxDelta <= maxChange) {
+                                converged = true;
+                                return [3 /*break*/, 19];
+                            }
+                        }
+                        else {
+                            previousValues = currentValues;
+                        }
+                        _1.label = 18;
+                    case 18:
+                        iteration++;
+                        return [3 /*break*/, 5];
+                    case 19:
+                        finalValues = previousValues !== null && previousValues !== void 0 ? previousValues : new Map();
+                        results = new Map();
+                        try {
+                            for (group_4 = (e_31 = void 0, __values(group)), group_4_1 = group_4.next(); !group_4_1.done; group_4_1 = group_4.next()) {
+                                cell = group_4_1.value;
+                                key = makeKey(cell.position);
+                                value = finalValues.get(key);
+                                if (!converged) {
+                                    value = new FormulaError("#NUM!", "Iterative calculation did not converge");
+                                }
+                                if (value instanceof FormulaError) {
+                                    _b = __read(getErrorResultsFromArrayPosition(cell.position), 2), arrayErrors = _b[0], recomputeOperations = _b[1];
+                                    getComputationCache().set(key, value);
+                                    enqueueCalculations(recomputeOperations);
+                                    results.set(key, [cell.position, value]);
+                                    try {
+                                        for (arrayErrors_1 = (e_32 = void 0, __values(arrayErrors)), arrayErrors_1_1 = arrayErrors_1.next(); !arrayErrors_1_1.done; arrayErrors_1_1 = arrayErrors_1.next()) {
+                                            _c = __read(arrayErrors_1_1.value, 2), errorKey = _c[0], errorValue = _c[1];
+                                            results.set(errorKey, errorValue);
+                                        }
+                                    }
+                                    catch (e_32_1) { e_32 = { error: e_32_1 }; }
+                                    finally {
+                                        try {
+                                            if (arrayErrors_1_1 && !arrayErrors_1_1.done && (_q = arrayErrors_1.return)) _q.call(arrayErrors_1);
+                                        }
+                                        finally { if (e_32) throw e_32.error; }
+                                    }
+                                    continue;
+                                }
+                                if (Array.isArray(value)) {
+                                    _d = __read(processArrayResults(value, cell.position, results, getDependents), 2), collides = _d[0], recomputeOperations = _d[1];
+                                    if (collides) {
+                                        getCalculator().cleanupPipelineFunction(cell.position);
+                                    }
+                                    enqueueCalculations(recomputeOperations);
+                                }
+                                else {
+                                    getComputationCache().set(key, value);
+                                    results.set(key, [cell.position, value]);
+                                }
+                            }
+                        }
+                        catch (e_31_1) { e_31 = { error: e_31_1 }; }
+                        finally {
+                            try {
+                                if (group_4_1 && !group_4_1.done && (_p = group_4.return)) _p.call(group_4);
+                            }
+                            finally { if (e_31) throw e_31.error; }
+                        }
+                        publishResults(results.values());
+                        _1.label = 20;
+                    case 20:
+                        iterativeGroups_2_1 = iterativeGroups_2.next();
+                        return [3 /*break*/, 4];
+                    case 21: return [3 /*break*/, 24];
+                    case 22:
+                        e_23_1 = _1.sent();
+                        e_23 = { error: e_23_1 };
+                        return [3 /*break*/, 24];
+                    case 23:
+                        try {
+                            if (iterativeGroups_2_1 && !iterativeGroups_2_1.done && (_k = iterativeGroups_2.return)) _k.call(iterativeGroups_2);
+                        }
+                        finally { if (e_23) throw e_23.error; }
+                        return [7 /*endfinally*/];
+                    case 24:
+                        followUpCells = new Map();
+                        try {
+                            for (iterativeGroups_3 = __values(iterativeGroups), iterativeGroups_3_1 = iterativeGroups_3.next(); !iterativeGroups_3_1.done; iterativeGroups_3_1 = iterativeGroups_3.next()) {
+                                group = iterativeGroups_3_1.value;
+                                try {
+                                    for (group_5 = (e_34 = void 0, __values(group)), group_5_1 = group_5.next(); !group_5_1.done; group_5_1 = group_5.next()) {
+                                        cell = group_5_1.value;
+                                        dependents = getDependents(cell.position);
+                                        try {
+                                            for (dependents_1 = (e_35 = void 0, __values(dependents)), dependents_1_1 = dependents_1.next(); !dependents_1_1.done; dependents_1_1 = dependents_1.next()) {
+                                                dependent = dependents_1_1.value;
+                                                if (isCellNode(dependent)) {
+                                                    cellDep = dependent;
+                                                    depKey = makeKey(cellDep.position);
+                                                    if (!iterativeKeys.has(depKey)) {
+                                                        followUpCells.set(depKey, cellDep);
+                                                    }
+                                                }
+                                            }
+                                        }
+                                        catch (e_35_1) { e_35 = { error: e_35_1 }; }
+                                        finally {
+                                            try {
+                                                if (dependents_1_1 && !dependents_1_1.done && (_t = dependents_1.return)) _t.call(dependents_1);
+                                            }
+                                            finally { if (e_35) throw e_35.error; }
+                                        }
+                                    }
+                                }
+                                catch (e_34_1) { e_34 = { error: e_34_1 }; }
+                                finally {
+                                    try {
+                                        if (group_5_1 && !group_5_1.done && (_s = group_5.return)) _s.call(group_5);
+                                    }
+                                    finally { if (e_34) throw e_34.error; }
+                                }
+                            }
+                        }
+                        catch (e_33_1) { e_33 = { error: e_33_1 }; }
+                        finally {
+                            try {
+                                if (iterativeGroups_3_1 && !iterativeGroups_3_1.done && (_r = iterativeGroups_3.return)) _r.call(iterativeGroups_3);
+                            }
+                            finally { if (e_33) throw e_33.error; }
+                        }
+                        if (!followUpCells.size) return [3 /*break*/, 26];
+                        return [4 /*yield*/, processCellsInParallel(Array.from(followUpCells.values()), recalculatedPosition)];
+                    case 25:
+                        _1.sent();
+                        _1.label = 26;
+                    case 26: return [2 /*return*/];
+                }
+            });
+        });
+    }
+    function processCellsInParallel(cells, recalculatedPosition) {
+        return __awaiter(this, void 0, void 0, function () {
+            function processCellWithDependencies(cell) {
+                return __awaiter(this, void 0, void 0, function () {
+                    var cellKey, controller_1, dependencies, cellDependencies, rangeDependencies, rangeDependencies_1, rangeDependencies_1_1, dep, cells_9, cells_9_1, cell_1, dependencyPromises_1, cellPromise;
+                    var e_39, _a, e_40, _b;
+                    var _this = this;
+                    return __generator(this, function (_c) {
+                        switch (_c.label) {
+                            case 0:
+                                cellKey = makeKey(cell.position);
+                                _c.label = 1;
+                            case 1:
+                                if (!processingCells.has(cellKey)) return [3 /*break*/, 3];
+                                return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 0); })];
+                            case 2:
+                                _c.sent();
+                                return [3 /*break*/, 1];
+                            case 3:
+                                if (cellPromises.has(cellKey)) {
+                                    return [2 /*return*/, cellPromises.get(cellKey).promise];
+                                }
+                                processingCells.add(cellKey);
+                                try {
+                                    controller_1 = new AbortController();
+                                    dependencies = getPrecedents(cell.position);
+                                    cellDependencies = dependencies.filter(function (dep) {
+                                        return isCellNode(dep) && cells.includes(dep);
+                                    });
+                                    rangeDependencies = dependencies.filter(function (dep) { return isCellRangeNode(dep); });
+                                    try {
+                                        for (rangeDependencies_1 = __values(rangeDependencies), rangeDependencies_1_1 = rangeDependencies_1.next(); !rangeDependencies_1_1.done; rangeDependencies_1_1 = rangeDependencies_1.next()) {
+                                            dep = rangeDependencies_1_1.value;
+                                            try {
+                                                for (cells_9 = (e_40 = void 0, __values(cells)), cells_9_1 = cells_9.next(); !cells_9_1.done; cells_9_1 = cells_9.next()) {
+                                                    cell_1 = cells_9_1.value;
+                                                    if (!isDerivedCellPosition(cell_1.position) &&
+                                                        isCellCoordinateWithinCellRange(cell_1.position, dep)) {
+                                                        cellDependencies.push(cell_1);
+                                                    }
+                                                }
+                                            }
+                                            catch (e_40_1) { e_40 = { error: e_40_1 }; }
+                                            finally {
+                                                try {
+                                                    if (cells_9_1 && !cells_9_1.done && (_b = cells_9.return)) _b.call(cells_9);
+                                                }
+                                                finally { if (e_40) throw e_40.error; }
+                                            }
+                                        }
+                                    }
+                                    catch (e_39_1) { e_39 = { error: e_39_1 }; }
+                                    finally {
+                                        try {
+                                            if (rangeDependencies_1_1 && !rangeDependencies_1_1.done && (_a = rangeDependencies_1.return)) _a.call(rangeDependencies_1);
+                                        }
+                                        finally { if (e_39) throw e_39.error; }
+                                    }
+                                    dependencyPromises_1 = cellDependencies.map(function (dep) {
+                                        return processCellWithDependencies(dep);
+                                    });
+                                    cellPromise = (function () { return __awaiter(_this, void 0, void 0, function () {
+                                        return __generator(this, function (_a) {
+                                            switch (_a.label) {
+                                                case 0: return [4 /*yield*/, Promise.allSettled(dependencyPromises_1)];
+                                                case 1:
+                                                    _a.sent();
+                                                    // Set signal
+                                                    cell.position.signal = controller_1.signal;
+                                                    // Process cell
+                                                    return [4 /*yield*/, processCell(cell, recalculatedPosition)];
+                                                case 2:
+                                                    // Process cell
+                                                    _a.sent();
+                                                    // Remove signal after processing this cell
+                                                    delete cell.position.signal;
+                                                    return [2 /*return*/];
+                                            }
+                                        });
+                                    }); })();
+                                    cellPromises.set(cellKey, { promise: cellPromise, controller: controller_1 });
+                                    return [2 /*return*/, cellPromise];
+                                }
+                                finally {
+                                    processingCells.delete(cellKey);
+                                }
+                                return [2 /*return*/];
+                        }
+                    });
+                });
+            }
+            var processingCells, getCellWeight, chunkCells, chunks, index, chunk, start, elapsed;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        processingCells = new Set();
+                        // Remove old promises
+                        cells.forEach(function (cell) {
+                            var _a;
+                            var key = makeKey(cell.position);
+                            if (key) {
+                                (_a = cellPromises.get(key)) === null || _a === void 0 ? void 0 : _a.controller.abort();
+                                cellPromises.delete(key);
+                            }
+                        });
+                        getCellWeight = function (cell) {
+                            var value = getFinalUserEnteredValue(cell.position);
+                            if (typeof value === "string" && value.startsWith("=")) {
+                                var formula = value.slice(1);
+                                if (isHeavyArrayFormula(formula)) {
+                                    return ARRAY_FORMULA_WEIGHT;
+                                }
+                            }
+                            return 1;
+                        };
+                        chunkCells = function () {
+                            var e_41, _a;
+                            if (!cells.length) {
+                                return [];
+                            }
+                            var chunks = [];
+                            var current = [];
+                            var weight = 0;
+                            var flush = function () {
+                                if (!current.length) {
+                                    return;
+                                }
+                                chunks.push(current);
+                                current = [];
+                                weight = 0;
+                            };
+                            try {
+                                for (var cells_10 = __values(cells), cells_10_1 = cells_10.next(); !cells_10_1.done; cells_10_1 = cells_10.next()) {
+                                    var cell = cells_10_1.value;
+                                    var nextWeight = getCellWeight(cell);
+                                    if (current.length && weight + nextWeight > DEFAULT_BATCH_WEIGHT) {
+                                        flush();
+                                    }
+                                    current.push(cell);
+                                    weight += nextWeight;
+                                    if (weight >= DEFAULT_BATCH_WEIGHT) {
+                                        flush();
+                                    }
+                                }
+                            }
+                            catch (e_41_1) { e_41 = { error: e_41_1 }; }
+                            finally {
+                                try {
+                                    if (cells_10_1 && !cells_10_1.done && (_a = cells_10.return)) _a.call(cells_10);
+                                }
+                                finally { if (e_41) throw e_41.error; }
+                            }
+                            flush();
+                            return chunks.length ? chunks : [cells];
+                        };
+                        chunks = chunkCells();
+                        index = 0;
+                        _a.label = 1;
+                    case 1:
+                        if (!(index < chunks.length)) return [3 /*break*/, 5];
+                        chunk = chunks[index];
+                        if (!chunk.length) {
+                            return [3 /*break*/, 4];
+                        }
+                        start = getTimestamp();
+                        return [4 /*yield*/, Promise.allSettled(chunk.map(processCellWithDependencies))];
+                    case 2:
+                        _a.sent();
+                        elapsed = getTimestamp() - start;
+                        if (!(elapsed >= MAX_CHUNK_DURATION_MS && index < chunks.length - 1)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, yieldToBrowser()];
+                    case 3:
+                        _a.sent();
+                        _a.label = 4;
+                    case 4:
+                        index++;
+                        return [3 /*break*/, 1];
+                    case 5:
+                        cellPromises.clear();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    }
+    // Process a single dirty cell
+    var processCell = function (dirtyCell, recalculatedPosition) { return __awaiter(void 0, void 0, void 0, function () {
+        var results, position, key, userEnteredValue, isFormula, onDemandMap, rafTimer, isCellNode_1, result, _a, collides, recomputeOperations, err_3, error_3, _b, arrayErrors, recomputeOperations, arrayErrors_2, arrayErrors_2_1, _c, key_1, value;
+        var e_42, _d;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    results = new Map();
+                    position = dirtyCell.position, key = dirtyCell.key;
+                    userEnteredValue = getFinalUserEnteredValue(position);
+                    isFormula = isAFormula(userEnteredValue);
+                    if (recalculatedPosition &&
+                        isEqualPosition(position, recalculatedPosition)) {
+                        debug("Prevent recalculation of pipeline function", key);
+                        return [2 /*return*/];
+                    }
+                    // Check for force
+                    if (onDemandPattern) {
+                        onDemandPattern.lastIndex = 0;
+                    }
+                    if (isFormula &&
+                        userEnteredValue &&
+                        (onDemandPattern === null || onDemandPattern === void 0 ? void 0 : onDemandPattern.test(userEnteredValue))) {
+                        if (!forceRecalcKeys.current.has(key)) {
+                            onDemandMap = new Map();
+                            onDemandMap.set(key, [position, AWAITING_CALCULATION]);
+                            onSuccess(onDemandMap.values());
+                            return [2 /*return*/];
+                        }
+                        // Mark this on-demand key as consumed inside the gate's PASSED branch.
+                        // A stale closure that reads userEnteredValue as undefined (pre-paste
+                        // state) has isFormula === false, so it never enters this gate and thus
+                        // never consumes the key. The key survives until the next calculation
+                        // cycle runs with fresh React state, where getFinalUserEnteredValue
+                        // returns the actual formula.
+                        consumedForceRecalcKeys.current.add(key);
+                    }
+                    // For non-on-demand cells in forceRecalcKeys, only consume when we can
+                    // confirm the cell actually holds a formula (guards against stale closures
+                    // where userEnteredValue is undefined).
+                    if (forceRecalcKeys.current.has(key) && isFormula && userEnteredValue) {
+                        consumedForceRecalcKeys.current.add(key);
+                    }
+                    // Log
+                    debug("Processing", position, key, userEnteredValue);
+                    if (!(isFormula && userEnteredValue)) return [3 /*break*/, 7];
+                    rafTimer = void 0;
+                    _e.label = 1;
+                case 1:
+                    _e.trys.push([1, 5, , 6]);
+                    isCellNode_1 = !!dirtyCell.position && isCellCoordinate(dirtyCell.position);
+                    rafTimer = isCellNode_1
+                        ? requestAnimationFrame(function () { return publishBeginCalculation === null || publishBeginCalculation === void 0 ? void 0 : publishBeginCalculation(dirtyCell); })
+                        : undefined;
+                    if (!isNil(rafTimer)) {
+                        rafTimerMapRef.current.set(key, rafTimer);
+                    }
+                    return [4 /*yield*/, getCalculator().calculate(userEnteredValue.slice(1), position)];
+                case 2:
+                    result = _e.sent();
+                    // Cancel
+                    if (rafTimer) {
+                        cancelAnimationFrame(rafTimer);
+                        rafTimerMapRef.current.delete(key);
+                    }
+                    if (!(result instanceof DataSource)) return [3 /*break*/, 4];
+                    return [4 /*yield*/, result.get()];
+                case 3:
+                    result = _e.sent();
+                    _e.label = 4;
+                case 4:
+                    // Array results
+                    if (Array.isArray(result)) {
+                        _a = __read(processArrayResults(result, position, results, getDependents), 2), collides = _a[0], recomputeOperations = _a[1];
+                        // If it does collide
+                        if (collides) {
+                            getCalculator().cleanupPipelineFunction(position);
+                        }
+                        // New compuete
+                        enqueueCalculations(recomputeOperations);
+                    }
+                    else {
+                        // Add it to computation cache
+                        getComputationCache().set(key, result);
+                        // Invalidate any cached ranges containing this cell
+                        getCalculator().invalidateCacheForCell(position.sheetId, position.rowIndex, position.columnIndex);
+                        // Push result to array
+                        results.set(key, [position, result]);
+                    }
+                    return [3 /*break*/, 6];
+                case 5:
+                    err_3 = _e.sent();
+                    if (rafTimer) {
+                        cancelAnimationFrame(rafTimer);
+                    }
+                    // Calculation error
+                    if (err_3 instanceof FormulaError || err_3 instanceof Error) {
+                        error_3 = err_3 instanceof FormulaError
+                            ? err_3
+                            : new FormulaError(err_3.name, err_3.message, err_3.stack);
+                        // We have to check if this error is caused in a cell
+                        // containing array formula
+                        // If so we have to reset all values references by this
+                        // array
+                        debug("Computation Error", error_3, position, key, userEnteredValue);
+                        _b = __read(getErrorResultsFromArrayPosition(position), 2), arrayErrors = _b[0], recomputeOperations = _b[1];
+                        // Add it to computation cache
+                        getComputationCache().set(key, error_3);
+                        // Invalidate any cached ranges containing this cell
+                        getCalculator().invalidateCacheForCell(position.sheetId, position.rowIndex, position.columnIndex);
+                        // New compuete
+                        enqueueCalculations(recomputeOperations);
+                        // Add to results
+                        results.set(key, [position, error_3]);
+                        try {
+                            for (arrayErrors_2 = __values(arrayErrors), arrayErrors_2_1 = arrayErrors_2.next(); !arrayErrors_2_1.done; arrayErrors_2_1 = arrayErrors_2.next()) {
+                                _c = __read(arrayErrors_2_1.value, 2), key_1 = _c[0], value = _c[1];
+                                results.set(key_1, value);
+                            }
+                        }
+                        catch (e_42_1) { e_42 = { error: e_42_1 }; }
+                        finally {
+                            try {
+                                if (arrayErrors_2_1 && !arrayErrors_2_1.done && (_d = arrayErrors_2.return)) _d.call(arrayErrors_2);
+                            }
+                            finally { if (e_42) throw e_42.error; }
+                        }
+                    }
+                    return [3 /*break*/, 6];
+                case 6:
+                    publishResults(results.values());
+                    return [3 /*break*/, 8];
+                case 7:
+                    // Cleanup functions
+                    // Scenario -
+                    // 1. Delete a pipeline function
+                    // 2. Undo
+                    // 3. And then Redo - Cleanup should be called when formula is deleted
+                    getCalculator().cleanupPipelineFunction(position);
+                    _e.label = 8;
+                case 8: return [2 /*return*/];
+            }
+        });
+    }); };
+    /**
+     * Publish static cells back
+     */
+    var publishStaticCells = useCallback(function (node) {
+        if (staticNodeArrayRef.current.push(node) === 1) {
+            requestAnimationFrame(function () {
+                try {
+                    onChangeStaticReference === null || onChangeStaticReference === void 0 ? void 0 : onChangeStaticReference(staticNodeArrayRef.current);
+                }
+                catch (err) {
+                    console.error("[spreadsheet-state] recalculation pass aborted:", err);
+                }
+                finally {
+                    staticNodeArrayRef.current.length = 0;
+                }
+            });
+        }
+    }, [onChangeStaticReference]);
+    /**
+     * Publish loading cells
+     */
+    var publishBeginCalculation = useCallback(function (node) {
+        if (initialCalculationArrayRef.current.push(node.position) === 1) {
+            requestAnimationFrame(function () {
+                try {
+                    onBeginCalculation === null || onBeginCalculation === void 0 ? void 0 : onBeginCalculation(initialCalculationArrayRef.current);
+                }
+                catch (err) {
+                    console.error("[spreadsheet-state] recalculation pass aborted:", err);
+                }
+                finally {
+                    initialCalculationArrayRef.current.length = 0;
+                }
+            });
+        }
+    }, [onBeginCalculation]);
+    /**
+     * Publish results back to the
+     */
+    var publishResults = useCallback(function (item) {
+        var e_43, _a;
+        try {
+            for (var item_1 = __values(item), item_1_1 = item_1.next(); !item_1_1.done; item_1_1 = item_1.next()) {
+                var entry = item_1_1.value;
+                var _b = __read(entry, 1), key = _b[0];
+                resultsQueueRef.current.set(makeKey(key), entry);
+            }
+        }
+        catch (e_43_1) { e_43 = { error: e_43_1 }; }
+        finally {
+            try {
+                if (item_1_1 && !item_1_1.done && (_a = item_1.return)) _a.call(item_1);
+            }
+            finally { if (e_43) throw e_43.error; }
+        }
+        if (resultsQueueRef.current.size === 0) {
+            return;
+        }
+        if (resultsFlushPendingRef.current) {
+            return;
+        }
+        resultsFlushPendingRef.current = true;
+        var isFullRecalc = isFullRecalcRef.current;
+        // The flush RAF is fire-and-forget: a throw from the host's `onSuccess`
+        // used to escape to `window.onerror` as a raw uncaught exception.
+        // Contain it, and clear the queue in `finally` so a throwing host
+        // callback can't replay the same results on every subsequent flush.
+        requestAnimationFrame(function () {
+            resultsFlushPendingRef.current = false;
+            if (!resultsQueueRef.current.size) {
+                return;
+            }
+            try {
+                onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(resultsQueueRef.current.values(), isFullRecalc, {});
+            }
+            catch (err) {
+                console.error("[spreadsheet-state] recalculation pass aborted:", err);
+            }
+            finally {
+                resultsQueueRef.current.clear();
+                isFullRecalcRef.current = false;
+            }
+        });
+    }, [onSuccess]);
+    // Immediately enqueue a calculation
+    var enqueueCalculations = function (operations) {
+        operations.forEach(processSingleOperation);
+    };
+    // Seed the calculator's array range map with a persisted spill range.
+    // No-op when no spillRange is supplied or the sheet name can't be resolved.
+    var seedArraySpillRange = function (position, spillRange) {
+        if (!spillRange) {
+            return;
+        }
+        var calculator = getCalculator();
+        var sheetName = calculator.getSheetName(position.sheetId);
+        if (!sheetName) {
+            return;
+        }
+        calculator.setArrayRangeReference(position, {
+            sheet: sheetName,
+            from: {
+                row: spillRange.startRowIndex,
+                col: spillRange.startColumnIndex,
+            },
+            to: {
+                row: spillRange.endRowIndex,
+                col: spillRange.endColumnIndex,
+            },
+        });
+    };
+    // Process a single
+    var processSingleOperation = function (operation) {
+        var _a;
+        var position = operation.position, type = operation.type, force = operation.force, spillRange = operation.spillRange;
+        var userEnteredValue = getFinalUserEnteredValue(position);
+        var isFormula = isAFormula(userEnteredValue);
+        var formulaValue = isFormula
+            ? (_a = String(userEnteredValue)) === null || _a === void 0 ? void 0 : _a.slice(1)
+            : undefined;
+        if (force) {
+            var forceKey = makeKey(position);
+            forceRecalcKeys.current.add(forceKey);
+            forceRecalcPositions.current.set(forceKey, position);
+        }
+        try {
+            // Add/remove to DAG
+            if (isFormula && formulaValue) {
+                // Does both add and update formula. Updates DAG references
+                getCalculator().addFormula(formulaValue, position);
+                // Seed array spill range from persisted ref so dependents pointing
+                // into the spill region resolve on first load without re-eval.
+                seedArraySpillRange(position, spillRange);
+                // Add to ephemeral
+                addToEphemeralFunction(formulaValue, position);
+            }
+            else if (type === "add") {
+                // If user replaces a formula with static text
+                // Remove old references
+                getCalculator().removePrecedents(position);
+                // Mark this cell as dirty
+                getCalculator().markAsDirty(position);
+                // Cleanup ephemeral
+                removeFromEphemeralFunction(position);
+            }
+            else if (type === "dirty") {
+                getCalculator().markAsDirty(position);
+            }
+            else if (type === "remove") {
+                // Remove cell and mark its dependents dirty (not the cell itself)
+                getCalculator().removeCellAndMarkDependentsDirty(position);
+                // Remove ephemeral cells
+                removeFromEphemeralFunction(position);
+            }
+        }
+        catch (err) {
+            if (isFormula) {
+                // Delete formula references
+                getCalculator().removeFormula(position);
+            }
+            // Remove all cell dependencies
+            getCalculator().deleteCell(position);
+            // Remove it from being executed again
+            getCalculator().unMarkAsDirty(position);
+            // For circular dependencies
+            var errorMap = new Map([
+                [makeKey(position), [position, new FormulaError("#REF!", String(err))]],
+            ]);
+            publishResults(errorMap.values());
+        }
+    };
+    // Update dependency graph
+    // without making cells dirty
+    var processUpdateDependencyGraphOperation = useCallback(function (operation) {
+        var _a;
+        var position = operation.position, type = operation.type, previousPosition = operation.previousPosition, spillRange = operation.spillRange;
+        var userEnteredValue = getFinalUserEnteredValue(position);
+        var isFormula = isAFormula(userEnteredValue);
+        var formulaValue = isFormula
+            ? (_a = String(userEnteredValue)) === null || _a === void 0 ? void 0 : _a.slice(1)
+            : undefined;
+        // We need to move array formulas
+        if (previousPosition) {
+            var shouldRemoveArrayReference = false;
+            var arraySideEffects = createArraySideEffectsAndGetResults({
+                position: previousPosition,
+                shouldRemoveArrayReference: shouldRemoveArrayReference,
+                getDependents: getDependents,
+            });
+            if (arraySideEffects.size) {
+                // Immediately publish array side effects
+                publishResults(arraySideEffects.values());
+            }
+            if (getCalculator().isArray(previousPosition)) {
+                getCalculator().shiftArrayFormula(previousPosition, position);
+            }
+        }
+        try {
+            // Add/remove to DAG
+            if (isFormula && formulaValue) {
+                // Does both add and update formula. Updates DAG references
+                getCalculator().addFormulaToGraph(formulaValue, position);
+                // Seed array spill range so dependents in the spill region resolve
+                // through the DAG even though we skipped evaluation.
+                seedArraySpillRange(position, spillRange);
+            }
+            else if (type === "remove") {
+                getCalculator().removeCellFromGraph(position);
+            }
+            else if (type === "add") {
+                // If user replaces a formula with static text
+                // Remove old references
+                getCalculator().removePrecendentsFromGraph(position);
+            }
+        }
+        catch (err) {
+            error("Error when updateDependencyGraphFromOperation", err);
+        }
+    }, [getFinalUserEnteredValue]);
+    /**
+     * Goes through the queue of update operations and processes them.
+     *
+     * Optimization: Instead of using shift() which is O(n) per call (making the
+     * entire loop O(n²)), we swap the queue with an empty array and iterate
+     * with a for loop. This makes the entire operation O(n).
+     *
+     * If new operations are enqueued during processing, they go into the new
+     * empty array and will be processed in the next animation frame.
+     */
+    var processUpdateDependencyGraphQueue = useCallback(function () {
+        // Swap queue with empty array - O(1) operation
+        var operations = graphOperationQueue.current;
+        if (operations.length === 0)
+            return;
+        graphOperationQueue.current = [];
+        // Process all operations - O(n) total
+        for (var i = 0; i < operations.length; i++) {
+            var operation = operations[i];
+            if (operation) {
+                processUpdateDependencyGraphOperation(operation);
+            }
+        }
+    }, [processUpdateDependencyGraphOperation]);
+    // Add to calculation queue
+    // Stable reference prevents re-render of grid
+    var enqueueGraphOperation = useCallbackRef(useCallback(function (operation) {
+        if (graphOperationQueue.current.push(operation) === 1) {
+            requestAnimationFrame(function () {
+                try {
+                    // Process operation queuu
+                    processUpdateDependencyGraphQueue();
+                }
+                catch (err) {
+                    console.error("[spreadsheet-state] recalculation pass aborted:", err);
+                }
+            });
+        }
+    }, [processUpdateDependencyGraphQueue]));
+    useDeferredCalculationFlush({
+        activeSheetId: enableLazyCalculation && !isNil(activeSheetId)
+            ? activeSheetId
+            : undefined,
+        deferredOperationsBySheetRef: deferredOperationsBySheetRef,
+        enqueueOperation: processSingleOperation,
+        onChunkComplete: yieldToBrowser,
+        onFlushComplete: startCalculation,
+    });
+    // Get all precendets of a cell
+    var getPrecedents = useCallback(function (source, includeSource) {
+        return getCalculator()
+            .getPrecedents(source)
+            .filter(
+        // Ignore source
+        function (node) {
+            if (isStaticNode(node)) {
+                return true;
+            }
+            // After isStaticNode early-return, node is CellNode or
+            // CellRangeNode — both have a defined position. The cast
+            // bridges a TS narrowing limitation across the union.
+            var pos = node.position;
+            if (!includeSource &&
+                isCellCoordinate(pos) &&
+                isCellCoordinate(source)) {
+                return !isEqualPosition(pos, source);
+            }
+            if (includeSource &&
+                !isCellCoordinate(pos) &&
+                !isCellCoordinate(source)) {
+                return !isAreasEqual(pos, source);
+            }
+            return true;
+        });
+    }, []);
+    // Get precedents from formula string
+    // Does not check with DAG
+    var getPrecedentsFromFormulaString = useCallback(function (value, source) {
+        var e_44, _a;
+        var dependencies = getCalculator().dependencies(value, source);
+        var nodes = [];
+        try {
+            for (var dependencies_2 = __values(dependencies), dependencies_2_1 = dependencies_2.next(); !dependencies_2_1.done; dependencies_2_1 = dependencies_2.next()) {
+                var pos = dependencies_2_1.value;
+                if (isStaticReference(pos)) {
+                    // Named-range static reference. Build a StaticNode shape
+                    // — caller treats it as a non-cell precedent.
+                    nodes.push(new StaticNode(makeKey(pos)));
+                }
+                else if (isCellCoordinate(pos)) {
+                    nodes.push(new CellNode(makeKey(pos), pos));
+                }
+                else {
+                    nodes.push(new CellRangeNode(makeKey(pos), pos));
+                }
+            }
+        }
+        catch (e_44_1) { e_44 = { error: e_44_1 }; }
+        finally {
+            try {
+                if (dependencies_2_1 && !dependencies_2_1.done && (_a = dependencies_2.return)) _a.call(dependencies_2);
+            }
+            finally { if (e_44) throw e_44.error; }
+        }
+        return nodes;
+    }, []);
+    // Is array formula
+    var isArrayFormula = useCallbackRef(useCallback(function (position) {
+        return (getCalculator().isArray(position) ||
+            getCalculator().isInArrayRange(position));
+    }, []));
+    // Get all dependents of a cell. Returns a mixed list — narrow with
+    // the `isCellNode`/`isStaticNode` helpers at call sites (NOT
+    // `instanceof`, which breaks across bundler module instances).
+    var getDependents = useCallback(function (source, includeSource) {
+        return getCalculator()
+            .getDependents(source)
+            .filter(
+        // Ignore source
+        function (node) {
+            if (isStaticNode(node)) {
+                return true;
+            }
+            // Array formulas
+            if (isArrayFormula(node.position)) {
+                return true;
+            }
+            // For cell range
+            if (!includeSource && isCellRangeNode(node)) {
+                return !isAreasEqual(node.position, source);
+            }
+            if (!includeSource &&
+                isCellCoordinate(source) &&
+                isCellNode(node)) {
+                return (node.position.rowIndex !== source.rowIndex ||
+                    node.position.columnIndex !== source.columnIndex);
+            }
+            return true;
+        });
+    }, [isArrayFormula]);
+    /**
+     * Process the calculation operation queue.
+     *
+     * Optimization: Instead of using shift() which is O(n) per call (making the
+     * entire loop O(n²)), we swap the queue with an empty array and iterate
+     * with a for loop. This makes the entire operation O(n).
+     *
+     * If new operations are enqueued during processing (via processSingleOperation),
+     * they go into the new empty array and will trigger a new requestAnimationFrame
+     * via the enqueue logic.
+     */
+    var processOperationQueue = useCallback(function () {
+        var e_45, _a, e_46, _b, e_47, _c, e_48, _d;
+        // Swap queue with empty array - O(1) operation
+        var operations = operationQueue.current;
+        if (operations.length === 0)
+            return;
+        operationQueue.current = [];
+        // Process all operations - O(n) total
+        for (var i = 0; i < operations.length; i++) {
+            var operation = operations[i];
+            if (operation) {
+                var clearedArrayRange = operation.type !== "dirty" && isArrayFormula(operation.position)
+                    ? getCalculator().getArrayRange(operation.position)
+                    : undefined;
+                if (operation.type === "remove") {
+                    // Only publish undefined result for formulas or array formulas
+                    // Static cells don't need calculation results
+                    var userEnteredValue = getFinalUserEnteredValue(operation.position);
+                    if (isAFormula(userEnteredValue) ||
+                        isArrayFormula(operation.position)) {
+                        initialArrayResults.current.set(makeKey(operation.position), [
+                            operation.position,
+                            undefined,
+                        ]);
+                    }
+                }
+                if (operation.type !== "dirty" && isArrayFormula(operation.position)) {
+                    var parentCandidates = new Map();
+                    try {
+                        for (var _e = (e_45 = void 0, __values(createArraySideEffectsAndGetResults({
+                            position: operation.position,
+                            getDependents: getDependents,
+                        }))), _f = _e.next(); !_f.done; _f = _e.next()) {
+                            var _g = __read(_f.value, 2), key = _g[0], value = _g[1];
+                            initialArrayResults.current.set(key, value);
+                            var _h = __read(value, 1), cellPosition = _h[0];
+                            var parent_1 = getCalculator().getClosestArrayParentCell(cellPosition);
+                            if (parent_1 &&
+                                !isEqualPosition(parent_1, cellPosition) &&
+                                !isEqualPosition(parent_1, operation.position)) {
+                                parentCandidates.set(makeKey(parent_1), parent_1);
+                            }
+                        }
+                    }
+                    catch (e_45_1) { e_45 = { error: e_45_1 }; }
+                    finally {
+                        try {
+                            if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
+                        }
+                        finally { if (e_45) throw e_45.error; }
+                    }
+                    try {
+                        for (var _j = (e_46 = void 0, __values(parentCandidates.values())), _k = _j.next(); !_k.done; _k = _j.next()) {
+                            var parent_2 = _k.value;
+                            getCalculator().markAsDirty(parent_2);
+                        }
+                    }
+                    catch (e_46_1) { e_46 = { error: e_46_1 }; }
+                    finally {
+                        try {
+                            if (_k && !_k.done && (_b = _j.return)) _b.call(_j);
+                        }
+                        finally { if (e_46) throw e_46.error; }
+                    }
+                    if (clearedArrayRange) {
+                        try {
+                            for (var _l = (e_47 = void 0, __values(getCalculator().arrayRangeMap)), _m = _l.next(); !_m.done; _m = _l.next()) {
+                                var _o = __read(_m.value, 2), key = _o[0], range = _o[1];
+                                if (!rangesOverlap(range, clearedArrayRange)) {
+                                    continue;
+                                }
+                                var anchor = getCalculator().arrayReferenceMap.get(key);
+                                if (anchor && !isEqualPosition(anchor, operation.position)) {
+                                    getCalculator().markAsDirty(anchor);
+                                }
+                            }
+                        }
+                        catch (e_47_1) { e_47 = { error: e_47_1 }; }
+                        finally {
+                            try {
+                                if (_m && !_m.done && (_c = _l.return)) _c.call(_l);
+                            }
+                            finally { if (e_47) throw e_47.error; }
+                        }
+                    }
+                }
+                var arrayParent = getCalculator().getClosestArrayParentCell(operation.position);
+                if (arrayParent && !isEqualPosition(arrayParent, operation.position)) {
+                    try {
+                        for (var _p = (e_48 = void 0, __values(createArraySideEffectsAndGetResults({
+                            position: arrayParent,
+                            shouldRemoveArrayReference: false,
+                            getDependents: getDependents,
+                        }))), _q = _p.next(); !_q.done; _q = _p.next()) {
+                            var _r = __read(_q.value, 2), key = _r[0], value = _r[1];
+                            initialArrayResults.current.set(key, value);
+                        }
+                    }
+                    catch (e_48_1) { e_48 = { error: e_48_1 }; }
+                    finally {
+                        try {
+                            if (_q && !_q.done && (_d = _p.return)) _d.call(_p);
+                        }
+                        finally { if (e_48) throw e_48.error; }
+                    }
+                }
+                // Backend driven
+                // When a backend sets a effective value of a formula
+                // Only update the dependent cells.
+                // This can be removed if the agent can do cell dependency computation
+                // And update the changed cells in the back-end
+                if (operation.source === "backend") {
+                    var graph = getCalculator().graph;
+                    var hasRanges = graph.ranges.size > 0;
+                    var shouldResolveDependents = hasRanges;
+                    if (!hasRanges) {
+                        if (graph.hasNode(operation.position)) {
+                            var node = graph.getNode(operation.position);
+                            shouldResolveDependents = node.dependentKeys.size > 0;
+                        }
+                        else {
+                            shouldResolveDependents = false;
+                        }
+                    }
+                    if (!shouldResolveDependents) {
+                        continue;
+                    }
+                    var dependents = getDependents(operation.position);
+                    dependents.forEach(function (dependent) {
+                        if (isCellNode(dependent)) {
+                            // CellNode.position is always defined — assertion to
+                            // bridge a TS narrowing limitation across the union.
+                            processSingleOperation({
+                                type: "dirty",
+                                position: dependent.position,
+                            });
+                        }
+                    });
+                }
+                else {
+                    // Process operation
+                    processSingleOperation(operation);
+                }
+            }
+        }
+    }, [
+        createArraySideEffectsAndGetResults,
+        getDependents,
+        processSingleOperation,
+    ]);
+    // Add to calculation queue
+    // Stable reference prevents re-render of grid
+    var enqueueCalculation = useCallbackRef(useCallback(function (operation) {
+        if (operationQueue.current.push(operation) === 1) {
+            // The RAF callback runs the queue processing + initial publish
+            // synchronously, so a throw here escapes straight to
+            // `window.onerror` (the `$exception` twin of the fire-and-forget
+            // rejection guarded in `startCalculation`). Contain it the same
+            // way: abort this pass, leave the queue for the next trigger.
+            requestAnimationFrame(function () {
+                var _a;
+                try {
+                    var hasValueAffectingNonEphemeralOp = operationQueue.current.some(function (queued) {
+                        return !ephemeralCellsRef.current.has(makeKey(queued.position));
+                    });
+                    if (hasValueAffectingNonEphemeralOp) {
+                        // Add ephemeral functions
+                        (_a = operationQueue.current).push.apply(_a, __spreadArray([], __read(getEphemeralCells()), false));
+                    }
+                    // Process operation queuu
+                    processOperationQueue();
+                    var initialResults = initialArrayResults.current;
+                    var shouldPublishInitialResults = initialResults.size > 0;
+                    if (shouldPublishInitialResults) {
+                        initialArrayResults.current = new Map();
+                        publishResults(initialResults.values());
+                        requestAnimationFrame(function () {
+                            scheduleStartCalculation();
+                        });
+                        return;
+                    }
+                    // Start calculation
+                    scheduleStartCalculation(initialResults);
+                }
+                catch (err) {
+                    console.error("[spreadsheet-state] recalculation pass aborted:", err);
+                }
+            });
+        }
+    }, [processOperationQueue, processSingleOperation, scheduleStartCalculation]));
+    // Delete all sheet references
+    var deleteSheetReferences = useCallback(function (sheetId) {
+        return getCalculator().deleteSheet(sheetId);
+    }, []);
+    var enqueueStructureChange = useCallbackRef(useCallback(function (change) {
+        var range = getInvalidationRangeFromStructureChange(change);
+        if (!range) {
+            return;
+        }
+        getCalculator().invalidateCacheForRange(range.sheetId, range.startRowIndex, range.startColumnIndex, range.endRowIndex, range.endColumnIndex);
+    }, []));
+    var clearRangeCache = useCallbackRef(useCallback(function () {
+        getCalculator().clearRangeCache();
+    }, []));
+    // Used for formula preview
+    var onRequestCalculate = useCallback(function (value, sheetId, rowIndex, columnIndex, options) { return __awaiter(void 0, void 0, void 0, function () {
+        var isArray, disablePreview, skipOnDemand, previousOverrides, position, precedents, isCircular, isPreview, err_4;
+        var _a, _b, _c, _d, _e;
+        return __generator(this, function (_f) {
+            switch (_f.label) {
+                case 0:
+                    isArray = (_a = options === null || options === void 0 ? void 0 : options.isArray) !== null && _a !== void 0 ? _a : false;
+                    disablePreview = (_b = options === null || options === void 0 ? void 0 : options.disablePreview) !== null && _b !== void 0 ? _b : false;
+                    skipOnDemand = (_c = options === null || options === void 0 ? void 0 : options.skipOnDemand) !== null && _c !== void 0 ? _c : true;
+                    if (skipOnDemand && onDemandPattern) {
+                        onDemandPattern.lastIndex = 0;
+                    }
+                    if (skipOnDemand && isAFormula(value) && (onDemandPattern === null || onDemandPattern === void 0 ? void 0 : onDemandPattern.test(value))) {
+                        return [2 /*return*/, undefined];
+                    }
+                    previousOverrides = overridesRef.current;
+                    overridesRef.current = (_d = options === null || options === void 0 ? void 0 : options.overrides) !== null && _d !== void 0 ? _d : null;
+                    position = { sheetId: sheetId, rowIndex: rowIndex, columnIndex: columnIndex };
+                    _f.label = 1;
+                case 1:
+                    _f.trys.push([1, 3, 4, 5]);
+                    if (((_e = iterativeCalculationRef.current) === null || _e === void 0 ? void 0 : _e.enabled) &&
+                        isAFormula(value) &&
+                        !disablePreview) {
+                        precedents = getPrecedentsFromFormulaString(value.slice(1), position);
+                        isCircular = precedents.some(function (node) {
+                            var range = node.position;
+                            // Named-range static nodes have no grid position — they
+                            // can't be a circular self-reference.
+                            if (!range)
+                                return false;
+                            if ("rowIndex" in range) {
+                                return (range.sheetId === sheetId &&
+                                    range.rowIndex === rowIndex &&
+                                    range.columnIndex === columnIndex);
+                            }
+                            return (range.sheetId === sheetId &&
+                                rowIndex >= range.startRowIndex &&
+                                rowIndex <= range.endRowIndex &&
+                                columnIndex >= range.startColumnIndex &&
+                                columnIndex <= range.endColumnIndex);
+                        });
+                        if (isCircular) {
+                            return [2 /*return*/, undefined];
+                        }
+                    }
+                    isPreview = true;
+                    return [4 /*yield*/, getCalculator().calculate(value.slice(1), position, isArray, isPreview, disablePreview)];
+                case 2: return [2 /*return*/, _f.sent()];
+                case 3:
+                    err_4 = _f.sent();
+                    // Formula errors (#NAME?, #REF!, …) are values, not
+                    // exceptions — the recalc loop stores them as cell values,
+                    // and fire-and-forget preview callers (charts, status bar,
+                    // filter-by-condition) have no rejection handler, so a throw
+                    // here escapes as an unhandled promise rejection.
+                    if (err_4 instanceof FormulaError) {
+                        return [2 /*return*/, err_4];
+                    }
+                    throw err_4;
+                case 4:
+                    overridesRef.current = previousOverrides !== null && previousOverrides !== void 0 ? previousOverrides : null;
+                    return [7 /*endfinally*/];
+                case 5: return [2 /*return*/];
+            }
+        });
+    }); }, []);
+    // Get all nodes from calculator
+    var getGraphNodes = useCallback(function () {
+        return getCalculator().graph.nodes;
+    }, []);
+    // Get sheet-bound nodes from the per-sheet bucket. Cheaper than
+    // `getGraphNodes()` for callers that only care about a single sheet —
+    // structural ops use this for the formula-cell sweep so cost scales with
+    // `nodes_in_sheet` rather than `nodes_in_workbook`.
+    var getGraphNodesInSheet = useCallback(function (sheetId) {
+        return getCalculator().graph.getNodesInSheet(sheetId);
+    }, []);
+    // Add a static reference
+    var addStaticReference = useCallback(function (source, sourcePosition) {
+        return getCalculator().addStaticReference(source, sourcePosition);
+    }, []);
+    var addFormulaToGraph = useCallbackRef(useCallback(function (formulaValue, position) {
+        if (!formulaValue) {
+            return;
+        }
+        getCalculator().addFormulaToGraph(formulaValue, position);
+    }, []));
+    // Remove static reference
+    var removeStaticReference = useCallback(function (source) {
+        return getCalculator().removeStaticReference(source);
+    }, []);
+    // Reset calculator
+    var onResetCalculator = useCallbackRef(useCallback(function () {
+        isFullRecalcRef.current = true;
+        // Reset graph
+        getCalculator().graph.reset();
+        getCalculator().arrayRangeMap.clear();
+        getCalculator().arrayRangeMap.clear();
+    }, []));
+    /**
+     * Get dependency graph
+     */
+    var getDependencyGraph = useCallbackRef(useCallback(function () {
+        return getCalculator().graph.toJSON();
+    }, []));
+    // Update dependency graph
+    var updateDependencyGraph = useCallbackRef(useCallback(function (nodes) {
+        // Reset graph
+        getCalculator().graph.reset();
+        // Update graph
+        getCalculator().graph.fromJSON(JSON.parse(nodes));
+    }, []));
+    var noopCalculationApi = useMemo(function () { return ({
+        enqueueCalculation: function () { },
+        enqueueGraphOperation: function () { },
+        getPrecedents: function () { return []; },
+        getPrecedentsFromFormulaString: function () { return []; },
+        getDependents: function () { return []; },
+        enqueueStructureChange: function () { },
+        clearRangeCache: function () { },
+        deleteSheetReferences: function () { },
+        onRequestCalculate: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+            return [2 /*return*/, undefined];
+        }); }); },
+        getGraphNodes: function () { return new Map(); },
+        getGraphNodesInSheet: function () { return undefined; },
+        addStaticReference: function () { },
+        addFormulaToGraph: function () { },
+        removeStaticReference: function () { },
+        onResetCalculator: function () { },
+        getDependencyGraph: function () { return "[]"; },
+        updateDependencyGraph: function () { },
+        isArrayFormula: function () { return false; },
+        applyNamedRanges: function (_list) { },
+    }); }, []);
+    var api = {
+        enqueueCalculation: enqueueCalculation,
+        enqueueGraphOperation: enqueueGraphOperation,
+        getPrecedents: getPrecedents,
+        getPrecedentsFromFormulaString: getPrecedentsFromFormulaString,
+        getDependents: getDependents,
+        enqueueStructureChange: enqueueStructureChange,
+        clearRangeCache: clearRangeCache,
+        deleteSheetReferences: deleteSheetReferences,
+        onRequestCalculate: onRequestCalculate,
+        getGraphNodes: getGraphNodes,
+        getGraphNodesInSheet: getGraphNodesInSheet,
+        addStaticReference: addStaticReference,
+        addFormulaToGraph: addFormulaToGraph,
+        removeStaticReference: removeStaticReference,
+        onResetCalculator: onResetCalculator,
+        getDependencyGraph: getDependencyGraph,
+        updateDependencyGraph: updateDependencyGraph,
+        isArrayFormula: isArrayFormula,
+        // Phase 9 — exposed so `useCalculationInitialize` can guarantee
+        // named ranges are registered BEFORE cell formulas are parsed
+        // (otherwise cells using a named range would form no DAG edge
+        // to its static node — Excel registers names workbook-wide
+        // before any cell evaluates).
+        applyNamedRanges: applyNamedRanges,
+    };
+    return enabled ? api : noopCalculationApi;
+};