@sheetxl/sdk 0.8.0-beta.11 → 0.8.0-beta.12

package/types/src/calculation/grid/CalcGridBackend.d.ts

@@ -20,7 +20,7 @@ export declare class CalcGridBackend extends CalcGridProxy implements ICalcGrid.
     _values: ISparseGrid<Scalar>;
     _spillSpatial: ISpatialMap<SpillEntry>;
     _errorSpatial: ISpatialMap<string>;
-    _pendingSpatial: ISpatialMap<boolean>;
+    _calcStatusSpatial: ISpatialMap<ICalcGrid.CalcStatus>;
     _circularSpatial: ISpatialMap<CircularEntry>;
     _contentfulSpatial: ISpatialMap<ContentfulSpatialValue>;
     _notifyValues: ISpatialMap;
@@ -29,7 +29,7 @@ export declare class CalcGridBackend extends CalcGridProxy implements ICalcGrid.
     _notifySpillsInsert: ISpatialMap.Entry<SpillEntry>[];
     _notifySpillsRemove: IRange.Coords[];
     _notifyFormats: ISpatialMap;
-    _notifyPending: ISpatialMap<boolean>;
+    _notifyCalcStatus: ISpatialMap<ICalcGrid.CalcStatus | false>;
     _notifyCircular: ISpatialMap<CircularEntry | false>;
     /**
      * Regions of this grid whose formula blocks were minted, re-imaged or removed since the last
@@ -77,7 +77,7 @@ export declare class CalcGridBackend extends CalcGridProxy implements ICalcGrid.
     protected _snapshots: Map<string, CalcGridSnapshot> | null;
     /**
      * The owner's callback for a record the engine pushed - a pass's results, a seed's. The one
-     * place the response half of the boundary is crossed on the way out (plan step 6); every site
+     * place the response half of the boundary is crossed on the way out (DESIGN-CALC-SERVICE §11); every site
      * that pushes calls this rather than `_options.onCalculated`.
      */
     protected _onCalculated: (response: CalcResponse) => void;
@@ -307,29 +307,6 @@ export declare class CalcGridBackend extends CalcGridProxy implements ICalcGrid.
      * inspected; a name mentioned upstream is that cell's precedent. Engine primitive.
      */
     getNamedReferencesAt(coords: IRange.Coords): string[];
-    /**
-     * What a `graph` request asking about this grid's defined name answers: the name's precedents
-     * or dependents, cells scoped by grid and names as nodes - ONE answer, as a cell's is.
-     *
-     * @remarks
-     * The PRECEDENTS: the cell half is the ordinary precedent graph - a body is a real formula here,
-     * and its references registered precedent ranges like any cell's. The name half is the body's
-     * `getNamedIds`: apply-at-eval means a name the body reads has no precedent edge, so the symbol
-     * list is the only carrier - one hop for `direct`, the downward closure (cycle-guarded) for the
-     * deep form, each member contributing its own grid's cell walk. The deep form does not take the
-     * symbol hop from UPSTREAM CELLS (`X = A1*2`, `A1 = SomeName`: `A1` is listed and `SomeName`'s
-     * inputs are not) - that hop is `A1`'s, one step of a tree walk.
-     *
-     * The DEPENDENTS: two graphs meet, and the walk changes vehicles between them. The symbol edge -
-     * which formulas mention this name - is not in the precedent spatial at all; it is the nameId
-     * list each compiled block carries (`container.getNamedDependents`). The cell edge is the
-     * precedent graph, which carries everything downstream of those blocks: `direct` is one hop of
-     * the first; the deep form takes it, then hands each landing block to its grid. A block on a
-     * grid that is no sheet is another NAME reading this one: a node, and the deep walk passes
-     * THROUGH it on the symbol closure (`getNamedDependentNames`), or `Base`'s dependents would stop
-     * at `Plus1`. This name is listed only when a true cycle leads back to it.
-     */
-    protected _nameGraphNow(kind: 'precedents' | 'dependents', direct: boolean): ICalcGrid.GraphNeighbors;
     /** The blank region of the body this grid holds, as data: see {@link ICalcGrid.Results.blankRegion}. */
     protected _blankRegion(): ICalcGrid.BlankRegion | null;
     /** The compiled block at a cell, or `null`. Engine-side: the model reads the vended view. */
