@sheetxl/sdk 0.7.21 → 0.7.23-beta.2

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

@@ -0,0 +1,120 @@
+import { FormulaError, IRange } from '@sheetxl/primitives';
+import { ISpatialMap } from '../../collections/ISpatialMap';
+import { IFormulaBlock } from '../formula';
+import { CalcNode, IContextContainer } from '../state';
+import { ReferenceCoords, SetReferenceOptions } from '../Types';
+import { ICalculation } from '../ICalculation';
+/**
+ * This extends IFormulaBlock with spatial behavior.
+ */
+export declare class FormulaSpatialValue implements IFormulaBlock, ISpatialMap.IUpdatableValue<FormulaSpatialValue> {
+    protected _container: IContextContainer;
+    gridId: string | null;
+    /**
+     * The block's extent.
+     *
+     * Invariant: whenever this block is stored in the formula spatial map, `ref` equals that entry's
+     * coords — every construction site builds the block from the coords of the entry it is stored under,
+     * and `getSplit` mints a new block per piece rather than narrowing an entry over a shared block.
+     *
+     * Consumers rely on this to treat a formula-sourced entry as the block's own extent (no offset to
+     * map through). Reusing one block across entries of differing coords would silently break the dirty
+     * windowing in `doCollectDirtyCalcs`.
+     */
+    ref: IRange.Coords;
+    formula: IFormulaBlock | null;
+    calcs: CalcNode[][];
+    /**
+     * The precedent entries that were actually registered for this block.
+     *
+     * Removal cannot re-derive these: it resolves the block's references against *current* state, and a
+     * reference may no longer resolve by then (deleting a named formula makes its dependents resolve to
+     * `#NAME?`, which the remove loop skips). The entry then survives holding a back-pointer to this —
+     * now stale — block, so the cell is reachable through both the stale precedent and its recompiled
+     * formula, yielding two CalcNodes for one cell and a duplicate push in the value builder.
+     *
+     * Recording what was inserted lets removal evict by identity instead. Only populated by the
+     * `updatePrecedentsSpatial` insert path; other paths leave it null and fall back to resolution.
+     */
+    registeredPrecedents: ISpatialMap.Entry<any>[] | null;
+    /**
+     * `true` when {@link ref} is a synthetic anchor rather than a position in a real grid — a named
+     * formula's body (stored at (0,0) in its virtual grid) or the editor's temporary formula.
+     *
+     * @remarks
+     * A **relative** reference is stored as an offset from `ref`, so on these blocks its absolute
+     * position (`ref + offset`) is fiction: there is no cell it names, and nothing to compare against
+     * a shift boundary. Structural change must therefore leave relative endpoints alone — the offset
+     * IS the definition. Measured against Excel: a relative name's `RefersTo` never changes under
+     * insert/delete/move, while an absolute one always does (`$`-fixed endpoints carry a real
+     * coordinate that owes nothing to the anchor, so they shift normally on these blocks too).
+     *
+     * Deliberately NOT "is a named body". Anything holding a formula at a synthetic anchor wants the
+     * same treatment, and the shift code should not have to know what a name is.
+     *
+     * Required at construction rather than defaulted: the block is immutable and re-minted on every
+     * reference rewrite, so an unthreaded copy would silently revert to `false` on the first
+     * `setReferenceAt` — which is exactly what a shift performs.
+     */
+    readonly unanchored: boolean;
+    constructor(coords: IRange.Coords, gridId: string | null, formula: IFormulaBlock | null, container: IContextContainer, unanchored: boolean, calcs?: CalcNode[][]);
+    protected _createCalcs(formula: IFormulaBlock | null, gridId: string | null, coords: IRange.Coords): CalcNode[][];
+    protected _cloneCalcs(calcs: CalcNode[][], colStart: number, rowStart: number, gridId?: string | null): CalcNode[][];
+    toJSON(r1c1?: boolean, formulaTransform?: ICalculation.FormulaTransform): [coords: string, text: string];
+    getCoords(): IRange.Coords;
+    /** {@inheritDoc ISpatialMap.IUpdatableValue.getShifted} */
+    getShifted(options: ISpatialMap.ShiftDetails<this>): ISpatialMap.Entry<this> | null;
+    /** {@inheritDoc ISpatialMap.IUpdatableValue.getMerged} */
+    getMerged(other: this, coords: IRange.Coords, axis: IRange.Axis): this | undefined;
+    /** {@inheritDoc ISpatialMap.IUpdatableValue.getSplit} */
+    getSplit(coords: [IRange.Coords, IRange.Coords], axis: IRange.Axis, offset: number): [this, this] | undefined;
+    /** {@inheritDoc ISpatialMap.IUpdatableValue.copyTo} */
+    copyTo(destination: IRange.Coords, options?: FormulaCopyToOptions): ISpatialMap.Entry<this> | undefined;
+    /** {@inheritDoc ISpatialMap.IUpdatableValue.canTile} */
+    canTile(_destination: IRange.Coords, _options?: ISpatialMap.CopyOptions): boolean;
+    /** {@inheritDoc ISpatialMap.IUpdatableValue.getSplit} */
+    onRemove?(entry: ISpatialMap.Entry<FormulaSpatialValue>): void;
+    /** {@inheritDoc IFormulaBlock.evaluateAt} */
+    evaluateAt(row: number, column: number, evalIndex?: number): any;
+    /** {@inheritDoc IFormulaBlock.finalizeValue} */
+    finalizeValue(value: any): any;
+    /** {@inheritDoc IFormulaBlock.finalizeValueForCell} */
+    finalizeValueForCell(value: any): any;
+    /** {@inheritDoc IFormulaBlock.getTokensAt} */
+    getTokensAt(row: number, column: number, evalIndex?: number): ICalculation.FormulaToken[];
+    /** {@inheritDoc IFormulaBlock.getTextAt} */
+    getTextAt(row: number, column: number, r1c1?: boolean, formulaTransform?: ICalculation.FormulaTransform): string;
+    /** {@inheritDoc IFormulaBlock.resolvedPrecedentsAt} */
+    resolvedPrecedentsAt(row: number, column: number, includeInvalidIntersect?: boolean, verticalAbs?: boolean[], horizontalAbs?: boolean[]): readonly (Readonly<IRange.FixableCoords> | FormulaError.Known)[];
+    /** {@inheritDoc IFormulaBlock.getReferences} */
+    getReferences(row: number, column: number): ReferenceCoords[];
+    /** {@inheritDoc IFormulaBlock.getReferenceAt} */
+    getReferenceAt(row: number, column: number, index: number): ReferenceCoords;
+    /** {@inheritDoc IFormulaBlock.setReferenceAt} */
+    setReferenceAt(index: number, reference: ReferenceCoords, options?: SetReferenceOptions): this;
+    /** {@inheritDoc IFormulaBlock.reanchorReferences} */
+    reanchorReferences(toGridId: string, force?: boolean): this;
+    /** {@inheritDoc IFormulaBlock.replaceSheetReferences} */
+    replaceSheetReferences(fromSheetDisplay: string, toSheetDisplay: string): this;
+    /** {@inheritDoc IFormulaBlock.wrapImplicit} */
+    wrapImplicit(rowIndex: number, colIndex: number, setSpillCells: Set<string>): this;
+    /** {@inheritDoc IFormulaBlock.getError} */
+    getError(): FormulaError.Parse | null;
+    /** {@inheritDoc IFormulaBlock.getNamedIds} */
+    getNamedIds(): string[];
+    /** {@inheritDoc IFormulaBlock.getReferencedSymbolIds} */
+    getReferencedSymbolIds(): string[];
+    /** {@inheritDoc IFormulaBlock.hasTotals} */
+    hasTotals(): boolean;
+    /** @inheritdoc IFormulaBlock.isReferenceOnly */
+    isReferenceOnly(): boolean;
+    /** {@inheritDoc IFormulaBlock.isEquals} */
+    isEquals(other: IFormulaBlock): boolean;
+}
+export interface FormulaCopyToOptions extends ISpatialMap.CopyOptions {
+    /**
+     * For cut operations: the source range being cut. Used to determine which relative edges to adjust.
+     */
+    cutFrom?: IRange.Coords;
+}
+//# sourceMappingURL=FormulaSpatialValue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FormulaSpatialValue.d.ts","sourceRoot":"","sources":["../../../../../src/calculation/spatial/FormulaSpatialValue.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,115 @@
+import { ISpatialMap } from '../../collections/ISpatialMap';
+import { FormulaSpatialValue } from './FormulaSpatialValue';
+/**
+ * What an entry's BOUNDS describe, for the entries that describe something other than a written
+ * reference. These ARE {@link PrecedentSpatialValue.index} values — the negative half of it — so
+ * there is no `Static` member: a static entry's kind is carried by its index being `>= 0`, which is
+ * also the index of the reference it stands for.
+ *
+ * @remarks
+ * One field rather than two because the two would never be independent: `index >= 0` has always
+ * meant static, so a separate tag could only ever agree with it or be wrong. Merged, a nonsense
+ * pairing cannot be built, the hot test in `doCollectDirtyCalcs` is `index < 0`, and these entries —
+ * one per (block, reference), the densest objects in the graph — carry one slot less.
+ *
+ * The distinction exists for the REPORTING apis (`getDirectDependentsAt`), which must answer with
+ * the cells that READ the query and therefore cannot treat a {@link PrecedentKind.Reference} entry's
+ * bounds as a location. The calculation path needs none of it: marking reads only
+ * `formulaEntry.value` and takes its geometry from the entry, and `doCollectDirtyCalcs` recalculates
+ * the whole block for anything negative.
+ */
+export declare const PrecedentKind: {
+    /**
+     * A range discovered at evaluation time — `INDIRECT`/`OFFSET`. The bounds are the range READ, on
+     * whatever grid it names, which is unrelated to where the formula lives.
+     */
+    readonly Reference: -1;
+    /**
+     * A watcher over a spill's own output footprint, registered so that typing into the spill area
+     * re-evaluates the anchor and raises (or clears) `#SPILL!`. The bounds are the formula's OUTPUT:
+     * anchored at the formula cell, on the formula's own grid, and always containing the block.
+     */
+    readonly Spill: -2;
+};
+export type PrecedentKind = typeof PrecedentKind[keyof typeof PrecedentKind];
+/**
+ * WHY THIS EXISTS
+ * ---------------
+ * `precedentSpatial` lets `getDirectDependentsAt(query)` find every formula
+ * that reads from a queried input range with a *single spatial search*.  Without
+ * it, every formula block would have to be iterated individually.
+ *
+ * One entry is stored per (formula block, reference) pair.  Its *spatial bounds*
+ * are the union of all per-cell natural ranges across the whole formula block,
+ * so a single rectangle covers every cell the block could ever read.  The fields
+ * below carry enough geometry to map any queried input cell back to the exact
+ * subset of formula cells that read from it — without re-parsing the formula.
+ */
+export interface PrecedentSpatialValue {
+    /**
+     * Back-pointer to the owning formula block entry in `formulaSpatial`.
+     *
+     * Stored here so the hot calculation loop can reach the formula block from a
+     * precedent entry without a second spatial map lookup.
+     *
+     * @remarks
+     * This is used primary by visitDependencies in markAndPlan but also in collectDirties.
+     *
+     * Only a static entry points at a REAL `formulaSpatial` entry, whose coords are the block's own.
+     * The dynamic kinds carry a synthetic one built around the watched range, so its coords mean
+     * whatever {@link index} says they mean — the block's true extent is always `formulaEntry.value.ref`
+     * (and `.gridId`), never these coords.
+     */
+    formulaEntry: ISpatialMap.Entry<FormulaSpatialValue>;
+    /**
+     * Formula block dimensions: `fh + 1` rows, `fw + 1` cols.
+     *
+     * Primary role — stable `fh` / `fw` for the sliding-window algorithm:
+     *   windowRowSpan  = (entry.rowEnd − entry.rowStart) − (formulaBlockHeight − 1)
+     *   offsetRowEnd   = min(queryEnd − entry.rowStart,    formulaBlockHeight − 1)
+     * and for the absolute case: offsetRowEnd = formulaBlockHeight − 1.
+     *
+     * Always the ORIGINAL block, so on a {@link PrecedentKind.Spill} entry — whose synthetic
+     * `formulaEntry` spans the whole spill output — it stays the 1×1 anchor and the two disagree.
+     * That gap used to be how a spill was recognized; {@link index} says it outright now, and the
+     * comparison survives only as a guard on static entries.
+     */
+    formulaBlockWidth: number;
+    formulaBlockHeight: number;
+    /**
+     * Which reference this entry stands for, and — when negative — what kind of entry it is.
+     *
+     * `>= 0` indexes the formula's precedent list, matching `formula.getPrecedents()[index]`.
+     * Negative values are {@link PrecedentKind}: these entries correspond to no written reference at
+     * all, so the slot carries the kind instead of an index that could not exist.
+     */
+    index: number;
+    /**
+     * Whether each ENDPOINT is anchored with `$`, and so does not slide from one cell of the block
+     * to the next.
+     *
+     * @remarks
+     * Per endpoint rather than per axis, because the two endpoints move independently and a range
+     * can mix them. `$A$1:A1` filled down — the running-total idiom — has a pinned start and a
+     * sliding end, so its cells read `$A$1:A1`, `$A$1:A2`, `$A$1:A3`: the union GROWS downward even
+     * though one endpoint never moves. A single per-axis flag (set when *either* endpoint was
+     * anchored) read that as fully pinned and left the union at the anchor cell's own range, so the
+     * rows below it were never registered as precedents at all and edits there updated nothing.
+     *
+     * Everything derived from this geometry keys off one endpoint or the other, never the axis:
+     *
+     *   entry bounds (`addPrecedents`)   rowEnd += $absRowEnd ? 0 : fh   — the END drives the union
+     *   natural size (`nh`)              $absRowEnd ? span : span - fh
+     *   sliding window, low  bound       $absRowEnd   ? 0    : max(0, d - windowRowSpan)
+     *   sliding window, high bound       $absRowStart ? fh   : min(fh, d)
+     *
+     * The window bounds invert because a cell reads a queried row `d` when its start is at or above
+     * it AND its end at or below: the START endpoint bounds which cells are still low enough (the
+     * high bound), and the END endpoint which are already high enough (the low bound).
+     */
+    $absColStart: boolean;
+    $absColEnd: boolean;
+    $absRowStart: boolean;
+    $absRowEnd: boolean;
+}
+//# sourceMappingURL=PrecedentSpatialValue.d.ts.map

