@rowsncolumns/spreadsheet-state 28.0.66

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

@@ -0,0 +1,1868 @@
+import { __assign, __awaiter, __generator, __read, __spreadArray, __values } from "tslib";
+import { CalculationGraph, CalculationWorkerClient, createNamedRangeResolver, createStructuredReferenceResolver, enqueueCalculationOperations, mapOperationToGraphOperation, } from "@rowsncolumns/calculation-worker";
+import { tokenize as formulaTokenizer } from "@rowsncolumns/calculator";
+import { CellNode, CellRangeNode, isCellCoordinate, isCellNode, isCellRangeNode, isStaticNode, makeKey, } from "@rowsncolumns/dag";
+import { FormulaError } from "@rowsncolumns/fast-formula-parser";
+import { isAreasEqual } from "@rowsncolumns/grid";
+import { useCallbackRef } from "@rowsncolumns/spreadsheet";
+import { isAFormula, isNil, scheduleAfterPaint } from "@rowsncolumns/utils";
+import { useCallback, useEffect, useMemo, useRef } from "react";
+import { BehaviorSubject } from "rxjs";
+import { parseFilterSourceRange } from "../api/filter-range";
+import { getFunctionNamesFromFormula } from "../api/immer-utils";
+import { generateCollisionError, isEqualPosition } from "../api/range";
+import { AWAITING_CALCULATION } from "../helpers";
+import { SheetCell } from "../sheet-cell";
+import { useDeferredCalculationFlush } from "./use-deferred-calculation-flush";
+var ensureBatchTiming = function (store, batchId) {
+    var timing = store.get(batchId);
+    if (!timing) {
+        timing = {};
+        store.set(batchId, timing);
+    }
+    return timing;
+};
+var getTimestamp = function () {
+    return typeof performance !== "undefined" && typeof performance.now === "function"
+        ? performance.now()
+        : Date.now();
+};
+var CalculationMetrics = /** @class */ (function () {
+    function CalculationMetrics() {
+        this.histogram = new Map();
+    }
+    CalculationMetrics.prototype.record = function (phase, duration) {
+        if (duration == null || Number.isNaN(duration)) {
+            return;
+        }
+        var bucket = this.histogram.get(phase);
+        if (bucket) {
+            bucket.push(duration);
+        }
+        else {
+            this.histogram.set(phase, [duration]);
+        }
+    };
+    CalculationMetrics.prototype.report = function () {
+        var e_1, _a;
+        var result = {};
+        try {
+            for (var _b = __values(this.histogram), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), phase = _d[0], values = _d[1];
+                if (!values.length)
+                    continue;
+                var sorted = __spreadArray([], __read(values), false).sort(function (a, b) { return a - b; });
+                result[phase] = {
+                    p50: this.getPercentileFromSorted(sorted, 0.5),
+                    p95: this.getPercentileFromSorted(sorted, 0.95),
+                    p99: this.getPercentileFromSorted(sorted, 0.99),
+                };
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return result;
+    };
+    CalculationMetrics.prototype.getPercentileFromSorted = function (values, percentile) {
+        if (!values.length)
+            return 0;
+        var index = Math.min(values.length - 1, Math.max(0, Math.floor(percentile * values.length)));
+        return values[index];
+    };
+    CalculationMetrics.prototype.clear = function () {
+        this.histogram.clear();
+    };
+    return CalculationMetrics;
+}());
+var isSerializedFormulaError = function (value) {
+    return Boolean(value &&
+        typeof value === "object" &&
+        "type" in value &&
+        value.type === "FormulaError");
+};
+var toCellRange = function (position) {
+    if ("startRowIndex" in position) {
+        return position;
+    }
+    return {
+        sheetId: position.sheetId,
+        startRowIndex: position.rowIndex,
+        endRowIndex: position.rowIndex,
+        startColumnIndex: position.columnIndex,
+        endColumnIndex: position.columnIndex,
+    };
+};
+var isWorkerFormulaErrorDetails = function (details) {
+    return (!!details &&
+        typeof details === "object" &&
+        "reason" in details &&
+        typeof details.reason === "string");
+};
+var normalizeArrayResult = function (value) {
+    if (!Array.isArray(value)) {
+        return null;
+    }
+    if (!value.length) {
+        return [[undefined]];
+    }
+    if (Array.isArray(value[0])) {
+        return value;
+    }
+    return [value];
+};
+var getOperationKey = function (operation) {
+    return makeKey(operation.position);
+};
+var VOLATILE_FUNCTIONS = new Set([
+    "NOW",
+    "TODAY",
+    "RAND",
+    "RANDARRAY",
+    "RANDBETWEEN",
+    "SHEET",
+    "SHEETS",
+    "OFFSET",
+    "INDIRECT",
+]);
+var MAX_BUFFERED_RESULTS = 2000;
+var mergePendingOperation = function (current, incoming) {
+    if (!current) {
+        return incoming;
+    }
+    if (incoming.type === "add" || incoming.type === "remove") {
+        return incoming;
+    }
+    if (incoming.type === "dirty") {
+        if (current.type === "add" || current.type === "remove") {
+            return current;
+        }
+        if (current.type === "dirty") {
+            return __assign(__assign({}, current), { force: current.force || incoming.force });
+        }
+    }
+    return incoming;
+};
+var createRangeFromMatrix = function (anchor, matrix) {
+    var _a, _b;
+    var rowCount = Math.max(matrix.length, 1);
+    var columnCount = Math.max((_b = (_a = matrix[0]) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 1, 1);
+    return {
+        sheetId: anchor.sheetId,
+        startRowIndex: anchor.rowIndex,
+        startColumnIndex: anchor.columnIndex,
+        endRowIndex: anchor.rowIndex + rowCount - 1,
+        endColumnIndex: anchor.columnIndex + columnCount - 1,
+    };
+};
+var forEachCellInRange = function (range, iteratee) {
+    var rowOffset = 0;
+    for (var row = range.startRowIndex; row <= range.endRowIndex; row++, rowOffset++) {
+        var columnOffset = 0;
+        for (var column = range.startColumnIndex; column <= range.endColumnIndex; column++, columnOffset++) {
+            var shouldStop = iteratee({ sheetId: range.sheetId, rowIndex: row, columnIndex: column }, { row: rowOffset, column: columnOffset });
+            if (shouldStop) {
+                return;
+            }
+        }
+    }
+};
+var isCoordinateWithinRange = function (position, range) {
+    return (range.sheetId === position.sheetId &&
+        position.rowIndex >= range.startRowIndex &&
+        position.rowIndex <= range.endRowIndex &&
+        position.columnIndex >= range.startColumnIndex &&
+        position.columnIndex <= range.endColumnIndex);
+};
+var rangesOverlap = function (left, right) {
+    if (left.sheetId !== right.sheetId) {
+        return false;
+    }
+    return (left.startRowIndex <= right.endRowIndex &&
+        left.endRowIndex >= right.startRowIndex &&
+        left.startColumnIndex <= right.endColumnIndex &&
+        left.endColumnIndex >= right.startColumnIndex);
+};
+export var useCalculationWorker = function (props) {
+    var _a;
+    var sheets = props.sheets, worker = props.worker, createWorker = props.createWorker, workerLogger = props.workerLogger, activeSheetId = props.activeSheetId, getSheetId = props.getSheetId, getSheetName = props.getSheetName, getEffectiveValue = props.getEffectiveValue, getCellData = props.getCellData, getUserEnteredValue = props.getUserEnteredValue, getConditionalFormatFormula = props.getConditionalFormatFormula, getDataValidationFormula = props.getDataValidationFormula, getEffectiveStructuredValue = props.getEffectiveStructuredValue, onSuccess = props.onSuccess, onBeginCalculation = props.onBeginCalculation, onChangeStaticReference = props.onChangeStaticReference, locale = props.locale, tables = props.tables, namedRanges = props.namedRanges, onDemandFormulaPattern = props.onDemandFormulaPattern, _b = props.coalesceDelayMs, coalesceDelayMs = _b === void 0 ? 0 : _b, _c = props.enablePerformanceLogging, enablePerformanceLogging = _c === void 0 ? false : _c, iterativeCalculation = props.iterativeCalculation, _d = props.enableLazyCalculation, enableLazyCalculation = _d === void 0 ? true : _d, _e = props.enabled, enabled = _e === void 0 ? true : _e;
+    var onSuccessRef = useCallbackRef(onSuccess);
+    var onBeginCalculationRef = useCallbackRef(onBeginCalculation);
+    var onChangeStaticReferenceRef = useCallbackRef(onChangeStaticReference);
+    var getUserEnteredValueRef = useCallbackRef(getUserEnteredValue);
+    var getConditionalFormatFormulaRef = useCallbackRef(getConditionalFormatFormula);
+    var getDataValidationFormulaRef = useCallbackRef(getDataValidationFormula);
+    var getEffectiveValueRef = useCallbackRef(getEffectiveValue);
+    var getEffectiveStructuredValueRef = useCallbackRef(getEffectiveStructuredValue);
+    var getSheetIdRef = useCallbackRef(getSheetId);
+    var getSheetNameRef = useCallbackRef(getSheetName);
+    var onPerformanceEventRef = useCallbackRef(props.onPerformanceEvent);
+    var emitPerformanceEvent = useCallback(function (event) {
+        var _a;
+        if (enablePerformanceLogging && typeof console !== "undefined") {
+            var logger = (_a = console.debug) !== null && _a !== void 0 ? _a : console.log;
+            logger.call(console, "[calc-worker]", event);
+        }
+        onPerformanceEventRef === null || onPerformanceEventRef === void 0 ? void 0 : onPerformanceEventRef(event);
+    }, [enablePerformanceLogging, onPerformanceEventRef]);
+    var pendingVolatileTrackingRef = useRef(new Map());
+    var deferredOperationsBySheetRef = useRef(new Map());
+    var completedCountRef = useRef(0);
+    var statsSubjectRef = useRef(null);
+    if (!statsSubjectRef.current) {
+        statsSubjectRef.current = new BehaviorSubject({
+            queuedCount: 0,
+            inFlightCount: 0,
+            completedCount: 0,
+            deferredCount: 0,
+        });
+    }
+    var processFrameRef = useRef(null);
+    var processingRef = useRef(false);
+    var pendingOperationQueueRef = useRef([]);
+    var pendingOperationMapRef = useRef(new Map());
+    var enqueuePendingOperationRef = useRef(undefined);
+    var isFullRecalcRef = useRef(false);
+    var computedValuesRef = useRef(new Map());
+    var pendingResultsRef = useRef(new Map());
+    var resultFrameRef = useRef(null);
+    var volatileCellsRef = useRef(new Map());
+    var pendingStaticNodesRef = useRef([]);
+    var staticFrameRef = useRef(null);
+    var beginQueueRef = useRef([]);
+    var beginPendingKeysRef = useRef(new Set());
+    var pendingArrayDirtyAnchorsRef = useRef(new Map());
+    var graphRef = useRef(null);
+    var workerInstanceRef = useRef(null);
+    var workerErrorPromiseRef = useRef(null);
+    var workerErrorRejectRef = useRef(null);
+    var workerErrorCleanupRef = useRef(null);
+    var tablesRef = useRef(tables);
+    var namedRangesRef = useRef(namedRanges);
+    var sheetsRef = useRef(sheets);
+    tablesRef.current = tables;
+    namedRangesRef.current = namedRanges;
+    sheetsRef.current = sheets;
+    var scheduleVolatileTracking = useCallback(function (position) {
+        pendingVolatileTrackingRef.current.set(makeKey(position), position);
+    }, []);
+    var structuredReferenceResolver = useMemo(function () {
+        return createStructuredReferenceResolver({
+            getTables: function () { return tablesRef.current; },
+            getSheetName: function (sheetId) { return getSheetNameRef(sheetId); },
+            getSheetId: function (sheetName) {
+                return sheetName ? getSheetIdRef(sheetName) : undefined;
+            },
+        });
+    }, [getSheetNameRef, getSheetIdRef]);
+    var namedRangeResolver = useMemo(function () {
+        return createNamedRangeResolver({
+            getNamedRanges: function () { return namedRangesRef.current; },
+            getSheetName: function (sheetId) { return getSheetNameRef(sheetId); },
+        });
+    }, [getSheetNameRef]);
+    if (!graphRef.current) {
+        graphRef.current = new CalculationGraph({
+            getSheetId: function (name) { return getSheetIdRef(name); },
+            getSheetName: function (id) { return getSheetNameRef(id); },
+            getFormula: function (position) {
+                var value = getFinalUserEnteredValue(position);
+                return typeof value === "string" ? value : undefined;
+            },
+            getCellValue: function (position, property) {
+                var key = makeKey(position);
+                if (computedValuesRef.current.has(key)) {
+                    var cached = computedValuesRef.current.get(key);
+                    if (property) {
+                        if (!getEffectiveStructuredValueRef) {
+                            return undefined;
+                        }
+                        var resolved = getEffectiveStructuredValueRef(cached, property);
+                        return resolved;
+                    }
+                    return cached;
+                }
+                return getEffectiveValueRef(position.sheetId, position.rowIndex, position.columnIndex, property);
+            },
+            getSheetProperties: function (sheetId) {
+                var sheet = sheetsRef.current.find(function (s) { return s.id === sheetId; });
+                if (!sheet)
+                    return undefined;
+                return {
+                    rowCount: sheet.rowCount,
+                    columnCount: sheet.columnCount,
+                };
+            },
+            depParserConfig: {
+                onStructuredReference: structuredReferenceResolver,
+                onVariable: namedRangeResolver,
+            },
+            iterativeCalculation: iterativeCalculation,
+        });
+    }
+    var graph = graphRef.current;
+    useEffect(function () {
+        graph.setIterativeCalculationOptions(iterativeCalculation);
+    }, [graph, iterativeCalculation]);
+    var ensureWorkerInstance = function () {
+        if (workerInstanceRef.current) {
+            return workerInstanceRef.current;
+        }
+        var instance = worker !== null && worker !== void 0 ? worker : createWorker === null || createWorker === void 0 ? void 0 : createWorker();
+        if (!instance) {
+            throw new Error("Calculation worker not provided. Pass a worker or createWorker factory.");
+        }
+        workerInstanceRef.current = instance;
+        workerErrorPromiseRef.current = new Promise(function (_, reject) {
+            workerErrorRejectRef.current = reject;
+        });
+        var handleWorkerError = function (event) {
+            var _a, _b;
+            var error = (event === null || event === void 0 ? void 0 : event.error) instanceof Error
+                ? event.error
+                : new Error((_a = event === null || event === void 0 ? void 0 : event.message) !== null && _a !== void 0 ? _a : "Calculation worker failed to load.");
+            (_b = workerErrorRejectRef.current) === null || _b === void 0 ? void 0 : _b.call(workerErrorRejectRef, error);
+        };
+        instance.addEventListener("error", handleWorkerError);
+        workerErrorCleanupRef.current = function () {
+            instance.removeEventListener("error", handleWorkerError);
+        };
+        return instance;
+    };
+    var workerClientRef = useRef(null);
+    var workerClientStub = useMemo(function () {
+        return ({
+            initialize: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                return [2 /*return*/];
+            }); }); },
+            dispose: function () { },
+            cancel: function () { },
+            evaluate: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                return [2 /*return*/, []];
+            }); }); },
+        });
+    }, []);
+    if (!workerClientRef.current) {
+        workerClientRef.current = enabled
+            ? new CalculationWorkerClient({
+                worker: ensureWorkerInstance(),
+                logger: workerLogger,
+                enableNumericMatrixTransfer: true,
+            })
+            : workerClientStub;
+    }
+    else if (enabled && workerClientRef.current === workerClientStub) {
+        workerClientRef.current = new CalculationWorkerClient({
+            worker: ensureWorkerInstance(),
+            logger: workerLogger,
+            enableNumericMatrixTransfer: true,
+        });
+    }
+    else if (!enabled && workerClientRef.current !== workerClientStub) {
+        (_a = workerErrorCleanupRef.current) === null || _a === void 0 ? void 0 : _a.call(workerErrorCleanupRef);
+        workerClientRef.current.dispose();
+        workerInstanceRef.current = null;
+        workerErrorPromiseRef.current = null;
+        workerErrorRejectRef.current = null;
+        workerClientRef.current = workerClientStub;
+    }
+    var workerClient = workerClientRef.current;
+    var workerReadyRef = useRef(false);
+    var pendingUserValueEditsRef = useRef(new Map());
+    var getFinalUserEnteredValue = useCallback(function (position) {
+        var pendingKey = makeKey(position);
+        if (pendingUserValueEditsRef.current.has(pendingKey)) {
+            return pendingUserValueEditsRef.current.get(pendingKey);
+        }
+        var conditionalFormatId = position.conditionalFormatId, dataValidationId = position.dataValidationId;
+        if (!isNil(conditionalFormatId)) {
+            return getConditionalFormatFormulaRef(position.sheetId, position.rowIndex, position.columnIndex, conditionalFormatId);
+        }
+        if (!isNil(dataValidationId)) {
+            return getDataValidationFormulaRef(position.sheetId, position.rowIndex, position.columnIndex, dataValidationId);
+        }
+        return getUserEnteredValueRef(position.sheetId, position.rowIndex, position.columnIndex);
+    }, [
+        getConditionalFormatFormulaRef,
+        getDataValidationFormulaRef,
+        getUserEnteredValueRef,
+    ]);
+    var updateVolatileFormulaTracking = useCallback(function (position) {
+        var userValue = getFinalUserEnteredValue(position);
+        var key = makeKey(position);
+        volatileCellsRef.current.delete(key);
+        if (typeof userValue !== "string") {
+            return;
+        }
+        var normalized = userValue.trim();
+        if (!normalized.startsWith("=")) {
+            return;
+        }
+        var formula = normalized.slice(1);
+        var fns = getFunctionNamesFromFormula(formula);
+        if (fns.some(function (fn) { return VOLATILE_FUNCTIONS.has(fn.toUpperCase()); })) {
+            volatileCellsRef.current.set(key, position);
+        }
+    }, [getFinalUserEnteredValue]);
+    var flushVolatileTracking = useCallback(function () {
+        // Volatile formulas enqueue themselves asynchronously—flush the buffered
+        // positions once per processing pass so we only rescan the formulas we saw.
+        if (!pendingVolatileTrackingRef.current.size) {
+            return;
+        }
+        pendingVolatileTrackingRef.current.forEach(function (position) {
+            return updateVolatileFormulaTracking(position);
+        });
+        pendingVolatileTrackingRef.current.clear();
+    }, [updateVolatileFormulaTracking]);
+    var queueAnchorDirty = useCallback(function (anchor) {
+        // Array anchors can request a follow-up recalc once spill conflicts clear;
+        // track a pending flag so we only enqueue a single dirty op per anchor.
+        var key = makeKey(anchor);
+        if (collisionAnchorsRef.current.has(key)) {
+            return;
+        }
+        var pending = pendingArrayDirtyAnchorsRef.current;
+        if (pending.has(key)) {
+            pending.set(key, true);
+            return;
+        }
+        if (!enqueuePendingOperationRef.current) {
+            return;
+        }
+        pending.set(key, false);
+        enqueuePendingOperationRef.current({
+            type: "dirty",
+            position: anchor,
+            force: true,
+        });
+    }, []);
+    var markAnchorProcessed = useCallback(function (anchor) {
+        var key = makeKey(anchor);
+        var pending = pendingArrayDirtyAnchorsRef.current;
+        var shouldRetry = pending.get(key);
+        pending.delete(key);
+        if (shouldRetry) {
+            queueAnchorDirty(anchor);
+        }
+    }, [queueAnchorDirty]);
+    var graphOperationQueueRef = useRef([]);
+    var graphOperationFrameRef = useRef(null);
+    var arrayRangeCacheRef = useRef(new Map());
+    var findCachedArrayAnchor = useCallback(function (position) {
+        var e_2, _a;
+        try {
+            for (var _b = __values(arrayRangeCacheRef.current.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var entry = _c.value;
+                if (isCoordinateWithinRange(position, entry.range)) {
+                    return entry.anchor;
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return undefined;
+    }, []);
+    var workerForceRecalcKeysRef = useRef(new Set());
+    var activeWorkerKeysRef = useRef(new Set());
+    var activeExecutionsRef = useRef(0);
+    var emitStats = useCallback(function () {
+        var statsSubject = statsSubjectRef.current;
+        if (!statsSubject) {
+            return;
+        }
+        var deferredCount = 0;
+        deferredOperationsBySheetRef.current.forEach(function (operations) {
+            deferredCount += operations.size;
+        });
+        statsSubject.next({
+            queuedCount: pendingOperationMapRef.current.size,
+            inFlightCount: activeWorkerKeysRef.current.size,
+            completedCount: completedCountRef.current,
+            deferredCount: deferredCount,
+        });
+    }, []);
+    var deferCalculationNodes = useCallback(function (positions) {
+        var e_3, _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: workerForceRecalcKeysRef.current.has(key),
+                });
+                deferredOperationsBySheetRef.current.set(sheetId, existing);
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (positions_1_1 && !positions_1_1.done && (_a = positions_1.return)) _a.call(positions_1);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        emitStats();
+    }, [emitStats]);
+    var cancelInflightEvaluation = useCallback(function (target) {
+        if (!target) {
+            return;
+        }
+        var key = typeof target === "string" ? target : makeKey(target);
+        if (activeWorkerKeysRef.current.has(key)) {
+            activeWorkerKeysRef.current.delete(key);
+            emitStats();
+        }
+        workerClient.cancel([key]);
+    }, [emitStats, workerClient]);
+    var onDemandPattern = useMemo(function () {
+        if (!onDemandFormulaPattern)
+            return undefined;
+        return new RegExp(onDemandFormulaPattern, "gi");
+    }, [onDemandFormulaPattern]);
+    var workerBatchTimingRef = useRef(new Map());
+    var batchSizesRef = useRef(new Map());
+    var batchesWithFirstResultLoggedRef = useRef(new Set());
+    var metricsRef = useRef(new CalculationMetrics());
+    var emitBatchPhaseEvent = useCallback(function (phase, options) {
+        var _a, _b;
+        var batchId = options.batchId;
+        if (!batchId) {
+            return;
+        }
+        var size = options.size && options.size > 0
+            ? options.size
+            : (_a = batchSizesRef.current.get(batchId)) !== null && _a !== void 0 ? _a : 0;
+        var timestamp = (_b = options.timestamp) !== null && _b !== void 0 ? _b : getTimestamp();
+        var timing = ensureBatchTiming(workerBatchTimingRef.current, batchId);
+        // The switch below materializes a pseudo state machine so we can derive
+        // durations for every phase even if some events arrive out of order.
+        var duration = options.duration;
+        switch (phase) {
+            case "start":
+                timing.start = timestamp;
+                break;
+            case "plan-built":
+                if (!timing.start) {
+                    timing.start = timestamp;
+                }
+                duration !== null && duration !== void 0 ? duration : (duration = timing.start != null ? timestamp - timing.start : undefined);
+                timing.planBuilt = timestamp;
+                break;
+            case "worker-dispatch":
+                duration !== null && duration !== void 0 ? duration : (duration = timing.planBuilt != null
+                    ? timestamp - timing.planBuilt
+                    : timing.start != null
+                        ? timestamp - timing.start
+                        : undefined);
+                timing.workerDispatch = timestamp;
+                break;
+            case "worker-runtime-complete":
+                if (duration == null) {
+                    duration =
+                        timing.workerDispatch != null
+                            ? timestamp - timing.workerDispatch
+                            : undefined;
+                }
+                timing.workerRuntimeComplete = timestamp;
+                break;
+            case "first-result":
+                if (timing.firstResult) {
+                    return;
+                }
+                duration !== null && duration !== void 0 ? duration : (duration = timing.workerDispatch != null
+                    ? timestamp - timing.workerDispatch
+                    : timing.planBuilt != null
+                        ? timestamp - timing.planBuilt
+                        : undefined);
+                timing.firstResult = timestamp;
+                break;
+            case "worker-complete":
+                duration !== null && duration !== void 0 ? duration : (duration = timing.workerRuntimeComplete != null
+                    ? timestamp - timing.workerRuntimeComplete
+                    : undefined);
+                timing.workerComplete = timestamp;
+                break;
+            case "complete":
+                duration !== null && duration !== void 0 ? duration : (duration = timing.start != null ? timestamp - timing.start : undefined);
+                timing.complete = timestamp;
+                workerBatchTimingRef.current.delete(batchId);
+                batchSizesRef.current.delete(batchId);
+                batchesWithFirstResultLoggedRef.current.delete(batchId);
+                break;
+        }
+        metricsRef.current.record(phase, duration);
+        if (enablePerformanceLogging && phase === "complete") {
+            var report = metricsRef.current.report();
+            if (Object.keys(report).length && typeof console !== "undefined") {
+                if (typeof console.table === "function") {
+                    console.table(report);
+                }
+                else if (typeof console.debug === "function") {
+                    console.debug("[calc-worker][metrics]", report);
+                }
+                else if (typeof console.log === "function") {
+                    console.log("[calc-worker][metrics]", report);
+                }
+            }
+        }
+        emitPerformanceEvent({
+            type: "worker-batch",
+            phase: phase,
+            batchId: batchId,
+            size: size,
+            timestamp: timestamp,
+            duration: duration,
+        });
+    }, [emitPerformanceEvent, enablePerformanceLogging]);
+    var beginBatchTracking = useCallback(function (plan, size, startTimestamp) {
+        batchSizesRef.current.set(plan.id, size);
+        emitBatchPhaseEvent("start", {
+            batchId: plan.id,
+            size: size,
+            timestamp: startTimestamp,
+        });
+    }, [emitBatchPhaseEvent]);
+    var handlePlanBuilt = useCallback(function (plan, startTimestamp) {
+        var cellCount = plan.nodes.filter(function (node) { return node.kind === "cell"; }).length;
+        if (!cellCount) {
+            return;
+        }
+        beginBatchTracking(plan, cellCount, startTimestamp);
+        emitBatchPhaseEvent("plan-built", { batchId: plan.id, size: cellCount });
+    }, [emitBatchPhaseEvent, beginBatchTracking]);
+    var handleWorkerBatchEvent = useCallback(function (event, batchId) {
+        if (event.phase === "worker-dispatch") {
+            batchSizesRef.current.set(batchId, event.batchSize);
+            emitBatchPhaseEvent("worker-dispatch", {
+                batchId: batchId,
+                timestamp: event.timestamp,
+                size: event.batchSize,
+            });
+            return;
+        }
+        emitBatchPhaseEvent("worker-runtime-complete", {
+            batchId: batchId,
+            timestamp: event.timestamp,
+            duration: event.duration,
+            size: event.batchSize,
+        });
+    }, [emitBatchPhaseEvent]);
+    var pushPendingOperation = useCallback(function (operation) {
+        var _a;
+        // Prevent stale worker responses from racing the new work by tearing down
+        // any inflight evaluations for the affected cells.
+        cancelInflightEvaluation(operation.position);
+        if (operation.previousPosition) {
+            cancelInflightEvaluation(operation.previousPosition);
+        }
+        if (operation.type !== "dirty") {
+            var anchor = (_a = graph.getArrayParent(operation.position)) !== null && _a !== void 0 ? _a : findCachedArrayAnchor(operation.position);
+            if (anchor && !isEqualPosition(anchor, operation.position)) {
+                queueAnchorDirty(anchor);
+            }
+        }
+        var key = getOperationKey(operation);
+        var existing = pendingOperationMapRef.current.get(key);
+        // Coalesce successive edits on the same cell so we only schedule the most
+        // recent intent and avoid redundant graph rebuilds.
+        var merged = mergePendingOperation(existing, operation);
+        if (merged === existing) {
+            return false;
+        }
+        pendingOperationMapRef.current.set(key, merged);
+        if (!existing) {
+            pendingOperationQueueRef.current.push(key);
+        }
+        if (operation.force) {
+            workerForceRecalcKeysRef.current.add(key);
+        }
+        return true;
+    }, [cancelInflightEvaluation, graph, findCachedArrayAnchor, queueAnchorDirty]);
+    var enqueueVolatileCells = useCallback(function () {
+        // Volatile cells always recalc with the next batch so they can pick up
+        // global changes (time, randomization, etc.).
+        volatileCellsRef.current.forEach(function (position) {
+            var key = makeKey(position);
+            if (!pendingOperationMapRef.current.has(key)) {
+                pushPendingOperation({
+                    type: "dirty",
+                    position: position,
+                    force: true,
+                });
+            }
+        });
+    }, [pushPendingOperation]);
+    var deserializeResultValue = useCallback(function (value) {
+        var _a;
+        if (isSerializedFormulaError(value)) {
+            var rawDetails = value.details;
+            var structured = void 0;
+            var summary = void 0;
+            if (typeof rawDetails === "string") {
+                summary = rawDetails;
+            }
+            else if (isWorkerFormulaErrorDetails(rawDetails)) {
+                structured = rawDetails;
+                summary = structured.reason;
+            }
+            else if (rawDetails != null) {
+                summary = String((_a = rawDetails.message) !== null && _a !== void 0 ? _a : rawDetails);
+            }
+            var error = new FormulaError(value.error, summary, summary);
+            error.details = structured !== null && structured !== void 0 ? structured : rawDetails;
+            return error;
+        }
+        return value;
+    }, []);
+    var flushStaticNotifications = useCallback(function () {
+        staticFrameRef.current = null;
+        if (!pendingStaticNodesRef.current.length)
+            return;
+        onChangeStaticReferenceRef === null || onChangeStaticReferenceRef === void 0 ? void 0 : onChangeStaticReferenceRef(pendingStaticNodesRef.current.slice());
+        pendingStaticNodesRef.current = [];
+    }, [onChangeStaticReferenceRef]);
+    var queueStaticNotification = useCallback(function (node) {
+        pendingStaticNodesRef.current.push(node);
+        if (staticFrameRef.current == null) {
+            staticFrameRef.current = requestAnimationFrame(flushStaticNotifications);
+        }
+    }, [flushStaticNotifications]);
+    var flushResults = useCallback(function () {
+        var e_4, _a;
+        resultFrameRef.current = null;
+        if (!pendingResultsRef.current.size)
+            return;
+        var isFullRecalc = isFullRecalcRef.current;
+        var pendingResults = pendingResultsRef.current;
+        onSuccessRef === null || onSuccessRef === void 0 ? void 0 : onSuccessRef(pendingResults.values(), isFullRecalc, {});
+        try {
+            // Once the consumer receives the batch we can drop the temporary cache so
+            // large evaluations (e.g. VLOOKUP matrices) don't accumulate in memory.
+            for (var _b = __values(pendingResults.keys()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var key = _c.value;
+                computedValuesRef.current.delete(key);
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+        pendingResults.clear();
+        isFullRecalcRef.current = false;
+    }, [onSuccessRef]);
+    var queueCellValue = useCallback(function (position, value, formatting) {
+        // Buffer results until the next frame so grid updates stay batched and
+        // React state observers only process one consolidated payload.
+        var key = makeKey(position);
+        pendingUserValueEditsRef.current.delete(key);
+        computedValuesRef.current.set(key, value);
+        pendingResultsRef.current.set(key, [position, value, formatting]);
+        workerForceRecalcKeysRef.current.delete(key);
+        beginPendingKeysRef.current.delete(key);
+        if (pendingResultsRef.current.size >= MAX_BUFFERED_RESULTS) {
+            var frame = resultFrameRef.current;
+            if (frame != null) {
+                cancelAnimationFrame(frame);
+                resultFrameRef.current = null;
+            }
+            flushResults();
+            return;
+        }
+        if (resultFrameRef.current == null) {
+            resultFrameRef.current = requestAnimationFrame(flushResults);
+        }
+    }, [flushResults]);
+    var flushBeginNotifications = useCallback(function () {
+        if (!beginQueueRef.current.length)
+            return;
+        // Swap queue with empty array - O(1) operation
+        // This avoids O(n²) complexity from using shift() in a loop
+        var operations = beginQueueRef.current;
+        beginQueueRef.current = [];
+        var pending = [];
+        var pendingKeys = beginPendingKeysRef.current;
+        // Process all operations - O(n) total
+        for (var i = 0; i < operations.length; i++) {
+            var position = operations[i];
+            if (!position) {
+                continue;
+            }
+            var key = makeKey(position);
+            if (pendingKeys.has(key)) {
+                pendingKeys.delete(key);
+                pending.push(position);
+            }
+        }
+        if (!pending.length)
+            return;
+        onBeginCalculationRef === null || onBeginCalculationRef === void 0 ? void 0 : onBeginCalculationRef(pending);
+    }, [onBeginCalculationRef]);
+    var enqueueBeginPosition = useCallback(function (position) {
+        var key = makeKey(position);
+        if (beginPendingKeysRef.current.has(key)) {
+            return;
+        }
+        beginPendingKeysRef.current.add(key);
+        // Ignore other node types
+        if (position.conditionalFormatId || position.dataValidationId) {
+            return;
+        }
+        beginQueueRef.current.push(position);
+        flushBeginNotifications();
+    }, [flushBeginNotifications]);
+    var preparePlanForExecution = useCallback(function (plan) {
+        var e_5, _a, e_6, _b, e_7, _c;
+        var cellNodes = plan.nodes.filter(function (node) { return node.kind === "cell"; });
+        if (!cellNodes.length)
+            return;
+        // Cancel any inflight evaluations for nodes in this plan
+        var keysToCancel = [];
+        try {
+            for (var cellNodes_1 = __values(cellNodes), cellNodes_1_1 = cellNodes_1.next(); !cellNodes_1_1.done; cellNodes_1_1 = cellNodes_1.next()) {
+                var node = cellNodes_1_1.value;
+                var key = makeKey(node.position);
+                if (activeWorkerKeysRef.current.has(key)) {
+                    keysToCancel.push(key);
+                    activeWorkerKeysRef.current.delete(key);
+                }
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (cellNodes_1_1 && !cellNodes_1_1.done && (_a = cellNodes_1.return)) _a.call(cellNodes_1);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+        if (keysToCancel.length) {
+            workerClient.cancel(keysToCancel);
+        }
+        var filteredNodes = [];
+        try {
+            for (var cellNodes_2 = __values(cellNodes), cellNodes_2_1 = cellNodes_2.next(); !cellNodes_2_1.done; cellNodes_2_1 = cellNodes_2.next()) {
+                var node = cellNodes_2_1.value;
+                var key = makeKey(node.position);
+                if (onDemandPattern) {
+                    onDemandPattern.lastIndex = 0;
+                }
+                var userValue = getFinalUserEnteredValue(node.position);
+                if (typeof userValue === "string" &&
+                    userValue.startsWith("=") &&
+                    (onDemandPattern === null || onDemandPattern === void 0 ? void 0 : onDemandPattern.test(userValue)) &&
+                    !workerForceRecalcKeysRef.current.has(key)) {
+                    // On-demand formulas opt-out of real execution until explicitly
+                    // forced; they still emit begin/end notifications so the UI shows a
+                    // deterministic "Awaiting calculation" placeholder.
+                    beginPendingKeysRef.current.delete(key);
+                    queueCellValue(node.position, AWAITING_CALCULATION);
+                    continue;
+                }
+                filteredNodes.push(node);
+            }
+        }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (cellNodes_2_1 && !cellNodes_2_1.done && (_b = cellNodes_2.return)) _b.call(cellNodes_2);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
+        if (filteredNodes.length !== cellNodes.length) {
+            var staticNodes = plan.nodes.filter(function (node) { return node.kind === "static"; });
+            plan.nodes = __spreadArray(__spreadArray([], __read(staticNodes), false), __read(filteredNodes), false);
+        }
+        try {
+            for (var filteredNodes_1 = __values(filteredNodes), filteredNodes_1_1 = filteredNodes_1.next(); !filteredNodes_1_1.done; filteredNodes_1_1 = filteredNodes_1.next()) {
+                var node = filteredNodes_1_1.value;
+                activeWorkerKeysRef.current.add(makeKey(node.position));
+            }
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (filteredNodes_1_1 && !filteredNodes_1_1.done && (_c = filteredNodes_1.return)) _c.call(filteredNodes_1);
+            }
+            finally { if (e_7) throw e_7.error; }
+        }
+        emitStats();
+    }, [
+        getFinalUserEnteredValue,
+        emitStats,
+        workerClient,
+        onDemandPattern,
+        queueCellValue,
+    ]);
+    var handleNodeBegin = useCallback(function (node) {
+        // Track inflight keys so late worker responses can be ignored/cancelled.
+        activeWorkerKeysRef.current.add(makeKey(node.position));
+        if (node.kind === "cell") {
+            enqueueBeginPosition(node.position);
+        }
+    }, [enqueueBeginPosition]);
+    var normalizePropertyOverride = useCallback(function (value, property) {
+        // Property accessors piggyback on the sheet-side structured resolver so
+        // worker scopes respect table/object semantics already in place.
+        if (value == null || typeof value !== "object" || Array.isArray(value)) {
+            return value;
+        }
+        if (!getEffectiveStructuredValueRef) {
+            return undefined;
+        }
+        return getEffectiveStructuredValueRef(value, property);
+    }, [getEffectiveStructuredValueRef]);
+    var detectArrayCollision = useCallback(function (range, anchor, preserve) {
+        // Spills cannot overwrite typed-in values or another array range.
+        var anchorKey = makeKey(anchor);
+        var conflict;
+        forEachCellInRange(range, function (cell) {
+            var key = makeKey(cell);
+            if (key === anchorKey || (preserve === null || preserve === void 0 ? void 0 : preserve.has(key))) {
+                return;
+            }
+            var userValue = getFinalUserEnteredValue(cell);
+            if (userValue != null) {
+                conflict = cell;
+                return true;
+            }
+            var parent = graph.getArrayParent(cell);
+            if (parent && isEqualPosition(parent, anchor)) {
+                return;
+            }
+            if (parent) {
+                conflict = cell;
+                return true;
+            }
+            return;
+        });
+        return conflict;
+    }, [getFinalUserEnteredValue, graph]);
+    var pendingSpillDependentAnchorsRef = useRef(new Set());
+    var collisionAnchorsRef = useRef(new Set());
+    var scheduleSpillDependents = useCallback(function (range, anchor) {
+        // Any dependent referencing a previously spilled cell must be dirtied so
+        // it recomputes with the anchor's new footprint.
+        if (!enqueuePendingOperationRef.current)
+            return;
+        var scheduled = new Set();
+        forEachCellInRange(range, function (cell) {
+            var e_8, _a;
+            var _b;
+            if (isEqualPosition(cell, anchor)) {
+                return;
+            }
+            var dependents = graph.getDependents(cell);
+            try {
+                for (var dependents_1 = __values(dependents), dependents_1_1 = dependents_1.next(); !dependents_1_1.done; dependents_1_1 = dependents_1.next()) {
+                    var dependent = dependents_1_1.value;
+                    if (!isCellNode(dependent) || !dependent.position) {
+                        continue;
+                    }
+                    if (isEqualPosition(dependent.position, anchor)) {
+                        continue;
+                    }
+                    var dependentKey = makeKey(dependent.position);
+                    if (scheduled.has(dependentKey))
+                        continue;
+                    scheduled.add(dependentKey);
+                    (_b = enqueuePendingOperationRef.current) === null || _b === void 0 ? void 0 : _b.call(enqueuePendingOperationRef, {
+                        type: "dirty",
+                        position: dependent.position,
+                        force: true,
+                    });
+                }
+            }
+            catch (e_8_1) { e_8 = { error: e_8_1 }; }
+            finally {
+                try {
+                    if (dependents_1_1 && !dependents_1_1.done && (_a = dependents_1.return)) _a.call(dependents_1);
+                }
+                finally { if (e_8) throw e_8.error; }
+            }
+        });
+    }, [graph]);
+    var clearArrayValues = useCallback(function (anchor, options) {
+        var _a;
+        if (options === void 0) { options = {}; }
+        // Helper for resetting existing spill results before writing new matrix
+        // values, with knobs for preserving user edits/registration metadata.
+        var anchorKey = makeKey(anchor);
+        var cachedEntry = arrayRangeCacheRef.current.get(anchorKey);
+        var range = (_a = graph.getArrayRangeFor(anchor)) !== null && _a !== void 0 ? _a : cachedEntry === null || cachedEntry === void 0 ? void 0 : cachedEntry.range;
+        if (range) {
+            var preserve_1 = new Set(options.preserveKeys);
+            if (options.preserveUserEntries) {
+                forEachCellInRange(range, function (cell) {
+                    if (isEqualPosition(cell, anchor)) {
+                        return;
+                    }
+                    var userValue = getFinalUserEnteredValue(cell);
+                    if (userValue != null &&
+                        (typeof userValue !== "string" || !userValue.startsWith("="))) {
+                        preserve_1.add(makeKey(cell));
+                    }
+                });
+            }
+            forEachCellInRange(range, function (cell) {
+                var key = makeKey(cell);
+                if ((!options.includeAnchor && key === anchorKey) ||
+                    preserve_1.has(key)) {
+                    return;
+                }
+                if (options.preserveComputedValues && key !== anchorKey) {
+                    return;
+                }
+                queueCellValue(cell, undefined);
+            });
+            if (options.notifyDependents) {
+                scheduleSpillDependents(range, anchor);
+            }
+            else if (options.deferDependents) {
+                pendingSpillDependentAnchorsRef.current.add(anchorKey);
+            }
+        }
+        if (!options.preserveRegistration) {
+            graph.unregisterArrayFormula(anchor);
+        }
+        if (options.forgetRange) {
+            arrayRangeCacheRef.current.delete(anchorKey);
+        }
+        else if (range) {
+            arrayRangeCacheRef.current.set(anchorKey, {
+                anchor: anchor,
+                range: range,
+            });
+        }
+    }, [graph, queueCellValue, scheduleSpillDependents, getFinalUserEnteredValue]);
+    var handleArrayEvaluation = useCallback(function (position, rawValue) {
+        // Array formulas emit either matrices or scalars; normalize + register
+        // spill metadata before writing values back to cells.
+        var matrix = normalizeArrayResult(rawValue);
+        if (!matrix) {
+            clearArrayValues(position, { preserveUserEntries: true });
+            queueCellValue(position, deserializeResultValue(rawValue));
+            markAnchorProcessed(position);
+            return;
+        }
+        clearArrayValues(position, {
+            preserveUserEntries: true,
+            preserveComputedValues: true,
+            deferDependents: true,
+        });
+        var range = createRangeFromMatrix(position, matrix);
+        var collision = detectArrayCollision(range, position);
+        graph.registerArrayFormula(position, range);
+        arrayRangeCacheRef.current.set(makeKey(position), {
+            anchor: position,
+            range: range,
+        });
+        var anchorFormula = getFinalUserEnteredValue(position);
+        var filterSourceRange = parseFilterSourceRange(typeof anchorFormula === "string" ? anchorFormula : undefined, position.sheetId, getSheetIdRef, formulaTokenizer);
+        var sourceSheetCell = new SheetCell();
+        var filterColumnFormattingCache = new Map();
+        var getFilterFormatting = function (columnOffset, rowOffset) {
+            if (!filterSourceRange) {
+                return undefined;
+            }
+            var sourceColumnIndex = filterSourceRange.startColumnIndex + columnOffset;
+            if (sourceColumnIndex < filterSourceRange.startColumnIndex ||
+                sourceColumnIndex > filterSourceRange.endColumnIndex) {
+                return undefined;
+            }
+            var cachedFormatting = filterColumnFormattingCache.get(sourceColumnIndex);
+            if (cachedFormatting) {
+                return cachedFormatting;
+            }
+            var preferredSourceRowIndex = filterSourceRange.startRowIndex + rowOffset;
+            var getSourceNumberFormat = function (sourceRowIndex) {
+                var _a;
+                var sourceCellData = getCellData(filterSourceRange.sheetId, sourceRowIndex, sourceColumnIndex);
+                return (_a = sourceSheetCell
+                    .assign(filterSourceRange.sheetId, {
+                    rowIndex: sourceRowIndex,
+                    columnIndex: sourceColumnIndex,
+                }, sourceCellData, { locale: locale })
+                    .getEffectiveCellFormat()) === null || _a === void 0 ? void 0 : _a.numberFormat;
+            };
+            if (preferredSourceRowIndex >= filterSourceRange.startRowIndex &&
+                preferredSourceRowIndex <= filterSourceRange.endRowIndex) {
+                var preferredNumberFormat = getSourceNumberFormat(preferredSourceRowIndex);
+                if (preferredNumberFormat) {
+                    var formatting = { numberFormat: preferredNumberFormat };
+                    filterColumnFormattingCache.set(sourceColumnIndex, formatting);
+                    return formatting;
+                }
+            }
+            for (var sourceRowIndex = filterSourceRange.startRowIndex; sourceRowIndex <= filterSourceRange.endRowIndex; sourceRowIndex += 1) {
+                var sourceNumberFormat = getSourceNumberFormat(sourceRowIndex);
+                if (sourceNumberFormat) {
+                    var formatting = { numberFormat: sourceNumberFormat };
+                    filterColumnFormattingCache.set(sourceColumnIndex, formatting);
+                    return formatting;
+                }
+            }
+            filterColumnFormattingCache.set(sourceColumnIndex, undefined);
+            return undefined;
+        };
+        if (collision) {
+            var preserve = new Set([makeKey(collision)]);
+            clearArrayValues(position, {
+                preserveKeys: preserve,
+                preserveUserEntries: true,
+                includeAnchor: false,
+                preserveRegistration: true,
+            });
+            var conflictingValue = getFinalUserEnteredValue(collision);
+            var collisionKey = makeKey(collision);
+            var usedPendingUserEdit = false;
+            if (conflictingValue === undefined) {
+                var pendingValue = pendingUserValueEditsRef.current.get(collisionKey);
+                if (pendingValue !== undefined) {
+                    conflictingValue = pendingValue;
+                    usedPendingUserEdit = true;
+                }
+            }
+            if (conflictingValue === undefined &&
+                computedValuesRef.current.has(collisionKey)) {
+                conflictingValue = computedValuesRef.current.get(collisionKey);
+            }
+            if (conflictingValue === undefined) {
+                var effective = getEffectiveValueRef(collision.sheetId, collision.rowIndex, collision.columnIndex);
+                if (effective != null) {
+                    conflictingValue = effective;
+                }
+            }
+            if (conflictingValue !== undefined) {
+                queueCellValue(collision, conflictingValue);
+                flushResults();
+                if (usedPendingUserEdit) {
+                    pendingUserValueEditsRef.current.delete(collisionKey);
+                }
+            }
+            queueCellValue(position, generateCollisionError(collision));
+            scheduleSpillDependents(range, position);
+            collisionAnchorsRef.current.add(makeKey(position));
+            pendingSpillDependentAnchorsRef.current.delete(makeKey(position));
+            markAnchorProcessed(position);
+            return;
+        }
+        forEachCellInRange(range, function (cell, offsets) {
+            var _a;
+            var value = (_a = matrix[offsets.row]) === null || _a === void 0 ? void 0 : _a[offsets.column];
+            queueCellValue(cell, value !== null && value !== void 0 ? value : undefined, getFilterFormatting(offsets.column, offsets.row));
+        });
+        pendingSpillDependentAnchorsRef.current.delete(makeKey(position));
+        scheduleSpillDependents(range, position);
+        collisionAnchorsRef.current.delete(makeKey(position));
+        markAnchorProcessed(position);
+    }, [
+        flushResults,
+        clearArrayValues,
+        detectArrayCollision,
+        graph,
+        queueCellValue,
+        deserializeResultValue,
+        scheduleSpillDependents,
+        getFinalUserEnteredValue,
+        getCellData,
+        getEffectiveValueRef,
+        getSheetIdRef,
+        markAnchorProcessed,
+        locale,
+    ]);
+    var resolveFormulaForOperation = useCallback(function (operation) {
+        var userValue = getFinalUserEnteredValue(operation.position);
+        return typeof userValue === "string" ? userValue : undefined;
+    }, [getFinalUserEnteredValue]);
+    var flushGraphOperations = useCallback(function () {
+        // Some graph operations (like static reference tweaks) are buffered so we
+        // can batch DAG mutations alongside user edits.
+        graphOperationFrameRef.current = null;
+        if (!graphOperationQueueRef.current.length)
+            return;
+        var operations = graphOperationQueueRef.current;
+        graphOperationQueueRef.current = [];
+        var graphOperations = operations
+            .map(function (operation) {
+            return mapOperationToGraphOperation(operation, resolveFormulaForOperation);
+        })
+            .filter(function (op) {
+            return Boolean(op);
+        });
+        if (!graphOperations.length)
+            return;
+        graph.applyGraphOperations(graphOperations);
+    }, [graph, resolveFormulaForOperation]);
+    var onAfterCalculation = useCallback(function () {
+        // Once every batch completes we either cleanup immediately or defer if more
+        // dirty anchors/operations are queued, preventing premature cache resets.
+        if (pendingOperationQueueRef.current.length ||
+            pendingArrayDirtyAnchorsRef.current.size) {
+            graph.cleanup();
+            workerForceRecalcKeysRef.current.clear();
+            return;
+        }
+        computedValuesRef.current.clear();
+        graph.cleanup();
+        workerForceRecalcKeysRef.current.clear();
+    }, [graph]);
+    var scheduleProcessingRef = useRef(function () { });
+    var handleResult = useCallback(function (result, batchId) {
+        // Record the first payload for perf metrics before we mutate caches.
+        if (batchId && !batchesWithFirstResultLoggedRef.current.has(batchId)) {
+            batchesWithFirstResultLoggedRef.current.add(batchId);
+            emitBatchPhaseEvent("first-result", { batchId: batchId });
+        }
+        var shouldEmitStats = false;
+        if (result.key && activeWorkerKeysRef.current.has(result.key)) {
+            activeWorkerKeysRef.current.delete(result.key);
+            shouldEmitStats = true;
+        }
+        if (result.staticReferenceId) {
+            var node = graph.getNodes().get(result.staticReferenceId);
+            if (isStaticNode(node)) {
+                queueStaticNotification(node);
+            }
+            if (shouldEmitStats) {
+                emitStats();
+            }
+            return;
+        }
+        if (!result.position) {
+            if (shouldEmitStats) {
+                emitStats();
+            }
+            return;
+        }
+        completedCountRef.current += 1;
+        shouldEmitStats = true;
+        var enrichedPosition = result.position;
+        if (Array.isArray(result.value)) {
+            // Spilled arrays require special handling: persist matrix values and
+            // dirty downstream dependents tied to the old spill footprint.
+            handleArrayEvaluation(enrichedPosition, result.value);
+            emitStats();
+            return;
+        }
+        clearArrayValues(enrichedPosition, {
+            notifyDependents: true,
+            forgetRange: true,
+        });
+        queueCellValue(enrichedPosition, deserializeResultValue(result.value));
+        markAnchorProcessed(enrichedPosition);
+        if (shouldEmitStats) {
+            emitStats();
+        }
+    }, [
+        clearArrayValues,
+        deserializeResultValue,
+        graph,
+        handleArrayEvaluation,
+        queueCellValue,
+        queueStaticNotification,
+        emitBatchPhaseEvent,
+        markAnchorProcessed,
+        emitStats,
+    ]);
+    var processOperations = useCallback(function () { return __awaiter(void 0, void 0, void 0, function () {
+        var hasValueAffectingNonVolatileOps, _loop_1;
+        return __generator(this, function (_a) {
+            // This is the main scheduler loop: drain the pending queue, build plans,
+            // and stream results back while accounting for volatile + array mechanics.
+            if (processingRef.current)
+                return [2 /*return*/];
+            processingRef.current = true;
+            try {
+                flushVolatileTracking();
+                hasValueAffectingNonVolatileOps = pendingOperationQueueRef.current.some(function (key) { return !volatileCellsRef.current.has(key); });
+                if (hasValueAffectingNonVolatileOps) {
+                    enqueueVolatileCells();
+                }
+                _loop_1 = function () {
+                    var e_9, _b;
+                    var keys = pendingOperationQueueRef.current.splice(0);
+                    var operations = [];
+                    try {
+                        for (var keys_1 = (e_9 = void 0, __values(keys)), keys_1_1 = keys_1.next(); !keys_1_1.done; keys_1_1 = keys_1.next()) {
+                            var key = keys_1_1.value;
+                            var operation = pendingOperationMapRef.current.get(key);
+                            if (operation) {
+                                operations.push(operation);
+                                pendingOperationMapRef.current.delete(key);
+                            }
+                        }
+                    }
+                    catch (e_9_1) { e_9 = { error: e_9_1 }; }
+                    finally {
+                        try {
+                            if (keys_1_1 && !keys_1_1.done && (_b = keys_1.return)) _b.call(keys_1);
+                        }
+                        finally { if (e_9) throw e_9.error; }
+                    }
+                    emitStats();
+                    if (!operations.length) {
+                        return "continue";
+                    }
+                    operations.sort(function (a, b) {
+                        var order = function (type) {
+                            if (type === "remove")
+                                return 0;
+                            if (type === "add")
+                                return 1;
+                            return 2;
+                        };
+                        return order(a.type) - order(b.type);
+                    });
+                    var evaluationOperations = operations;
+                    if (!evaluationOperations.length) {
+                        return "continue";
+                    }
+                    activeExecutionsRef.current++;
+                    var currentBatchId = null;
+                    var enqueueStartTime = getTimestamp();
+                    var forcedPositions = evaluationOperations
+                        .filter(function (operation) {
+                        return "position" in operation &&
+                            Boolean(operation.force) &&
+                            isCellCoordinate(operation.position);
+                    })
+                        .map(function (operation) { return operation.position; });
+                    var onPlanBuiltWrapper = function (plan) {
+                        currentBatchId = plan.id;
+                        handlePlanBuilt(plan, enqueueStartTime);
+                    };
+                    var onWorkerBatchWrapper = function (event) {
+                        if (currentBatchId) {
+                            handleWorkerBatchEvent(event, currentBatchId);
+                        }
+                    };
+                    var onResultWrapper = function (result) {
+                        handleResult(result, currentBatchId !== null && currentBatchId !== void 0 ? currentBatchId : undefined);
+                    };
+                    var enqueuePromise = enqueueCalculationOperations({
+                        graph: graph,
+                        workerClient: workerClient,
+                        operations: evaluationOperations,
+                        resolveFormula: resolveFormulaForOperation,
+                        onResult: onResultWrapper,
+                        onPlan: preparePlanForExecution,
+                        onPlanBuilt: onPlanBuiltWrapper,
+                        onWorkerBatch: onWorkerBatchWrapper,
+                        onNodeBegin: handleNodeBegin,
+                        normalizePropertyOverride: normalizePropertyOverride,
+                        planOptions: enableLazyCalculation && typeof activeSheetId === "number"
+                            ? {
+                                rootSheetId: activeSheetId,
+                                onDeferredNodes: deferCalculationNodes,
+                                includePositions: forcedPositions.length
+                                    ? forcedPositions
+                                    : undefined,
+                            }
+                            : undefined,
+                    });
+                    // Fire and forget (tracked by activeExecutionsRef)
+                    enqueuePromise
+                        .then(function () {
+                        if (currentBatchId) {
+                            emitBatchPhaseEvent("worker-complete", {
+                                batchId: currentBatchId,
+                            });
+                            emitBatchPhaseEvent("complete", { batchId: currentBatchId });
+                        }
+                    })
+                        .catch(function (error) {
+                        console.error("Calculation error: ", error);
+                    })
+                        .finally(function () {
+                        activeExecutionsRef.current--;
+                        if (activeExecutionsRef.current === 0) {
+                            onAfterCalculation();
+                            pendingArrayDirtyAnchorsRef.current.clear();
+                            activeWorkerKeysRef.current.clear();
+                            emitStats();
+                        }
+                    });
+                };
+                while (pendingOperationQueueRef.current.length) {
+                    _loop_1();
+                }
+            }
+            finally {
+                processingRef.current = false;
+                if (pendingOperationQueueRef.current.length) {
+                    scheduleProcessingRef.current();
+                }
+            }
+            return [2 /*return*/];
+        });
+    }); }, [
+        activeSheetId,
+        enableLazyCalculation,
+        graph,
+        workerClient,
+        resolveFormulaForOperation,
+        handleResult,
+        preparePlanForExecution,
+        handlePlanBuilt,
+        handleWorkerBatchEvent,
+        emitBatchPhaseEvent,
+        emitStats,
+        handleNodeBegin,
+        normalizePropertyOverride,
+        deferCalculationNodes,
+        flushVolatileTracking,
+        enqueueVolatileCells,
+        onAfterCalculation,
+    ]);
+    var scheduleProcessing = useCallback(function () {
+        if (!workerReadyRef.current) {
+            return;
+        }
+        if (processFrameRef.current !== null) {
+            return;
+        }
+        var schedule = function (cb) {
+            if (coalesceDelayMs > 0) {
+                return setTimeout(function () { return scheduleAfterPaint(cb); }, coalesceDelayMs);
+            }
+            scheduleAfterPaint(cb);
+            return 0;
+        };
+        processFrameRef.current = schedule(function () {
+            processFrameRef.current = null;
+            processOperations();
+        });
+    }, [coalesceDelayMs, processOperations]);
+    scheduleProcessingRef.current = scheduleProcessing;
+    var enqueuePendingOperation = useCallback(function (operation) {
+        if (pushPendingOperation(operation)) {
+            emitStats();
+            scheduleProcessing();
+        }
+    }, [emitStats, pushPendingOperation, scheduleProcessing]);
+    useEffect(function () {
+        enqueuePendingOperationRef.current = enqueuePendingOperation;
+    }, [enqueuePendingOperation]);
+    // Deferred activesheetid callbacks
+    useDeferredCalculationFlush({
+        activeSheetId: enableLazyCalculation && typeof activeSheetId === "number"
+            ? activeSheetId
+            : undefined,
+        deferredOperationsBySheetRef: deferredOperationsBySheetRef,
+        enqueueOperation: enqueuePendingOperation,
+        onFlushComplete: emitStats,
+    });
+    // Initialize
+    var workerInitSnapshotRef = useRef(undefined);
+    useEffect(function () {
+        if (!enabled || workerClient === workerClientStub) {
+            return;
+        }
+        var nextSnapshot = { sheets: sheets, locale: locale, tables: tables, namedRanges: namedRanges };
+        var prevSnapshot = workerInitSnapshotRef.current;
+        if (prevSnapshot &&
+            prevSnapshot.locale === nextSnapshot.locale &&
+            prevSnapshot.tables === nextSnapshot.tables &&
+            prevSnapshot.namedRanges === nextSnapshot.namedRanges &&
+            prevSnapshot.sheets === nextSnapshot.sheets) {
+            return;
+        }
+        workerInitSnapshotRef.current = nextSnapshot;
+        var cancelled = false;
+        workerReadyRef.current = false;
+        (function () { return __awaiter(void 0, void 0, void 0, function () {
+            var initialization, error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        initialization = workerErrorPromiseRef.current
+                            ? Promise.race([
+                                workerClient.initialize(nextSnapshot),
+                                workerErrorPromiseRef.current,
+                            ])
+                            : workerClient.initialize(nextSnapshot);
+                        return [4 /*yield*/, initialization];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        error_1 = _a.sent();
+                        console.error("Failed to initialize calculation worker", error_1);
+                        return [2 /*return*/];
+                    case 3:
+                        if (cancelled) {
+                            return [2 /*return*/];
+                        }
+                        workerReadyRef.current = true;
+                        scheduleProcessing();
+                        return [2 /*return*/];
+                }
+            });
+        }); })();
+        return function () {
+            cancelled = true;
+            workerReadyRef.current = false;
+        };
+    }, [
+        enabled,
+        workerClient,
+        workerClientStub,
+        sheets,
+        locale,
+        tables,
+        namedRanges,
+        scheduleProcessing,
+    ]);
+    useEffect(function () {
+        if (workerClient === workerClientStub) {
+            return;
+        }
+        return function () {
+            var _a;
+            (_a = workerErrorCleanupRef.current) === null || _a === void 0 ? void 0 : _a.call(workerErrorCleanupRef);
+            workerClient.dispose();
+        };
+    }, [workerClient, workerClientStub]);
+    useEffect(function () {
+        return function () {
+            if (resultFrameRef.current != null) {
+                cancelAnimationFrame(resultFrameRef.current);
+            }
+        };
+    }, []);
+    var prepareArrayOperation = useCallback(function (operation) {
+        var e_10, _a;
+        var _b, _c, _d;
+        if (operation.type === "dirty") {
+            return;
+        }
+        var anchor = (_b = graph.getArrayParent(operation.position)) !== null && _b !== void 0 ? _b : findCachedArrayAnchor(operation.position);
+        if (!anchor) {
+            return;
+        }
+        var anchorKey = makeKey(anchor);
+        var clearedRange = operation.type === "remove" &&
+            isEqualPosition(anchor, operation.position)
+            ? (_c = graph.getArrayRangeFor(anchor)) !== null && _c !== void 0 ? _c : (_d = arrayRangeCacheRef.current.get(anchorKey)) === null || _d === void 0 ? void 0 : _d.range
+            : undefined;
+        var isAnchorTarget = isEqualPosition(anchor, operation.position);
+        var preserve = new Set();
+        if (!isAnchorTarget) {
+            preserve.add(makeKey(operation.position));
+        }
+        var shouldNotifyDependents = !!isAnchorTarget;
+        clearArrayValues(anchor, {
+            preserveKeys: preserve,
+            includeAnchor: operation.type === "remove" && isAnchorTarget,
+            notifyDependents: shouldNotifyDependents,
+            forgetRange: operation.type === "remove" && isAnchorTarget,
+            preserveUserEntries: !isAnchorTarget,
+            preserveComputedValues: !isAnchorTarget && operation.type !== "remove",
+            deferDependents: !shouldNotifyDependents,
+            preserveRegistration: !isAnchorTarget,
+        });
+        if (clearedRange) {
+            try {
+                for (var _e = __values(arrayRangeCacheRef.current.values()), _f = _e.next(); !_f.done; _f = _e.next()) {
+                    var entry = _f.value;
+                    if (!rangesOverlap(entry.range, clearedRange)) {
+                        continue;
+                    }
+                    var key = makeKey(entry.anchor);
+                    if (key === anchorKey) {
+                        continue;
+                    }
+                    collisionAnchorsRef.current.delete(key);
+                    queueAnchorDirty(entry.anchor);
+                }
+            }
+            catch (e_10_1) { e_10 = { error: e_10_1 }; }
+            finally {
+                try {
+                    if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
+                }
+                finally { if (e_10) throw e_10.error; }
+            }
+        }
+    }, [clearArrayValues, findCachedArrayAnchor, graph, queueAnchorDirty]);
+    var enqueueCalculation = useCallbackRef(function (operation) {
+        var _a;
+        if (operation.type !== "dirty") {
+            var anchor = (_a = graph.getArrayParent(operation.position)) !== null && _a !== void 0 ? _a : findCachedArrayAnchor(operation.position);
+            if (anchor) {
+                collisionAnchorsRef.current.delete(makeKey(anchor));
+            }
+        }
+        scheduleVolatileTracking(operation.position);
+        prepareArrayOperation(operation);
+        enqueuePendingOperation(operation);
+    });
+    var enqueueGraphOperation = useCallbackRef(function (operation) {
+        graphOperationQueueRef.current.push(operation);
+        if (graphOperationFrameRef.current == null) {
+            graphOperationFrameRef.current =
+                requestAnimationFrame(flushGraphOperations);
+        }
+    });
+    var isArrayFormula = useCallbackRef(function (position) {
+        return graph.isArrayFormula(position) || graph.isInArrayRange(position);
+    });
+    var getPrecedents = useCallback(function (source, includeSource) {
+        return graph.getPrecedents(source).filter(function (node) {
+            if (isStaticNode(node))
+                return true;
+            if (!includeSource && isCellNode(node) && isCellCoordinate(source)) {
+                return !isEqualPosition(node.position, source);
+            }
+            if (!includeSource &&
+                isCellRangeNode(node) &&
+                !isCellCoordinate(source)) {
+                return !isAreasEqual(node.position, source);
+            }
+            return true;
+        });
+    }, [graph]);
+    var getPrecedentsFromFormulaString = useCallback(function (value, source) {
+        var dependencies = graph.getDependenciesFromFormula(value, source);
+        return dependencies.map(function (dependency) {
+            if (dependency.kind === "cell") {
+                return new CellNode(makeKey(dependency.position), dependency.position);
+            }
+            return new CellRangeNode(makeKey(dependency.range), dependency.range);
+        });
+    }, [graph]);
+    var getDependents = useCallback(function (source, includeSource) {
+        return graph.getDependents(source).filter(function (node) {
+            if (isStaticNode(node)) {
+                return true;
+            }
+            if ((isCellNode(node) || isCellRangeNode(node)) &&
+                node.position &&
+                isCellCoordinate(node.position) &&
+                isArrayFormula(node.position)) {
+                return true;
+            }
+            if (includeSource &&
+                isCellRangeNode(node) &&
+                !isCellCoordinate(source)) {
+                return !isAreasEqual(node.position, source);
+            }
+            if (!includeSource && isCellCoordinate(source) && isCellNode(node)) {
+                var cellNode = node;
+                return (cellNode.position.rowIndex !== source.rowIndex ||
+                    cellNode.position.columnIndex !== source.columnIndex);
+            }
+            return true;
+        });
+    }, [graph, isArrayFormula]);
+    var deleteSheetReferences = useCallback(function (sheetId) {
+        graph.deleteSheetReferences(sheetId);
+    }, [graph]);
+    var onRequestCalculate = useCallback(function (value, sheetId, rowIndex, columnIndex, options) { return __awaiter(void 0, void 0, void 0, function () {
+        var disablePreview, skipOnDemand, formula, position, dependencies, isCircular, scope, _a, _b, _c, key, value_1, plan, _d, result, resultValue;
+        var e_11, _e;
+        var _f, _g, _h;
+        return __generator(this, function (_j) {
+            switch (_j.label) {
+                case 0:
+                    disablePreview = (_f = options === null || options === void 0 ? void 0 : options.disablePreview) !== null && _f !== void 0 ? _f : false;
+                    if (!enabled || workerClient === workerClientStub) {
+                        return [2 /*return*/, undefined];
+                    }
+                    skipOnDemand = (_g = options === null || options === void 0 ? void 0 : options.skipOnDemand) !== null && _g !== void 0 ? _g : 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];
+                    }
+                    if (!isAFormula(value)) {
+                        return [2 /*return*/, null];
+                    }
+                    formula = value.startsWith("=") ? value.slice(1) : value;
+                    if (!formula) {
+                        return [2 /*return*/, null];
+                    }
+                    position = { sheetId: sheetId, rowIndex: rowIndex, columnIndex: columnIndex };
+                    dependencies = graph.getDependenciesFromFormula(formula, position);
+                    if ((iterativeCalculation === null || iterativeCalculation === void 0 ? void 0 : iterativeCalculation.enabled) && !disablePreview) {
+                        isCircular = dependencies.some(function (dependency) {
+                            if (dependency.kind === "cell") {
+                                return (dependency.position.sheetId === sheetId &&
+                                    dependency.position.rowIndex === rowIndex &&
+                                    dependency.position.columnIndex === columnIndex);
+                            }
+                            var range = dependency.range;
+                            return (range.sheetId === sheetId &&
+                                rowIndex >= range.startRowIndex &&
+                                rowIndex <= range.endRowIndex &&
+                                columnIndex >= range.startColumnIndex &&
+                                columnIndex <= range.endColumnIndex);
+                        });
+                        if (isCircular) {
+                            return [2 /*return*/, undefined];
+                        }
+                    }
+                    scope = graph.collectScope(dependencies);
+                    if ((_h = options === null || options === void 0 ? void 0 : options.overrides) === null || _h === void 0 ? void 0 : _h.size) {
+                        try {
+                            for (_a = __values(options.overrides), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                _c = __read(_b.value, 2), key = _c[0], value_1 = _c[1];
+                                scope[key] = value_1;
+                            }
+                        }
+                        catch (e_11_1) { e_11 = { error: e_11_1 }; }
+                        finally {
+                            try {
+                                if (_b && !_b.done && (_e = _a.return)) _e.call(_a);
+                            }
+                            finally { if (e_11) throw e_11.error; }
+                        }
+                    }
+                    plan = {
+                        id: "preview-".concat(Date.now()),
+                        nodes: [
+                            {
+                                kind: "cell",
+                                key: "preview-node-".concat(Date.now()),
+                                position: position,
+                                formula: formula,
+                                precedents: dependencies,
+                                isPreview: !disablePreview,
+                            },
+                        ],
+                    };
+                    return [4 /*yield*/, workerClient.evaluate(plan, function () { return scope; })];
+                case 1:
+                    _d = __read.apply(void 0, [_j.sent(), 1]), result = _d[0];
+                    resultValue = deserializeResultValue(result.value);
+                    if (resultValue instanceof FormulaError) {
+                        return [2 /*return*/, undefined];
+                    }
+                    return [2 /*return*/, resultValue];
+            }
+        });
+    }); }, [
+        enabled,
+        graph,
+        workerClient,
+        workerClientStub,
+        deserializeResultValue,
+        iterativeCalculation,
+    ]);
+    var getGraphNodes = useCallback(function () {
+        return graph.getNodes();
+    }, [graph]);
+    var getGraphNodesInSheet = useCallback(function (sheetId) { return graph.getNodesInSheet(sheetId); }, [graph]);
+    var addStaticReference = useCallback(function (source, sourcePosition) {
+        graph.applyOperations([
+            {
+                kind: "static:add",
+                reference: source,
+                range: toCellRange(sourcePosition),
+            },
+        ]);
+    }, [graph]);
+    var addFormulaToGraph = useCallbackRef(useCallback(function (formulaValue, position) {
+        if (!formulaValue) {
+            return;
+        }
+        var formula = formulaValue.startsWith("=")
+            ? formulaValue
+            : "=".concat(formulaValue);
+        graph.applyOperations([{ kind: "upsert", position: position, formula: formula }]);
+    }, [graph]));
+    var removeStaticReference = useCallback(function (source) {
+        graph.applyOperations([
+            {
+                kind: "static:remove",
+                reference: source,
+            },
+        ]);
+    }, [graph]);
+    var onResetCalculator = useCallbackRef(function () {
+        isFullRecalcRef.current = true;
+        graph.reset();
+        computedValuesRef.current.clear();
+    });
+    var getDependencyGraph = useCallbackRef(function () { return graph.serialize(); });
+    var updateDependencyGraph = useCallbackRef(function (nodes) {
+        return graph.hydrate(nodes);
+    });
+    var enqueueStructureChange = useCallbackRef(function (_change) { });
+    var clearRangeCache = useCallbackRef(function () { });
+    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 Set(); },
+            getGraphNodesInSheet: function () { return undefined; },
+            addStaticReference: function () { },
+            addFormulaToGraph: function () { },
+            removeStaticReference: function () { },
+            onResetCalculator: function () { },
+            getDependencyGraph: function () { return "[]"; },
+            updateDependencyGraph: function () { },
+            isArrayFormula: function () { return false; },
+            applyNamedRanges: function (_list) { },
+            stats$: statsSubjectRef.current.asObservable(),
+        });
+    }, []);
+    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,
+        // Worker re-inits on namedRanges change (sent via WorkerInit
+        // payload), so there's no host-side calculator to apply to.
+        // No-op to satisfy the shared API contract.
+        applyNamedRanges: function (_list) { },
+        stats$: statsSubjectRef.current.asObservable(),
+    };
+    return (enabled
+        ? api
+        : noopCalculationApi);
+};