@@ -338,6 +315,7 @@ export declare class CalcGridBackend extends CalcGridProxy implements ICalcGrid.
     getReferencesAt(row: number, column: number): ReferenceCoords[];
     /** What an `evaluate` request answers: the formula at the cell, evaluated now; `null` where there is none. */
     protected _evaluateNow(row: number, column: number, evalIndex?: number, coerce?: 'scalar'): Scalar | IRange | Promise<Scalar | IRange> | null;
+    protected _evaluateBlockNow(block: IFormulaBlock, row: number, column: number, evalIndex?: number, coerce?: 'scalar'): Scalar | IRange | Promise<Scalar | IRange> | null;
     /** What a `setReference` request does: the rewrite, and the write of the formula it makes. */
     protected _setReferenceNow(row: number, column: number, index: number, precedent: IRange.FixableCoords | IRange.FixableCellCoords | NamedReference | FormulaError.Ref): CalcResponse;
     /** What a `setReferenceMode` request does: refused for a reference that is not to cells. */
@@ -497,7 +475,7 @@ export interface CalcGridMaps {
     contentful: ISpatialMap<ContentfulSpatialValue>;
     spills: ISpatialMap<SpillEntry>;
     errors: ISpatialMap<string>;
-    pending: ISpatialMap<boolean>;
+    calcStatus: ISpatialMap<ICalcGrid.CalcStatus>;
     circular: ISpatialMap<CircularEntry>;
     /** The size a `resize` gave, or `null` for the one the grid was made with. */
     entireCoords?: IRange.Coords | null;

package/types/src/calculation/grid/CalcGridProxy.d.ts

@@ -96,8 +96,6 @@ export declare class CalcGridProxy implements ICalcGrid.Backend {
      * A question: an engine that holds no grid (`Off`) answers with nothing.
      */
     getGraphNeighborsAt(coords: IRange.Coords, kind: 'precedents' | 'dependents', direct: boolean): Promise<ICalcGrid.GraphNeighbors>;
-    /** {@inheritDoc ICalcGrid.Backend.getNameGraph} */
-    getNameGraph(kind: 'precedents' | 'dependents', direct: boolean): Promise<ICalcGrid.GraphNeighbors>;
     /**
      * {@inheritDoc ICalcGrid.isVolatileAt}
      *

package/types/src/calculation/grid/CalcGridUtils.d.ts

@@ -1,6 +1,7 @@
 import { IRange, Scalar } from '@sheetxl/primitives';
 import { Tuple, ISparseGrid, ISpatialMap, ISpatialMap3D } from '../../collections';
 import { CalcNode } from '../state';
+import { ICalcGrid } from './ICalcGrid';
 import { ContentfulSpatialValue, FormulaSpatialValue, SpillEntry, PrecedentSpatialValue, CircularEntry, PrecedentKind } from '../spatial';
 import { ReferenceCoords } from '../Types';
 export declare function anchorCompareValues(a: ISpatialMap.Entry<FormulaSpatialValue>, removing: ISpatialMap.Entry<FormulaSpatialValue>): boolean;
@@ -58,9 +59,10 @@ export declare function clearErrorIndex(errorSpatial: ISpatialMap<string>, coord
  * @remarks
  * This code will inline spill errors but spill results are handled in calculations.
  */
-export declare function applyContentful(cycleId: number, removes: readonly IRange.Coords[] | null | undefined, inserts: ISpatialMap.Entry[] | null | undefined, contentfulSpatial: ISpatialMap<ContentfulSpatialValue>, spillSpatial: ISpatialMap<SpillEntry>, values: ISparseGrid<Scalar>, addDirty?: (colStart: number, rowStart: number, colEnd: number, rowEnd: number) => void, notifyValuesSpatial?: ISpatialMap, notifySpills?: (insert: ISpatialMap.Entry<SpillEntry>, remove: ISpatialMap.Entry<SpillEntry>) => void, notifyPending?: ISpatialMap<boolean>, errorSpatial?: ISpatialMap<string>, // notifyErrorSpatial,
+export declare function applyContentful(cycleId: number, removes: readonly IRange.Coords[] | null | undefined, inserts: ISpatialMap.Entry[] | null | undefined, contentfulSpatial: ISpatialMap<ContentfulSpatialValue>, spillSpatial: ISpatialMap<SpillEntry>, values: ISparseGrid<Scalar>, addDirty?: (colStart: number, rowStart: number, colEnd: number, rowEnd: number) => void, notifyValuesSpatial?: ISpatialMap, notifySpills?: (insert: ISpatialMap.Entry<SpillEntry>, remove: ISpatialMap.Entry<SpillEntry>) => void, notifyCalcStatus?: ISpatialMap<ICalcGrid.CalcStatus | false>, errorSpatial?: ISpatialMap<string>, // notifyErrorSpatial,
 isColumn?: boolean, notifyCalc?: boolean, // should notify. this is to differentiate between user set values and calc set values
-circularSpatial?: ISpatialMap<CircularEntry>): IRange.Coords | null;
+circularSpatial?: ISpatialMap<CircularEntry>, // the circular index: a written cell leaves it, like errorSpatial
+calcStatusSpatial?: ISpatialMap<ICalcGrid.CalcStatus>): IRange.Coords | null;
 /**
  * Creates a map from tuples
  *

package/types/src/calculation/grid/ICalcGrid.d.ts

@@ -116,7 +116,7 @@ export interface ICalcGrid {
      * @param transaction Read the record as this transaction sees it, its held writes not yet
      * made; the current record when omitted.
      */
-    getPending(transaction?: ITransaction | null): ISpatialMap<boolean>;
+    getCalcStatus(transaction?: ITransaction | null): ISpatialMap<ICalcGrid.CalcStatus>;
     /**
      * Engine FAILURES by cell (a formula that could not be evaluated), as a message. Not error
      * VALUES - those are {@link getErrorValues}.
@@ -410,7 +410,7 @@ export declare namespace ICalcGrid {
      * the engine answers, and nothing the model holds for itself. The in-process engine grid is
      * one; a message-passing proxy under a worker is another.
      */
-    type Backend = Omit<ICalcGrid, 'getStateId' | 'getEntireCoords' | 'getFormulaAt' | 'getFormulas' | 'getValues' | 'getContentful' | 'getSpills' | 'getPending' | 'getCalcErrors' | 'getCirculars' | 'getErrorValues' | 'getValuesEpoch' | 'getVolatileRegions' | 'getRangeStats'> & {
+    type Backend = Omit<ICalcGrid, 'getStateId' | 'getEntireCoords' | 'getFormulaAt' | 'getFormulas' | 'getValues' | 'getContentful' | 'getSpills' | 'getCalcStatus' | 'getCalcErrors' | 'getCirculars' | 'getErrorValues' | 'getValuesEpoch' | 'getVolatileRegions' | 'getRangeStats'> & {
         /** Write a body as authored; the engine anchors it (see {@link ICalcGrid.BodyOptions}). */
         setBody(options: ICalcGrid.BodyOptions): Promise<ICalcGrid.Results>;
         /** {@link ICalcGrid.evaluateAt} coerced to one scalar, as a defined name's `evaluate()` is. */
@@ -422,12 +422,6 @@ export declare namespace ICalcGrid {
          * last set; see `CalcGridBackend.getDemanded`. Evaluated by the next pass.
          */
         demand(rects: readonly IRange.Coords[]): void;
-        /**
-         * The graph around the defined name whose body this grid holds - its precedents or
-         * dependents, cells in calc currency and names - as {@link ICalcGrid.getGraphNeighborsAt}
-         * answers for cells.
-         */
-        getNameGraph(kind: 'precedents' | 'dependents', direct: boolean): Promise<ICalcGrid.GraphNeighbors>;
     };
     /**
      * A body written as it was authored, for a grid that holds one (a name's, a watch's): the engine
@@ -556,7 +550,7 @@ export declare namespace ICalcGrid {
          * @remarks
          * These are guaranteed to not overlap.
          */
-        pendingUpdates?: ISpatialMap.Entry<boolean>[];
+        calcStatusUpdates?: ISpatialMap.Entry<ICalcGrid.CalcStatus | false>[];
         /**
          * Cells that entered or left a reference cycle (or the set downstream of one). A `null`
          * value is a removal.
@@ -609,6 +603,16 @@ export declare namespace ICalcGrid {
         /** For a paged region, the tiles this pass evaluated. */
         readonly evaluated?: readonly IRange.Coords[];
     }
+    /**
+     * Why a cell is in the calc-status index: its own function asked for a result that has not
+     * arrived (`Working`), or it was calculated from such a value and is calculated again when it
+     * arrives (`Waiting`). A removal travels as `false` in a delta.
+     */
+    const CalcStatus: {
+        readonly Working: 1;
+        readonly Waiting: 2;
+    };
+    type CalcStatus = typeof CalcStatus[keyof typeof CalcStatus];
     /**
      * Returns from `ICalcGrid.beginUpdates()`.
      *
@@ -620,7 +624,7 @@ export declare namespace ICalcGrid {
         values: ISparseGrid<Scalar>;
         spillSpatial: ISpatialMap<SpillEntry>;
         errorSpatial: ISpatialMap<string>;
-        pendingSpatial: ISpatialMap<boolean>;
+        calcStatusSpatial: ISpatialMap<ICalcGrid.CalcStatus>;
         circularSpatial: ISpatialMap<CircularEntry>;
         contentfulSpatial: ISpatialMap<ContentfulSpatialValue>;
         notifyValues: ISpatialMap;
@@ -639,9 +643,9 @@ export declare namespace ICalcGrid {
         notifySpillsInsert: ISpatialMap.Entry<SpillEntry>[];
         notifySpillsRemove: IRange.Coords[];
         notifyFormats: ISpatialMap;
-        notifyPending: ISpatialMap<boolean>;
+        notifyCalcStatus: ISpatialMap<ICalcGrid.CalcStatus | false>;
         notifyCircular: ISpatialMap<CircularEntry | false>;
-        pendingConflating: ISpatialMap.IConflatingEntries<boolean> | null;
+        calcStatusConflating: ISpatialMap.IConflatingEntries<ICalcGrid.CalcStatus | false> | null;
         circularConflating: ISpatialMap.IConflatingEntries<CircularEntry | false> | null;
         errorRemovesConflating: ISpatialMap.IConflatingEntries<null> | null;
         errorInsertsConflating: ISpatialMap.IConflatingEntries<string> | null;

package/types/src/calculation/grid/_CalcRequest.d.ts

@@ -13,7 +13,7 @@ import { ICalcGrid } from './ICalcGrid';
  * @remarks
  * Not part of {@link ICalcGrid}: a caller sees the verbs and their promises. This is what the
  * in-process channel holds in place of a worker port's queue, and what the clone boundary audits
- * (plan step 6): a held call carries what the verb's arguments carry, which is what a proxy
+ * (DESIGN-CALC-SERVICE §11): a held call carries what the verb's arguments carry, which is what a proxy
  * would post.
  *
  * @internal Deliberately not exported from the barrel.
@@ -166,15 +166,13 @@ export type CalcRequest =
 }
 /**
  * The graph around cells of this grid, answered in the response (`ICalcGrid.GraphNeighbors`,
- * cells in calc currency). A question. `asName` walks the defined name this grid holds the body
- * of instead: its own precedents or dependents, cells and names.
+ * cells in calc currency). A question.
  */
  | {
     type: 'graph';
     kind: 'precedents' | 'dependents';
     direct: boolean;
-    coords?: IRange.Coords;
-    asName?: boolean;
+    coords: IRange.Coords;
 }
 /** Whether the formula at a cell is volatile, answered in the response. A question. */
  | {
@@ -215,6 +213,18 @@ export type CalcRequest =
     changes: readonly (readonly [id: string, name: NameSymbols | null])[];
     options?: ICalcGrid.RequestOptions;
 }
+/**
+ * The graph around a defined name - its precedents or dependents, cells in calc currency and
+ * names - answered in the response (`ICalcGrid.GraphNeighbors`). A question of the service, not
+ * of the name's grid: its readers are found by its id, so a name that has not compiled is asked
+ * without making it a grid.
+ */
+ | {
+    type: 'nameGraph';
+    nameId: string;
+    kind: 'precedents' | 'dependents';
+    direct: boolean;
+}
 /**
  * A nested savepoint of the model rolled back inside an operation that goes on: what the requests
  * made under it did goes with it. After them in the channel, so it undoes exactly those.
@@ -287,6 +297,8 @@ export type GridRequest = Exclude<CalcRequest, {
     type: 'tables';
 } | {
     type: 'names';
+} | {
+    type: 'nameGraph';
 } | {
     type: 'rollback';
 } | {

package/types/src/calculation/spatial/FormulaSpatialValue.d.ts

@@ -428,6 +428,8 @@ export declare class FormulaSpatialValue implements IFormulaBlock, ISpatialMap.I
     getReferencedSymbolIds(): string[];
     /** {@inheritDoc IFormulaBlock.hasTotals} */
     hasTotals(): boolean;
+    /** {@inheritDoc IFormulaBlock.hasDataTable} */
+    hasDataTable(): boolean;
     /** {@inheritDoc IFormulaBlock.hasVolatile} */
     hasVolatile(): boolean;
     /** {@inheritDoc IFormulaBlock.isBlankCacheable} */

package/types/src/calculation/spatial/SpillEntry.d.ts

@@ -1,6 +1,7 @@
 import { IRange } from '@sheetxl/primitives';
 import { ITypes } from '../../type';
-import { ISpatialMap } from '../../collections';
+import { ISpatialMap, ISpatialQuery } from '../../collections';
+import { AsyncValue } from '../../primitives/AsyncValue';
 /**
  * Spill Entries are used to track the extent an array formula occupies.
  *
@@ -15,7 +16,15 @@ export declare class SpillEntry {
     private _c;
     private _k;
     private _cycleId;
-    constructor(coords: IRange.Coords, cycleId: number, kind?: ITypes.FormulaArrayKind);
+    private _h;
+    /**
+     * @param holder The anchor's holder when the evaluation that laid the spill out deferred
+     * (DESIGN-ASYNC §4.4): the anchor cell holds the first element, so the entry carries what a
+     * scalar cell holds in its value, and moves and versions with the spill the same way.
+     */
+    constructor(coords: IRange.Coords, cycleId: number, kind?: ITypes.FormulaArrayKind, holder?: AsyncValue | null);
+    /** The anchor's holder, for a spill laid out by an evaluation that deferred; `null` otherwise. */
+    getHolder(): AsyncValue | null;
     getCycleId(): number;
     /** {@inheritDoc ITypes.FormulaArrayKind} */
     getKind(): ITypes.FormulaArrayKind;
@@ -52,4 +61,9 @@ export declare class SpillEntry {
     /** {@inheritDoc ISpatialMap.IUpdatableValue.getSplit} */
     getSplit(coords: [IRange.Coords, IRange.Coords], _axis: IRange.Axis): [this, this] | undefined;
 }
+/**
+ * The holder of the spill anchored at (`row`, `col`), or `null` when no spill is anchored there
+ * or its evaluation did not defer. A blocked spill's entry is anchored too.
+ */
+export declare const spillHolderAt: (spills: ISpatialQuery<SpillEntry> | null | undefined, row: number, col: number) => AsyncValue | null;
 //# sourceMappingURL=SpillEntry.d.ts.map

package/types/src/calculation/state/CalcNode.d.ts

@@ -51,7 +51,6 @@ export interface CalcNodeExt {
      * and by `setInputs` with a `arrayFixed`; translated with the node when its block moves.
      */
     fixedRef: IRange.Coords | null;
-    pendingPromise: Promise<any> | null;
     /**
      * The demand evaluation's result — finalized for the cell, or a pending promise — which
      * `doEvaluate` consumes in place of an `evaluateAt` of its own. Cleared once consumed.

package/types/src/calculation/state/CalcScope.d.ts

@@ -1,4 +1,5 @@
 import { CalcNode } from './CalcNode';
+import { DeferredCall } from './DeferredCalls';
 /**
  * A reused data structure passed to CalculationContext.
  *
@@ -70,6 +71,34 @@ export interface CalcScope {
      * before. Ignored when no seed is set.
      */
     drawIndex: number;
+    /**
+     * How many `IFormulaContext.defer` calls the backend has taken, ever.
+     *
+     * @remarks
+     * Never reset. A dispatch, or the executor around an evaluation, reads it before and compares
+     * after: a change means a body deferred inside, however deeply nested. Nothing else on the
+     * synchronous path reads it.
+     */
+    deferCount: number;
+    /**
+     * How many calls the evaluation in progress has deferred: the next call's ordinal, which is how
+     * a later evaluation of the same cell finds it. Back to `0` once the evaluation's calls are
+     * taken, which only an evaluation that deferred needs.
+     */
+    deferOrdinal: number;
+    /**
+     * Whether the formula's ROOT call deferred in the evaluation in progress. With one call in all,
+     * the cell's value is that call's answer and a settle needs no re-evaluation. Cleared with
+     * {@link deferOrdinal}.
+     */
+    deferRoot: boolean;
+    /**
+     * The call the last `defer` was served — the site's call standing for its payload — or `null`
+     * when that `defer` made a new one. The dispatch around the deferring body takes it and, when
+     * the call has a latest, answers that in place of the body's return. Cleared with
+     * {@link deferOrdinal}.
+     */
+    deferServed: DeferredCall | null;
     /**
      * Stable nameIds currently on the resolution stack — the cycle guard for named
      * formulas. A plain name re-entering itself (`X = X + 1`) is a circular reference.

package/types/src/calculation/state/CalcState.d.ts

@@ -23,10 +23,6 @@ export declare const CalcState: {
     readonly Removed: number;
     /** The node is in the pending spatial (the user has been given a pending status). */
     readonly Pending: number;
-    /** A precedent evaluated to a pending value this pass, so the node keeps its cached value. */
-    readonly PendingPrecedents: number;
-    /** The node's promise resolved; the result waits in `cachedValue` for the next pass. */
-    readonly PendingResolved: number;
     /**
      * The topological sort could not order the node this pass — it is in a reference cycle, or
      * downstream of one — so it was (or will be) evaluated by demand and `doEvaluate` takes its
@@ -82,6 +78,32 @@ export declare const CalcState: {
      * never needed for a right answer.
      */
     readonly Queued: number;
+    /**
+     * A precedent is pending with a value this pass: the node evaluates from that value, as any
+     * dependent does, and is pending with it.
+     */
+    readonly WaitingPrecedents: number;
+    /**
+     * The node is {@link Pending} with a value its dependents calculate from — it holds a call that
+     * has not answered, or was calculated from such a value — rather than holding them. Decided by
+     * each evaluation, so outside {@link PassMask}.
+     */
+    readonly PendingValue: number;
+    /**
+     * The node's one call answered with a shape its cell cannot take without the layout machinery
+     * — a range, or the cell is a spill anchor — and a settle seeded it (DESIGN-ASYNC §4.5): the
+     * settle pass takes the holder's latest in place of running the body and lays it out as any
+     * range result. Any other pass clears it and evaluates, since the node may be dirty for its own
+     * reasons. Outside {@link PassMask}: set between passes.
+     */
+    readonly ServeLatest: number;
+    /**
+     * The evaluation recorded a call of the cell's own that has not answered: the cell is working,
+     * not merely waiting on a precedent. Decided by each evaluation, so outside {@link PassMask}.
+     */
+    readonly OwnCall: number;
+    /** What the status index was last told, while {@link Pending}: working (set) or waiting (clear). */
+    readonly SentWorking: number;
     /** What the mark phase resets: everything a single pass decides. `Skip` and the shown role survive. */
     readonly PassMask: number;
 };

package/types/src/calculation/state/CalculationContext.d.ts

@@ -1,10 +1,11 @@
-import { IRange, ScalarType, FormulaError, Scalar, IReferenceRange, IFunction, IFormulaContext, IFunctionArguments, IRuntime } from '@sheetxl/primitives';
+import { IRange, ScalarType, FormulaError, Scalar, IReferenceRange, IFunction, IFormulaContext, IFunctionArguments, IRuntime, IRichData } from '@sheetxl/primitives';
 import { FunctionProvider } from '@sheetxl/scripting';
 import { ITransaction } from '../../transaction';
 import { IFunctionCollection } from '../../scripting';
 import { Tuple } from '../../collections';
 import { IContextContainer } from './IContextContainer';
 import { CalcScope } from './CalcScope';
+import { WhatIfTable } from '../executor/_WhatIf';
 import { ReadHook } from './_ReadObservedGrid';
 export declare class CalculationContext implements IFormulaContext {
     protected _instanceScope: any;
@@ -60,6 +61,22 @@ export declare class CalculationContext implements IFormulaContext {
      * hook is armed. See {@link _dynamicRead}.
      */
     _setDynamicReadHook(hook: ReadHook | null): void;
+    /**
+     * @hidden
+     * Disarms both read hooks and returns what they were, for {@link _restoreReadHooks}: a what-if
+     * evaluation reads plainly in the middle of a node that is itself observed.
+     */
+    _takeReadHooks(): [ReadHook | null, ReadHook | null];
+    /** @hidden Re-arms the hooks {@link _takeReadHooks} returned. */
+    _restoreReadHooks(hooks: [ReadHook | null, ReadHook | null]): void;
+    /**
+     * @hidden
+     * The grid id of the cell being evaluated and of an input reference, for `TABLE`: `null` for a
+     * reference whose sheet does not resolve.
+     */
+    _gridIdOfReference(coords: Readonly<IRange.Coords> | null): string | null;
+    /** @hidden The what-if results of a data table, for the `TABLE` node being evaluated. */
+    _evaluateWhatIf(table: WhatIfTable): Scalar[][] | null;
     /**
      * @hidden
      *
@@ -81,6 +98,12 @@ export declare class CalculationContext implements IFormulaContext {
     _createScoped(sheet: string): CalculationContext | null;
     /** @inheritdoc IFormulaContext.getFunction */
     getFunction(name: string): IFunction | null;
+    /**
+     * @hidden
+     * The function registry's stamp: a function {@link getFunction} returned stays the answer for its
+     * name while this is unchanged.
+     */
+    _getFunctionStamp(): number;
     /** @inheritdoc IFormulaContext.getNumberFormat */
     getNumberFormat(formatText: string, value: Scalar): string | null;
     /** @inheritdoc IFormulaContext.getEntireCoords */
@@ -89,6 +112,8 @@ export declare class CalculationContext implements IFormulaContext {
     getFormulaAt(row: number, column: number, sheetName?: string): string | null;
     /** @inheritdoc IFormulaContext.markVolatile */
     markVolatile(): void;
+    /** @inheritdoc IFormulaContext.defer */
+    defer(executor: IFormulaContext.DeferExecutor, payload?: unknown): unknown;
     /** @inheritdoc IFormulaContext.formatResults */
     formatResults(numFmt: string): void;
     /** @inheritdoc IFormulaContext.filterHidden */
@@ -205,6 +230,8 @@ export declare class CalculationContext implements IFormulaContext {
     toText(value: Scalar | undefined): string;
     /** @inheritdoc IFormulaContext.getRuntime */
     getRuntime(): IRuntime;
+    /** @inheritdoc IFormulaContext.createRichData */
+    createRichData(type: string, data?: any): IRichData;
     /** @inheritdoc IFormulaContext.getArgs */
     getArgs(): IFunctionArguments;
     get [Symbol.toStringTag](): string;