package/types/src/calculation/spatial/PrecedentSpatialValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrecedentSpatialValue.d.ts","sourceRoot":"","sources":["../../../../../src/calculation/spatial/PrecedentSpatialValue.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAEjE,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAEjE;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,aAAa;IACxB;;;OAGG;;IAEH;;;;OAIG;;CAEK,CAAC;AACX,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC,MAAM,OAAO,aAAa,CAAC,CAAC;AAE7E;;;;;;;;;;;;GAYG;AAEH,MAAM,WAAW,qBAAqB;IACpC;;;;;;;;;;;;;OAaG;IACH,YAAY,EAAE,WAAW,CAAC,KAAK,CAAC,mBAAmB,CAAC,CAAC;IAErD;;;;;;;;;;;;OAYG;IACH,iBAAiB,EAAE,MAAM,CAAC;IAC1B,kBAAkB,EAAE,MAAM,CAAC;IAE3B;;;;;;OAMG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,YAAY,EAAE,OAAO,CAAC;IACtB,UAAU,EAAE,OAAO,CAAC;IACpB,YAAY,EAAE,OAAO,CAAC;IACtB,UAAU,EAAE,OAAO,CAAC;CAErB"}

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

@@ -0,0 +1,40 @@
+import { IRange } from '@sheetxl/primitives';
+import { ITypes } from '../../type';
+import { ISpatialMap } from '../../collections';
+/**
+ * Spill Entries are used to track the extent an array formula occupies.
+ *
+ * There are three {@link ITypes.FormulaArrayKind | kinds}:
+ * * `dynamic` - the extent was derived from the result during a calculation cycle.
+ * * `dynamicSpillError` - the spill was blocked. This can arise either from a direct input via the
+ *   api or from a collision detected during a calculation cycle.
+ * * `static` - a legacy array-entered (Ctrl+Shift+Enter) block, whose extent is fixed and
+ *   authoritative rather than derived. Degenerate 1x1 static entries are legal and meaningful.
+ */
+export declare class SpillEntry {
+    private _c;
+    private _k;
+    private _cycleId;
+    constructor(coords: IRange.Coords, cycleId: number, kind?: ITypes.FormulaArrayKind);
+    getCycleId(): number;
+    /** {@inheritDoc ITypes.FormulaArrayKind} */
+    getKind(): ITypes.FormulaArrayKind;
+    getError(): boolean;
+    /**
+     * True for a legacy array-entered block, whose extent must not be re-derived from the result.
+     */
+    isFixed(): boolean;
+    getCoords(): IRange.Coords;
+    setError(error: boolean, cycleId: number): ISpatialMap.Entry<this>;
+    /**
+     * Translate the coordinates of the spill
+     */
+    getTranslated(rowIndex: number, colIndex: number): ISpatialMap.Entry<this>;
+    /** {@inheritDoc ISpatialMap.IUpdatableValue.getShifted} */
+    getShifted(options: ISpatialMap.ShiftDetails<this>): ISpatialMap.Entry<this> | null;
+    /** {@inheritDoc ISpatialMap.IUpdatableValue.getMerged} */
+    getMerged(_other: this, coords: IRange.Coords, _axis: IRange.Axis): this | undefined;
+    /** {@inheritDoc ISpatialMap.IUpdatableValue.getSplit} */
+    getSplit(coords: [IRange.Coords, IRange.Coords], _axis: IRange.Axis): [this, this] | undefined;
+}
+//# sourceMappingURL=SpillEntry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SpillEntry.d.ts","sourceRoot":"","sources":["../../../../../src/calculation/spatial/SpillEntry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAGlD,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD;;;;;;;;;GASG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,EAAE,CAAgB;IAC1B,OAAO,CAAC,EAAE,CAA0B;IACpC,OAAO,CAAC,QAAQ,CAAS;gBAGvB,MAAM,EAAE,MAAM,CAAC,MAAM,EACrB,OAAO,EAAE,MAAM,EACf,IAAI,GAAE,MAAM,CAAC,gBAA0B;IAQzC,UAAU,IAAI,MAAM;IAIpB,4CAA4C;IAC5C,OAAO,IAAI,MAAM,CAAC,gBAAgB;IAIlC,QAAQ,IAAI,OAAO;IAInB;;OAEG;IACH,OAAO,IAAI,OAAO;IAIlB,SAAS,IAAI,MAAM,CAAC,MAAM;IAI1B,QAAQ,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC;IAwBlE;;OAEG;IACH,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC;IAgB1E,2DAA2D;IAC3D,UAAU,CAAC,OAAO,EAAE,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI;IAUnF,0DAA0D;IAC1D,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,IAAI,GAAG,IAAI,GAAG,SAAS;IAMpF,yDAAyD;IACzD,QAAQ,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,IAAI,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,SAAS;CAO/F"}

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

@@ -0,0 +1,5 @@
+export * from './SpillEntry';
+export * from './ContentfulSpatialValue';
+export * from './FormulaSpatialValue';
+export * from './PrecedentSpatialValue';
+//# sourceMappingURL=index.d.ts.map

package/types/src/calculation/spatial/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/calculation/spatial/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,0BAA0B,CAAC;AAEzC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC"}

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

@@ -0,0 +1,71 @@
+import { Scalar, FormulaError, IRange } from '@sheetxl/primitives';
+import { ISpatialMap } from '../../collections';
+import { PrecedentSpatialValue, FormulaSpatialValue } from '../spatial';
+export interface CalcNode {
+    block: FormulaSpatialValue;
+    gridId: string | null;
+    colIndex: number;
+    rowIndex: number;
+    cycleId: number;
+    markId: number;
+    inDegree: number;
+    /**
+     * Cached result of a spatial search: all ISpatialMap.Entry<PrecedentSpatialValue> blocks whose formula ranges
+     * overlap this cell.
+     * Populated once during the mark phase (the BFS upward-walk), then reused by the topological sort to decrement.
+     */
+    dependents: ISpatialMap.Entry<PrecedentSpatialValue>[];
+    /**
+     * Parallel to `precedents`. One slot per static precedent, in formula order.
+     * Populated by the push model: after CalcNode N evaluates, N writes cachedValue into
+     * each dependent D's inputs[entry.value.index]. Range-typed slots are filled by a
+     * mid-cycle ReferenceRange (see doEvaluate range branch). Read by CalculationContext
+     * during evaluateAt() to resolve formula argument values.
+     * Undefined slots mean the precedent is a constant cell — CalculationContext falls back to the grid.
+     */
+    inputs: (Scalar | IRange | IRange.Coords | undefined)[];
+    /**
+     * Coordinate ranges for every static precedent in formula order, parallel to `inputs`.
+     * Pre-filled at CalcNode construction from resolvedPrecedentsAt(cellRow, cellCol).
+     * Errors (FormulaError.Known) appear where the reference resolves to an invalid range (#REF! etc.).
+     * Read by CalculationContext for runtime value lookups and by the mark phase for inDegree computation.
+     */
+    precedents: (IRange.Coords | FormulaError.Known)[];
+    /**
+     * The cached value of the cell after evaluation.
+     *
+     * @remarks
+     * This is `undefined` if not calculated.
+     */
+    cachedValue: Scalar | IRange | undefined;
+    pendingPromise: Promise<any> | null;
+    /**
+     * Indicates if the pending is in the pending spatial (to avoid lookup)
+     */
+    pending: boolean;
+    /**
+     * Indicates the pending is waiting on a precedent to resolve.
+     */
+    pendingPrecedents: boolean;
+    /**
+     * Indicates the pending is full filled and waiting for the next cycle to resolve.
+     */
+    pendingResolved: boolean;
+    /**
+     * Set when the topological sort could not order this node — it is part of a reference cycle, or
+     * downstream of one. Reset for every affected node at the start of each mark phase, so like
+     * `inDegree` it only describes the CURRENT cycle.
+     *
+     * @remarks
+     * Deliberately not folded into {@link state}: `state` carries the Skip/Pending transitions that
+     * `doEvaluate` reads and rewrites mid-pass, and this has to survive being set BEFORE that runs.
+     */
+    circular: boolean;
+    /**
+     * The state is a bit mask with transient states.
+     * The CalcNode is reused across cycles and cloned records for performance.
+     * To ensure that it is correct the cycleId id must be consulted.
+     */
+    state: number;
+}
+//# sourceMappingURL=CalcNode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CalcNode.d.ts","sourceRoot":"","sources":["../../../../../src/calculation/state/CalcNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,YAAY,EAAE,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElF,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,OAAO,EAAE,KAAK,qBAAqB,EAAE,KAAK,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAClF,MAAM,WAAW,QAAQ;IAEvB,KAAK,EAAE,mBAAmB,CAAC;IAG3B,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IAGjB,OAAO,EAAE,MAAM,CAAC;IAGhB,MAAM,EAAE,MAAM,CAAC;IAGf,QAAQ,EAAE,MAAM,CAAC;IAEjB;;;;OAIG;IACH,UAAU,EAAE,WAAW,CAAC,KAAK,CAAC,qBAAqB,CAAC,EAAE,CAAC;IAEvD;;;;;;;OAOG;IACH,MAAM,EAAE,CAAC,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,CAAC;IAExD;;;;;OAKG;IACH,UAAU,EAAE,CAAC,MAAM,CAAC,MAAM,GAAG,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC;IAEnD;;;;;OAKG;IACH,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IAEzC,cAAc,EAAE,OAAO,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC;IAEpC;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;OAEG;IACH,iBAAiB,EAAE,OAAO,CAAC;IAC3B;;OAEG;IACH,eAAe,EAAE,OAAO,CAAC;IAEzB;;;;;;;;OAQG;IACH,QAAQ,EAAE,OAAO,CAAC;IAQlB;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAC;CACf"}

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

@@ -0,0 +1,35 @@
+import { CalcNode } from './CalcNode';
+/**
+ * A reused data structure passed to CalculationContext.
+ *
+ * @remarks
+ * This allows for the FormulaContext to interact with the calculation engine.
+ */
+export interface CalcScope {
+    gridId: string | null;
+    rowIndex: number;
+    colIndex: number;
+    /**
+     * The outermost real cell being evaluated — the **owner** for attribution.
+     *
+     * @remarks
+     * `markVolatile` and `addDynamicPrecedent` attribute to this node. When evaluation
+     * descends into a shared named-formula body (apply-at-eval), the body has no node of
+     * its own and does not overwrite this field, so volatility / dynamic precedents are
+     * correctly charged to the outermost caller.
+     */
+    node: CalcNode | null;
+    /**
+     * Recursion depth of the current evaluation (named-formula / LAMBDA apply-at-eval).
+     * 0 for an ordinary cell. Enforces the LAMBDA recursion limit (Step 14).
+     */
+    depth: number;
+    /**
+     * 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.
+     * (LAMBDA recursion is permitted up to `depth`; it is not a cycle.) Pushed/popped
+     * synchronously around each named-body descent.
+     */
+    activeNames: Set<string>;
+}
+//# sourceMappingURL=CalcScope.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CalcScope.d.ts","sourceRoot":"","sources":["../../../../../src/calculation/state/CalcScope.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C;;;;;GAKG;AACH,MAAM,WAAW,SAAS;IAExB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IAEjB;;;;;;;;OAQG;IACH,IAAI,EAAE,QAAQ,GAAG,IAAI,CAAC;IAEtB;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;;;OAKG;IACH,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CAC1B"}

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

@@ -0,0 +1,28 @@
+export declare const CalcState: {
+    /**
+     * The default state.
+     */
+    readonly Active: 0;
+    /**
+     * Causing a recalc due to a dynamic dependency. This is either a
+     * dynamic precedent or a spill output.
+     */
+    readonly Skip: 1;
+    readonly Removed: 2;
+    /**
+     * The calc node is pending and waiting for a precedent to resolve.
+     * This is used to indicate that the user has been given a pending status.
+     */
+    readonly Pending: 3;
+    /**
+     * The calc node is pending and waiting for a precedent to resolve.
+     * This is used for dynamic dependencies that are not yet resolved.
+     */
+    readonly PendingPrecedents: 4;
+    /**
+     * The calc node is pending and waiting for a precedent to resolve.
+     * This is used for dynamic dependencies that are not yet resolved.
+     */
+    readonly PendingResolved: 5;
+};
+//# sourceMappingURL=CalcState.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CalcState.d.ts","sourceRoot":"","sources":["../../../../../src/calculation/state/CalcState.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,SAAS;IACpB;;OAEG;;IAGH;;;OAGG;;;IAIH;;;OAGG;;IAEH;;;OAGG;;IAEH;;;OAGG;;CAEK,CAAC"}

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

@@ -0,0 +1,125 @@
+import { IRange, ScalarType, FormulaError, Scalar, IReferenceRange, IFunction, IFormulaContext, IRuntime } 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';
+export declare class CalculationContext implements IFormulaContext {
+    protected _instanceScope: any;
+    protected _runtime: IRuntime;
+    protected _calcScope: CalcScope;
+    protected _functions: IFunctionCollection;
+    protected _container: IContextContainer;
+    protected _axis: IRange.Axis;
+    protected _coerceToNumber: (value: Scalar, fromType: ScalarType, options?: IFormulaContext.ParseNumberOptions) => Scalar;
+    protected _functionProviders?: readonly FunctionProvider[];
+    constructor(container: IContextContainer, axis?: IRange.Axis, functionProviders?: readonly FunctionProvider[]);
+    /** @hidden */
+    _setInstanceScope(instanceScope: any): void;
+    /**
+     * @hidden
+     *
+     * Will be per worker so we need to dispatch runtime info and functions.
+     */
+    _initialize(transactions?: ITransaction.IStore): Promise<{
+        functions: IFunctionCollection;
+    }>;
+    /**
+     * @hidden
+     * A context bound to `sheet`'s grid INDEPENDENT of evaluation state — the public-API vend
+     * behind `IFunctionCollection.getByName(name, { sheet })` (CALC-ISSUES item 35). The engine's
+     * shared context resolves references through the mutable `CalcScope` the container owns, which
+     * only carries a grid while a formula is evaluating; a vended function called outside the
+     * graph needs a grid of its own. Shares every initialized part (runtime, functions, coercer) —
+     * only the scope object is new — and is NEVER used on the engine's evaluation path, which
+     * stays allocation-free on the shared instance.
+     */
+    _createScoped(sheet: string): CalculationContext | null;
+    /** @inheritdoc IFormulaContext.getFunction */
+    getFunction(name: string): IFunction | null;
+    /** @inheritdoc IFormulaContext.getNumberFormat */
+    getNumberFormat(formatText: string, value: Scalar): string | null;
+    /** @inheritdoc IFormulaContext.getEntireCoords */
+    getEntireCoords(): IRange.Coords;
+    /** @inheritdoc IFormulaContext.getFormulaAt */
+    getFormulaAt(row: number, column: number, sheetName?: string): string | null;
+    /** @inheritdoc IFormulaContext.markVolatile */
+    markVolatile(): void;
+    /** @inheritdoc IFormulaContext.formatResults */
+    formatResults(numFmt: string): void;
+    /** @inheritdoc IFormulaContext.filterHidden */
+    filterHidden(range: IRange, axes?: IRange.AxisSelection): IRange;
+    /** @inheritdoc IFormulaContext.filterTotals */
+    filterTotals(range: IRange): IRange;
+    /** @inheritdoc IFormulaContext.getSheetIndex */
+    getSheetIndex(sheet?: string | IReferenceRange): number;
+    /** @inheritdoc IFormulaContext.getSheetCount */
+    getSheetCount(): number;
+    /** @inheritdoc IFormulaContext.isValidDate */
+    isValidDate(value: any, jsDateOnly?: boolean): boolean;
+    /** @inheritdoc IFormulaContext.fromSerialDate */
+    fromSerialDate(serialDate: number, dateOnly?: boolean): Date;
+    /** @inheritdoc IFormulaContext.toSerialDate */
+    toSerialDate(date: Date, dateOnly?: boolean): number;
+    /** @inheritdoc IFormulaContext.getDateParts */
+    getDateParts(serialDate: number, reuseParts?: IFormulaContext.DateParts | boolean): IFormulaContext.DateParts;
+    /** @inheritdoc IFormulaContext.getSerialDate */
+    getSerialDate(year: number, month: number, day: number, hour?: number, minute?: number, second?: number, millis?: number): number;
+    /** @inheritdoc IFormulaContext.getNow */
+    getNow(): number;
+    /** @inheritdoc IFormulaContext.compare */
+    compare(a: Scalar, b: Scalar, options?: Intl.CollatorOptions): number;
+    protected _fromTuples(boundedTuples: Tuple.BoundedTuples<Scalar>, type?: ScalarType | null, isLiteral?: boolean, isDirectScalar?: boolean): IRange | null;
+    /** @inheritdoc IFormulaContext.getValueAt */
+    getValueAt(rowIndex: number, colIndex: number, sheetName?: string | null, options?: IRange.ValueOptions): Scalar | null;
+    /** @inheritdoc IFormulaContext.getSpillAt */
+    getSpillAt(rowIndex: number, colIndex: number, sheetName?: string): IReferenceRange | null;
+    /** @inheritdoc IFormulaContext.createRange */
+    createRange<TS extends Scalar = Scalar>(rows?: number, columns?: number, values?: Scalar | Scalar[][] | ((value: TS, coords: IRange.CellCoords, range: IRange<TS>) => TS)): IRange;
+    getRange(value: Scalar | Scalar[][], type?: ScalarType | null, isLiteral?: boolean): IRange;
+    /** @inheritdoc IFormulaContext.getRow */
+    getRow(): number;
+    /** @inheritdoc IFormulaContext.getColumn */
+    getColumn(): number;
+    /** @inheritdoc IFormulaContext.getReference */
+    getReference(coords: IRange.Coords | string, r1c1?: boolean): IReferenceRange;
+    /** @inheritdoc IFormulaContext.getResizedReference */
+    getResizedReference(anchor: Readonly<IRange.Coords>, rowCount: number, colCount: number): IReferenceRange;
+    /**
+     * Builds the {@link ReferenceRange} every {@link getReference} path returns.
+     *
+     * @remarks
+     * Coords that land off the grid cannot be formed into a reference at all, and `ReferenceRange`
+     * says so with an internal `OutOfBoundsError`. Left alone that escapes the calculation as a
+     * `#VALUE!` carrying the text "Out of bounds"; the formula-visible answer is `#REF!`, which is
+     * what {@link IFormulaContext.getReference} documents and what Excel answers for every consumer
+     * whose reference IS the result (`OFFSET` in all four directions, `INDIRECT` past the last
+     * row/column - probe-oob-getreference.ps1).
+     *
+     * A caller that reads a WINDOW rather than returning a reference - `SUMIF`'s `sum_range`,
+     * `LOOKUP`'s `result_vector`, both anchor-plus-length - goes through
+     * {@link getResizedReference} instead: Excel reads the part that fits rather than failing.
+     */
+    private _toReference;
+    /** @inheritdoc IFormulaContext.getAddress */
+    getAddress(coords?: Readonly<IRange.FixableCoords | IRange.FixableCellCoords>, r1c1?: boolean): string;
+    /** @inheritdoc IFormulaContext.parseAsSerialDate */
+    parseAsSerialDate(textOrNumber: string | number, requireDate?: boolean): number;
+    /** @inheritdoc IFormulaContext.parseAsDate */
+    parseAsDate(serialOrString: string | number | Date | any, requireDate?: boolean): Date;
+    /** @inheritdoc IFormulaContext.parseAsNumber */
+    parseAsNumber(textOrNumber: Scalar, options?: IFormulaContext.ParseNumberOptions): number;
+    parseAsNumber(textOrNumber: Scalar | undefined, options?: IFormulaContext.ParseNumberOptions): number | undefined;
+    /** @inheritdoc IFormulaContext.createCriteria */
+    createCriteria(criteria: Scalar): IFormulaContext.CriteriaEvaluator;
+    /** @inheritdoc IFormulaContext.parseAsLiteral */
+    parseAsLiteral(text: string): boolean | FormulaError.Known | undefined;
+    /** @inheritdoc IFormulaContext.toText */
+    toText(value: Scalar | undefined): string;
+    /** @inheritdoc IFormulaContext.getRuntime */
+    getRuntime(): IRuntime;
+    get [Symbol.toStringTag](): string;
+    toString(): string;
+}
+//# sourceMappingURL=CalculationContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CalculationContext.d.ts","sourceRoot":"","sources":["../../../../../src/calculation/state/CalculationContext.ts"],"names":[],"mappings":"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"}