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

package/types/src/comment/_NoteBox.d.ts

@@ -0,0 +1,67 @@
+import { IRange } from '@sheetxl/primitives';
+import { Bounds } from '@sheetxl/utils';
+import { IMovable } from '../movable';
+import { IWorksheet } from '../sheet';
+import { Movable } from '../movable/Movable';
+/**
+ * Where a note's box goes when nothing has moved it, and how a note stores where its box is.
+ *
+ * @remarks
+ * The default is Excel's, probed with hidden COM on a 96-DPI machine (2026-09-30): a 144×79 px
+ * box hung 15 px right of its cell and 10 px above its top, flipped to the other side when it
+ * would pass the sheet's last column or row. A note on a merged cell hangs beside the merge
+ * (probed 2026-10-20). It is pixel geometry first and the cells those
+ * pixels fall on second, so tall, narrow and hidden rows and columns need no rule of their own.
+ *
+ * A note stores its box's anchor with the cells counted from the note's own, so a note copied
+ * to another cell keeps its box beside it. The box itself is an ordinary movable anchored to the
+ * sheet's cells; these functions convert between the two.
+ * @internal
+ */
+/** The width of a default box, in pixels. */
+export declare const NOTE_DEFAULT_WIDTH = 144;
+/** The height of a default box, in pixels. */
+export declare const NOTE_DEFAULT_HEIGHT = 79;
+/**
+ * The cell geometry placing a box needs: the same three a movable is built with.
+ */
+export type NoteLayout = Required<Pick<Movable.ConstructorOptions, 'getBoundsAtCoords' | 'getCoordsAtBounds' | 'getMaxBounds'>>;
+/** The merge a cell is in, or `null` when it is in none. */
+export type MergeAt = (cell: IRange.CellCoords) => IRange.Coords | null;
+/** {@link MergeAt} through a sheet's cells, for once it has loaded. */
+export declare const sheetMergeAt: (sheet: IWorksheet) => MergeAt;
+/**
+ * The cells a note's box hangs beside: the note's cell, or the merge it anchors.
+ */
+export declare function noteBoxTarget(mergeAt: MergeAt, cell: IRange.CellCoords): IRange.Coords;
+/**
+ * The bounds of a note's box when nothing has moved or resized it.
+ *
+ * @param target The cells the box hangs beside, from {@link noteBoxTarget}.
+ */
+export declare function defaultNoteBounds(target: IRange.Coords, layout: NoteLayout): Bounds;
+/**
+ * Bounds measured from the sheet's top-left (as a file's VML `style` places a box with no anchor)
+ * in the layout's coordinates.
+ */
+export declare function sheetNoteBounds(bounds: Bounds, layout: NoteLayout): Bounds;
+/**
+ * The cells and offsets a box's corners fall on, as a movable is loaded from.
+ */
+export declare function boundsToAnchor(bounds: Bounds, layout: NoteLayout): IMovable.AnchorOffset;
+/**
+ * An anchor with its cells restated relative to the note's cell, which is how a note stores it.
+ */
+export declare function toRelativeAnchor(anchor: IMovable.AnchorOffset, cell: IRange.CellCoords): IMovable.AnchorOffset;
+/**
+ * A stored anchor with its cells restated as the sheet's, held to the sheet.
+ *
+ * @remarks
+ * A corner whose cell would be off the sheet is held to the sheet's edge; its offset is kept.
+ */
+export declare function toAbsoluteAnchor(anchor: IMovable.AnchorOffset, cell: IRange.CellCoords, entire: IRange.Coords): IMovable.AnchorOffset;
+/**
+ * Whether two boxes are drawn in the same place, to the pixel Excel rounds to.
+ */
+export declare function isEqualBounds(a: Bounds, b: Bounds): boolean;
+//# sourceMappingURL=_NoteBox.d.ts.map

package/types/src/comment/index.d.ts

@@ -1,2 +1,3 @@
 export * from './IComment';
+export * from './ICommentCollection';
 //# sourceMappingURL=index.d.ts.map

package/types/src/condition/AnchoredConditional.d.ts

@@ -2,21 +2,24 @@ import { IRange, IRuntime, Scalar } from '@sheetxl/primitives';
 import { MaybePromise } from '@sheetxl/utils';
 import { IListener } from '../listener';
 import { ITransaction } from '../transaction';
-import { ISparseGrid } from '../collections';
+import { Tuple, ISparseGrid } from '../collections';
 import { ICalculation } from '../calculation';
+import { FormulaHost } from '../calculation/grid';
 import { ICellRange, ICellRanges } from '../cellRange';
 import { ICondition } from '../condition';
+import { ConditionFormulaBinding } from '../condition/_ConditionFormula';
 import { IAnchored } from '../anchored';
 import { AbstractAnchored } from '../anchored/AbstractAnchored';
 import { Anchored } from '../anchored/Anchored';
+import * as _ConditionUtils from '../condition/_ConditionUtils';
 /**
  * Implementation of {@link IDataValidation}.
  */
-export declare abstract class AnchoredConditional<STATE extends AnchoredConditional.State, VIEW extends AnchoredConditional.CommitView = AnchoredConditional.CommitView, EVENTS extends ICondition.Events = ICondition.Events, JSON = any> extends AbstractAnchored<STATE, VIEW, EVENTS> implements IAnchored, ITransaction.ITransactional, IListener.ISource<IAnchored> {
+export declare abstract class AnchoredConditional<STATE extends AnchoredConditional.State, EVENTS extends ICondition.Events = ICondition.Events, JSON = any> extends AbstractAnchored<STATE, EVENTS> implements IAnchored, ITransaction.ITransactional, IListener.ISource<IAnchored> {
     protected _rangeListener: ICellRange.Listener | null;
     protected _getValueGrid: () => ISparseGrid<Scalar>;
     /**
-     * One registered watch per formula the condition asked for, keyed by expression: its remove, and
+     * One registered watch per formula the condition asked for, keyed by the formula: its remove, and
      * the values delivered so far, indexed by anchored area.
      *
      * @remarks
@@ -26,10 +29,16 @@ export declare abstract class AnchoredConditional<STATE extends AnchoredConditio
      * the difference between a new formula-valued operator working automatically and needing this
      * class edited to know about it.
      */
-    protected _conditionWatches: Map<string, WatchEntry>;
+    protected _conditionWatches: Map<ICalculation.IFormula | string, WatchEntry>;
+    /** What this rule's condition formulas compile with — see {@link _getFormulaBinding}. */
+    protected _formulaBinding: ConditionFormulaBinding | undefined;
     /**
      * The area marked stale since the last flush: `undefined` = nothing, `null` = the whole rule,
      * a range = just that part. See {@link _markValueUpdates}.
+     *
+     * NO initializers, for the same reason as {@link _rangeListener}: `_initialize` marks the rule
+     * from the base constructor, and an initializer would then reset both, so the flush already
+     * queued finds nothing marked and the first evaluation never runs.
      */
     protected _markedValueRange: ICellRange | null | undefined;
     protected _valueUpdatesScheduled: boolean;
@@ -37,8 +46,29 @@ export declare abstract class AnchoredConditional<STATE extends AnchoredConditio
     protected abstract _getActionDescription(action: 'delete' | 'initialize' | 'updateListener'): string | null;
     /** @internal */
     protected abstract _getType(): string;
-    /** @internal */
-    protected abstract _processValueUpdates(range: ICellRange | null): void;
+    /**
+     * Re-judges the rule after a change.
+     *
+     * @returns What the re-judging awaits, when it does: counted as calculation in flight until it
+     * settles (see `ICalculation.waitUntil`).
+     * @internal
+     */
+    protected abstract _processValueUpdates(range: ICellRange | null): void | Promise<void>;
+    /**
+     * Whether this rule's formula watches evaluate a blank region the answer of which depends on
+     * the position only where the rule is read (`WatchAnchor.Options.paged`): a cell not read yet
+     * has no answer and judges as no match until its tile is delivered. Right for a rule read a
+     * window at a time - a format, painted where it is on screen - and not for one whose every
+     * answer is wanted at once.
+     * @internal
+     */
+    protected _pagesWatches(): boolean;
+    /**
+     * Whether every formula watch of this rule holds its answer at a cell of the area at
+     * `areaIndex`, asking for the cell where one does not (see `FormulaHost.request`).
+     * @internal
+     */
+    protected _requestWatchedCell(areaIndex: number, row: number, column: number): boolean;
     /** @internal */
     protected abstract _fromJSON(json: JSON | undefined, options?: ITransaction.OperationOptions): void;
     /** @internal */
@@ -75,10 +105,11 @@ export declare abstract class AnchoredConditional<STATE extends AnchoredConditio
      *
      * Registered through `ICellRanges.addWatch`, which fills the expression to every area — a rule
      * over `'C19:C23 C3:C7'` reads different cells in its second area, and only the filled form knows
-     * which. The delivery re-runs the rule; the pass after it has values.
+     * which. The delivery re-runs the rule; the pass after it has values. Evaluated as a rule's
+     * formula is (`arrayFirstCell`): each cell an array-entered formula over itself.
      * @internal
      */
-    protected _watchConditionFormula(ranges: ICellRanges, expression: string, areaIndex: number, used: Set<string>): MaybePromise<IRange | null>;
+    protected _watchConditionFormula(ranges: ICellRanges, formula: ICalculation.IFormula | string, areaIndex: number, used: Set<ICalculation.IFormula | string>): MaybePromise<IRange | null>;
     /**
      * Drops watches nothing asked for during the evaluation that just finished.
      *
@@ -88,7 +119,7 @@ export declare abstract class AnchoredConditional<STATE extends AnchoredConditio
      * the pass and pruning after is what closes that.
      * @internal
      */
-    protected _pruneConditionWatches(used: Set<string>): void;
+    protected _pruneConditionWatches(used: Set<ICalculation.IFormula | string>): void;
     /** @internal */
     protected _removeConditionWatches(): void;
     /**
@@ -100,13 +131,35 @@ export declare abstract class AnchoredConditional<STATE extends AnchoredConditio
      * resolve. They resolve to `null` — "no values", which reads as an inert condition.
      * @internal
      */
-    protected _removeConditionWatch(entry: WatchEntry): void;
+    protected _removeConditionWatch(formula: ICalculation.IFormula | string, entry: WatchEntry): void;
     /** @internal */
     protected _processClose(): void;
+    /**
+     * An undo or redo can hand back a different condition while no value changes, so no range
+     * listener fires to re-derive the results. Heard here, not in `_processRestoreOrRevert`: that
+     * is told of every record in the store on every undo, this only of the ones the undo changed.
+     * @internal
+     */
+    protected _processAfterStateChange(state: STATE, commit: ITransaction.ICommit, isRevert?: boolean, isRestore?: boolean): void;
     /** @internal */
     protected _processAnchorCoords(): void;
+    /**
+     * Set while the container is shifting or deleting this rule, so {@link _processAnchorCoords}
+     * leaves the listener alone.
+     *
+     * @remarks
+     * Both run INSIDE the anchored map's own pass. The listener's reference lives in a map of the
+     * same kind and is moved (or dropped) by the same pass, so there is nothing to re-register - and
+     * reaching into a map that is mid-shift to do it is what used to throw.
+     * @internal
+     */
+    protected _isContainerShifting: boolean;
+    /** @internal */
+    protected _processContainerDelete(): void;
     /** @internal */
     protected _processContainerShift(options: Anchored.ShiftOptions): IRange.Coords | null | void;
+    /** @internal */
+    protected _doProcessContainerShift(options: Anchored.ShiftOptions): IRange.Coords | null | void;
     /**
      * Whether the anchor is absolute. See {@link AbstractAnchored._isAnchorAbsolute}.
      *
@@ -132,11 +185,19 @@ export declare abstract class AnchoredConditional<STATE extends AnchoredConditio
     setIndex(index: number): this;
     /** {@inheritDoc ICondition.Stateful.getCondition} */
     getCondition(): Readonly<ICondition> | null;
+    /**
+     * The engine and anchor this rule's condition formulas compile with: the rule's calculation, at
+     * the top-left of the bounding box of its ranges.
+     * @internal
+     */
+    protected _getFormulaBinding(): ConditionFormulaBinding;
+    /** @internal */
+    protected _bindConditionFormulas(condition: ICondition | null): void;
     /** {@inheritDoc IDataValidation.setCondition} */
     setCondition(condition: ICondition.Input | ICondition.Predicate | string | null, options?: ITransaction.OperationOptions): this;
     /**
-     * Rewrites the condition's anchor-relative formulas after the anchor cell (the first
-     * range's top-left) moves — fill semantics: relative references follow the anchor,
+     * Rewrites the condition's anchor-relative formulas after the anchor cell (the top-left of
+     * the bounding box of every range) moves — fill semantics: relative references follow the anchor,
      * absolute ones stay put. Excel does the same when extending a rule's applies-to moves
      * its origin: `G5>5` on `F5:F10` becomes `G1>5` when the rule grows to `F1:F10`.
      *
@@ -214,8 +275,6 @@ export declare abstract class AnchoredConditional<STATE extends AnchoredConditio
      * @internal
      */
     protected _shiftFormulaText(text: string, from: IRange.CellCoords, to: IRange.CellCoords): string | null;
-    /** {@inheritDoc ICondition.createDefaultCondition} */
-    createDefaultCondition(): ICondition;
     /** {@inheritDoc ICondition.Stateful.apply} */
     apply(): void;
     /**
@@ -229,21 +288,56 @@ export declare abstract class AnchoredConditional<STATE extends AnchoredConditio
      * be answered from a single cell's value.
      */
     protected _evalConditionRanges(handlers: {
-        onTrue?: (coords: IRange.CellCoords, value: Scalar) => void;
-        onFalse?: (coords: IRange.CellCoords, value: Scalar) => void;
+        /** `area` is the anchored area the cell belongs to — see {@link AreaResultCollector}. */
+        onTrue?: (coords: IRange.CellCoords, value: Scalar, area: IRange.Coords) => void;
+        onFalse?: (coords: IRange.CellCoords, value: Scalar, area: IRange.Coords) => void;
+        /**
+         * The answer for the BLANK cells of one anchored area, once per area — see
+         * `DoRunConditionsOptions.onBlank`. `area` is that area's coords, so a caller keeping the
+         * resolver can tell which cells it answers for.
+         */
+        onBlank?: (resolve: _ConditionUtils.BlankResolver, area: IRange.Coords) => void;
+        /** {@inheritDoc DoRunConditionsOptions.spacesAreBlank} */
+        spacesAreBlank?: boolean;
     }): Promise<void>;
     get [Symbol.toStringTag](): string;
     toString(): string;
 }
+/**
+ * Collects a rule's per-cell `true` results across its anchored areas into one grid.
+ *
+ * @remarks
+ * One tuple builder PER AREA. A builder takes cells in axis order, and a rule's areas are in
+ * authored order, not axis order — Excel writes `C3 C1` when it merges identical rules on save —
+ * and two areas can interleave on the major axis besides. One builder across all of them throws
+ * on the first area that runs backwards.
+ * @internal
+ */
+export declare class AreaResultCollector {
+    protected _isColumn: boolean;
+    protected _regions: Tuple.GridTuple<boolean>[];
+    protected _builder: Tuple.IBuilder<boolean> | null;
+    protected _area: IRange.Coords | null;
+    constructor(isColumn: boolean);
+    /** Adds a cell. Cells of one area arrive together, in axis order. */
+    push(coords: IRange.CellCoords, area: IRange.Coords): void;
+    /** The collected cells, or `null` when none were pushed. */
+    build(axis: IRange.Axis): ISparseGrid<boolean> | null;
+    protected _flush(): void;
+}
 /**
  * One registered formula watch: its remove, the values delivered per area, and any resolver still
  * waiting on an area's first delivery.
  */
 interface WatchEntry {
     remove: IListener.Remove;
+    /** The areas the watch was registered over, as an address: a rule reshaped since asks again. */
+    areas: string;
     values: (IRange | null)[];
     /** Resolvers waiting on an area's first delivery — a LIST: passes overlap, and each has its own. */
     pending: (((values: IRange | null) => void)[])[];
+    /** Each area's host, once registered: what a paged watch is asked for cells through. */
+    hosts: (FormulaHost | undefined)[];
 }
 /**
  * Tables are designed to be instantiated as both standalone and anchored items that represent a table of data on a sheet.
@@ -275,9 +369,6 @@ export declare namespace AnchoredConditional {
         condition: ICondition | null;
         removeListener: IListener.Remove | null;
     }
-    /** @internal */
-    interface CommitView extends AbstractAnchored.CommitView {
-    }
 }
 export {};
 //# sourceMappingURL=AnchoredConditional.d.ts.map

package/types/src/condition/BuiltInOperators/AbstractOperator.d.ts

@@ -1,5 +1,6 @@
 import { InteropScalarType, IRange, Scalar } from '@sheetxl/primitives';
 import { MaybePromise } from '@sheetxl/utils';
+import { ICalculation } from '../../calculation';
 import { ICondition } from '../ICondition';
 /**
  * Reads a comparison operand's value at the cell being evaluated. Built once per
@@ -20,14 +21,12 @@ export declare abstract class AbstractOperator<P> implements ICondition.IOperato
     getName(): string;
     /** {@inheritDoc ICondition.IOperator.getAcceptsTypes} */
     getAcceptsTypes(): readonly (InteropScalarType | null)[] | null;
-    /** {@inheritDoc ICondition.IOperator.acceptsList} */
-    acceptsList(): boolean;
     /** {@inheritDoc ICondition.IOperator.getParamType} */
     getParamType(lhsSelector?: ICondition.ISelector): string | null;
     /** {@inheritDoc ICondition.IOperator.isCombinator} */
     isCombinator(): boolean;
     /** {@inheritDoc ICondition.IOperator.createDefaultParam} */
-    createDefaultParam(lhsSelector?: ICondition.ISelector): P | null | undefined;
+    createDefaultParam(lhsSelector?: ICondition.ISelector, context?: ICondition.DefaultConditionContext): P | null | undefined;
     /**
      * {@inheritDoc ICondition.IOperator.getTitle}
      *
@@ -42,8 +41,8 @@ export declare abstract class AbstractOperator<P> implements ICondition.IOperato
     /** {@inheritDoc ICondition.doBatch} */
     doBatch(keys: Set<any>, param: P, ctx: ICondition.IContext): MaybePromise<IRange<boolean> | null>;
     /**
-     * Resolves a comparison operand that may be formula-valued — a string param with a leading `=`,
-     * the Scalar-param convention — into a per-cell {@link OperandReader}.
+     * Resolves a comparison operand that may be formula-valued — an {@link ICalculation.IFormula}, or
+     * a string param with a leading `=` — into a per-cell {@link OperandReader}.
      *
      * @returns The reader, or `null` when the operand is a formula with nothing to read (no engine,
      * an empty expression) — the caller returns a `null` predicate and the condition is inert
@@ -57,18 +56,49 @@ export declare abstract class AbstractOperator<P> implements ICondition.IOperato
      * same code path.
      *
      * A per-cell value that is an ERROR is returned as the error — comparisons must treat it as
-     * no-match, never a throw — and warns once per predicate build. A value that is a RANGE (a
-     * reference operand) takes its top-left: Excel does NOT implicitly intersect here (`$E$5:$F$6>10`
-     * tested `E5` for every cell; measured 2026-08-21).
+     * no-match, never a throw — and warns once per predicate build. A reference operand reads its
+     * top-left: Excel does NOT implicitly intersect here (`$E$5:$F$6>10` tested `E5` for every cell;
+     * measured 2026-08-21), which is the watch's `arrayFirstCell` evaluation.
      */
-    protected _resolveOperand(param: Scalar | undefined, ctx: ICondition.IContext): Promise<OperandReader | null>;
+    protected _resolveOperand(param: Scalar | ICalculation.IFormula | undefined, ctx: ICondition.IContext): Promise<OperandReader | null>;
+    /**
+     * Whether a comparison operand has not been given: absent, or blank text.
+     *
+     * @remarks
+     * A comparison missing an operand is inert, never a comparison against 0. Excel reads a rule
+     * whose `<formula>` is absent or empty that way — a validation flags nothing, a format paints
+     * nothing (measured, `probe-dv-operands` and `probe-cf-operands`) — and its dialogs refuse to
+     * author one.
+     */
+    protected _isMissingOperand(param: Scalar | ICalculation.IFormula | undefined): boolean;
+    /**
+     * The first problem with a comparison operand under `lhsSelector`, as a message key, or `null`.
+     *
+     * @param allowEmptyText Whether `''` is an operand (equal to empty text) rather than one not given.
+     *
+     * @remarks
+     * The rules Excel's dialogs refuse on (measured, `probe-dv-operands`): an operand is required; a
+     * whole-number rule takes an integer, a text-length rule a non-negative integer, a date a serial
+     * from 0, a time a serial in [0, 1); text where a number belongs is refused; a formula must parse.
+     * With no selector (a format's Cell Value rule) any scalar is an operand — Excel accepts text there.
+     */
+    protected _validateOperand(param: Scalar | ICalculation.IFormula | undefined, lhsSelector: ICondition.ISelector | null | undefined, allowEmptyText?: boolean): string | null;
     /**
      * The shared predicate shape of the ordered comparisons (`greaterThan` … `before`): resolve the
      * operand (formula or literal — see {@link _resolveOperand}), then compare per cell. An ERROR
-     * operand never matches; a `null` return means the operand could not resolve and the condition
-     * is inert.
+     * operand never matches; a `null` return means the operand is missing
+     * ({@link _isMissingOperand}) or could not resolve, and the condition is inert.
+     *
+     * An empty cell arrives as `null` and compares as 0, which is how Excel judges one (measured,
+     * `probe-dv-blank`).
+     */
+    protected _createComparePredicate(param: Scalar | ICalculation.IFormula | undefined, ctx: ICondition.IContext, compare: (value: number, operand: number) => boolean): Promise<ICondition.Predicate | null>;
+    /**
+     * An operand as a rule's text reads it: a date or time serial as the date or time it is,
+     * under a selector that reads one (`34995` is `10/23/1995` under Date); anything else as it is.
+     * The host locale is not known here, so the format is the en-US short form.
      */
-    protected _createComparePredicate(param: Scalar | undefined, ctx: ICondition.IContext, compare: (value: number, operand: number) => boolean): Promise<ICondition.Predicate | null>;
+    protected _operandText(value: Scalar | ICalculation.IFormula | undefined, lhsSelector?: ICondition.ISelector | null): unknown;
     /** {@inheritDoc ICondition.IOperator.toString} */
     toString(param?: P, lhsSelector?: ICondition.ISelector): string | undefined;
 }

package/types/src/condition/BuiltInOperators/AfterEqualToOperator.d.ts

@@ -4,5 +4,7 @@ export declare class AfterEqualToOperator extends AbstractOperator<number | stri
     constructor();
     /** {@inheritDoc ICondition.IOperator.createPredicate} */
     createPredicate(param: number | string, ctx: ICondition.IContext): Promise<ICondition.Predicate | null>;
+    /** {@inheritDoc ICondition.IOperator.validateParam} */
+    validateParam(param: number | string, lhsSelector?: ICondition.ISelector | null): string | null;
 }
 //# sourceMappingURL=AfterEqualToOperator.d.ts.map

package/types/src/condition/BuiltInOperators/AfterOperator.d.ts

@@ -4,5 +4,7 @@ export declare class AfterOperator extends AbstractOperator<number | string> imp
     constructor();
     /** {@inheritDoc ICondition.IOperator.createPredicate} */
     createPredicate(param: number | string, ctx: ICondition.IContext): Promise<ICondition.Predicate | null>;
+    /** {@inheritDoc ICondition.IOperator.validateParam} */
+    validateParam(param: number | string, lhsSelector?: ICondition.ISelector | null): string | null;
 }
 //# sourceMappingURL=AfterOperator.d.ts.map

package/types/src/condition/BuiltInOperators/AndOperator.d.ts

@@ -5,7 +5,9 @@ export declare class AndOperator extends AbstractOperator<readonly ICondition.In
     /** {@inheritDoc ICondition.IOperator.isCombinator} */
     isCombinator(): boolean;
     /** {@inheritDoc ICondition.IOperator.createPredicate} */
-    createPredicate(param: readonly ICondition.Input[], ctx: ICondition.IContext): Promise<ICondition.Predicate>;
+    createPredicate(param: readonly ICondition.Input[], ctx: ICondition.IContext): Promise<ICondition.Predicate | null>;
+    /** {@inheritDoc ICondition.IOperator.validateParam} */
+    validateParam(param: readonly ICondition.Input[], lhsSelector?: ICondition.ISelector | null): string | null;
     /** {@inheritDoc ICondition.IOperator.toString} */
     toString(param?: readonly ICondition.Input[], lhsSelector?: ICondition.ISelector): string | undefined;
 }

package/types/src/condition/BuiltInOperators/AverageOperator.d.ts

@@ -4,6 +4,8 @@ export declare class AverageOperator extends AbstractOperator<ICondition.Average
     constructor();
     /** {@inheritDoc ICondition.IOperator.createPredicate} */
     createPredicate(param: ICondition.AverageOption, ctx: ICondition.IContext): Promise<ICondition.Predicate>;
+    /** {@inheritDoc ICondition.IOperator.validateParam} */
+    validateParam(param: ICondition.AverageOption, lhsSelector?: ICondition.ISelector | null): string | null;
     /** {@inheritDoc ICondition.IOperator.createDefaultParam} */
     createDefaultParam(lhsSelector?: ICondition.ISelector): ICondition.AverageOption;
     /** {@inheritDoc ICondition.IOperator.toString} */

package/types/src/condition/BuiltInOperators/BeforeEqualToOperator.d.ts

@@ -4,5 +4,7 @@ export declare class BeforeEqualToOperator extends AbstractOperator<number | str
     constructor();
     /** {@inheritDoc ICondition.IOperator.createPredicate} */
     createPredicate(param: number | string, ctx: ICondition.IContext): Promise<ICondition.Predicate | null>;
+    /** {@inheritDoc ICondition.IOperator.validateParam} */
+    validateParam(param: number | string, lhsSelector?: ICondition.ISelector | null): string | null;
 }
 //# sourceMappingURL=BeforeEqualToOperator.d.ts.map

package/types/src/condition/BuiltInOperators/BeforeOperator.d.ts

@@ -4,5 +4,7 @@ export declare class BeforeOperator extends AbstractOperator<number | string> im
     constructor();
     /** {@inheritDoc ICondition.IOperator.createPredicate} */
     createPredicate(param: number | string, ctx: ICondition.IContext): Promise<ICondition.Predicate | null>;
+    /** {@inheritDoc ICondition.IOperator.validateParam} */
+    validateParam(param: number | string, lhsSelector?: ICondition.ISelector | null): string | null;
 }
 //# sourceMappingURL=BeforeOperator.d.ts.map

package/types/src/condition/BuiltInOperators/BetweenOperator.d.ts

@@ -6,6 +6,8 @@ export declare class BetweenOperator extends AbstractOperator<ICondition.Between
     createPredicate(param: ICondition.BetweenOption, ctx: ICondition.IContext): Promise<ICondition.Predicate | null>;
     /** {@inheritDoc ICondition.IOperator.createDefaultParam} */
     createDefaultParam(lhsSelector?: ICondition.ISelector): ICondition.BetweenOption;
+    /** {@inheritDoc ICondition.IOperator.validateParam} */
+    validateParam(param: ICondition.BetweenOption, lhsSelector?: ICondition.ISelector | null): string | null;
     /** {@inheritDoc ICondition.IOperator.toString} */
     toString(param?: ICondition.BetweenOption, lhsSelector?: ICondition.ISelector): string | undefined;
 }

package/types/src/condition/BuiltInOperators/ColorOperator.d.ts

@@ -1,5 +1,9 @@
 import { ICondition } from '../ICondition';
 import { AbstractOperator } from './AbstractOperator';
+/**
+ * Filter by cell or font color. Carried and written back; not evaluated until a condition can
+ * read a cell's style, so applying one throws.
+ */
 export declare class ColorOperator extends AbstractOperator<ICondition.ColorOption> implements ICondition.IOperator<ICondition.ColorOption> {
     constructor();
     /** {@inheritDoc ICondition.IOperator.createPredicate} */

package/types/src/condition/BuiltInOperators/ContainsOperator.d.ts

@@ -4,5 +4,7 @@ export declare class ContainsOperator extends AbstractOperator<string> implement
     constructor();
     /** {@inheritDoc ICondition.IOperator.createPredicate} */
     createPredicate(param: string, ctx: ICondition.IContext): ICondition.Predicate;
+    /** {@inheritDoc ICondition.IOperator.validateParam} */
+    validateParam(param: string, lhsSelector?: ICondition.ISelector | null): string | null;
 }
 //# sourceMappingURL=ContainsOperator.d.ts.map

package/types/src/condition/BuiltInOperators/EndsWithOperator.d.ts

@@ -4,5 +4,7 @@ export declare class EndsWithOperator extends AbstractOperator<string> implement
     constructor();
     /** {@inheritDoc ICondition.IOperator.createPredicate} */
     createPredicate(param: string, ctx: ICondition.IContext): ICondition.Predicate;
+    /** {@inheritDoc ICondition.IOperator.validateParam} */
+    validateParam(param: string, lhsSelector?: ICondition.ISelector | null): string | null;
 }
 //# sourceMappingURL=EndsWithOperator.d.ts.map

package/types/src/condition/BuiltInOperators/EqualToOperator.d.ts

@@ -1,10 +1,13 @@
 import { Scalar } from '@sheetxl/primitives';
+import { ICalculation } from '../../calculation';
 import { ICondition } from '../ICondition';
 import { AbstractOperator } from './AbstractOperator';
 export declare class EqualToOperator extends AbstractOperator<Scalar> implements ICondition.IOperator<Scalar> {
     constructor();
     /** {@inheritDoc ICondition.IOperator.createPredicate} */
-    createPredicate(param: Scalar, ctx: ICondition.IContext): Promise<ICondition.Predicate | null>;
+    createPredicate(param: Scalar | ICalculation.IFormula, ctx: ICondition.IContext): Promise<ICondition.Predicate | null>;
+    /** {@inheritDoc ICondition.IOperator.validateParam} */
+    validateParam(param: Scalar | ICalculation.IFormula, lhsSelector?: ICondition.ISelector | null): string | null;
     /** {@inheritDoc ICondition.IOperator.createDefaultParam} */
     createDefaultParam(lhsSelector?: ICondition.ISelector): Scalar | undefined;
 }

package/types/src/condition/BuiltInOperators/ExpressionOperator.d.ts

@@ -1,17 +1,16 @@
+import { ICalculation } from '../../calculation';
 import { ICondition } from '../ICondition';
 import { AbstractOperator } from './AbstractOperator';
 /**
  * Evaluates a formula expression against the value of the cell.
  */
-export declare class ExpressionOperator extends AbstractOperator<string> implements ICondition.IOperator<string> {
+export declare class ExpressionOperator extends AbstractOperator<ICalculation.IFormula | string> implements ICondition.IOperator<ICalculation.IFormula | string> {
     constructor();
+    /** {@inheritDoc ICondition.IOperator.validateParam} */
+    validateParam(param: ICalculation.IFormula | string, lhsSelector?: ICondition.ISelector | null): string | null;
     /** {@inheritDoc ICondition.IOperator.createDefaultParam} */
     createDefaultParam(lhsSelector?: ICondition.ISelector): string;
     /** {@inheritDoc ICondition.IOperator.createPredicate} */
-    createPredicate(param: string, ctx: ICondition.IContext): Promise<ICondition.Predicate | null>;
+    createPredicate(param: ICalculation.IFormula | string, ctx: ICondition.IContext): Promise<ICondition.Predicate | null>;
 }
-/**
- * Creates a temporary range. This is for illustrations only.
- */
-export declare const ExpressionRuleAccumulate: ICondition.IOperator<string>;
 //# sourceMappingURL=ExpressionOperator.d.ts.map

package/types/src/condition/BuiltInOperators/GreaterThanEqualToOperator.d.ts

@@ -4,5 +4,7 @@ export declare class GreaterThanEqualToOperator extends AbstractOperator<number
     constructor();
     /** {@inheritDoc ICondition.IOperator.createPredicate} */
     createPredicate(param: number | string, ctx: ICondition.IContext): Promise<ICondition.Predicate | null>;
+    /** {@inheritDoc ICondition.IOperator.validateParam} */
+    validateParam(param: number | string, lhsSelector?: ICondition.ISelector | null): string | null;
 }
 //# sourceMappingURL=GreaterThanEqualToOperator.d.ts.map

package/types/src/condition/BuiltInOperators/GreaterThanOperator.d.ts

@@ -4,5 +4,7 @@ export declare class GreaterThanOperator extends AbstractOperator<number | strin
     constructor();
     /** {@inheritDoc ICondition.IOperator.createPredicate} */
     createPredicate(param: number | string, ctx: ICondition.IContext): Promise<ICondition.Predicate | null>;
+    /** {@inheritDoc ICondition.IOperator.validateParam} */
+    validateParam(param: number | string, lhsSelector?: ICondition.ISelector | null): string | null;
 }
 //# sourceMappingURL=GreaterThanOperator.d.ts.map

package/types/src/condition/BuiltInOperators/IconOperator.d.ts

@@ -1,5 +1,9 @@
 import { ICondition } from '../ICondition';
 import { AbstractOperator } from './AbstractOperator';
+/**
+ * Filter by conditional-format icon. Carried and written back; not evaluated until a condition
+ * can read a cell's decorations, so applying one throws.
+ */
 export declare class IconOperator extends AbstractOperator<ICondition.IconOption> implements ICondition.IOperator<ICondition.IconOption> {
     constructor();
     /** {@inheritDoc ICondition.IOperator.createPredicate} */

package/types/src/condition/BuiltInOperators/InSetOperator.d.ts

@@ -1,13 +1,30 @@
+import { Scalar } from '@sheetxl/primitives';
+import { MaybePromise } from '@sheetxl/utils';
 import { ICondition } from '../ICondition';
 import { AbstractOperator } from './AbstractOperator';
 export declare class InSetOperator extends AbstractOperator<ICondition.InSetOption> implements ICondition.IOperator<ICondition.InSetOption> {
     constructor();
-    /** {@inheritDoc ICondition.IOperator.acceptsList} */
-    acceptsList(): boolean;
     /** {@inheritDoc ICondition.IOperator.createPredicate} */
-    createPredicate(param: ICondition.InSetOption, ctx: ICondition.IContext): ICondition.Predicate;
-    /** {@inheritDoc ICondition.IOperator.createDefaultParam} */
-    createDefaultParam(lhsSelector?: ICondition.ISelector): ICondition.InSetOption;
+    createPredicate(param: ICondition.InSetOption, ctx: ICondition.IContext): ICondition.Predicate | Promise<ICondition.Predicate | null>;
+    /** {@inheritDoc ICondition.IOperator.validateParam} */
+    validateParam(param: ICondition.InSetOption, lhsSelector?: ICondition.ISelector | null): string | null;
+    /**
+     * {@inheritDoc ICondition.IOperator.getCandidates}
+     *
+     * @remarks
+     * `items`, then what the `source` lists (with a context to evaluate it in), then `additions`,
+     * less `subtractions`: the parts in the order the author gave them. A date group is an
+     * interval and lists nothing.
+     */
+    getCandidates(param: ICondition.InSetOption, ctx?: ICondition.IContext | null): MaybePromise<readonly Scalar[] | null>;
+    /**
+     * {@inheritDoc ICondition.IOperator.createDefaultParam}
+     *
+     * @remarks
+     * The distinct values already in the cells, sorted as a filter lists them, when there are a
+     * few; otherwise no items. Read through the range's stats.
+     */
+    createDefaultParam(lhsSelector?: ICondition.ISelector, context?: ICondition.DefaultConditionContext): ICondition.InSetOption;
     /** {@inheritDoc ICondition.IOperator.toString} */
     toString(param?: ICondition.InSetOption, lhsSelector?: ICondition.ISelector): string | undefined;
 }

package/types/src/condition/BuiltInOperators/LessThanEqualToOperator.d.ts

@@ -4,5 +4,7 @@ export declare class LessThanEqualToOperator extends AbstractOperator<number | s
     constructor();
     /** {@inheritDoc ICondition.IOperator.createPredicate} */
     createPredicate(param: number | string, ctx: ICondition.IContext): Promise<ICondition.Predicate | null>;
+    /** {@inheritDoc ICondition.IOperator.validateParam} */
+    validateParam(param: number | string, lhsSelector?: ICondition.ISelector | null): string | null;
 }
 //# sourceMappingURL=LessThanEqualToOperator.d.ts.map

package/types/src/condition/BuiltInOperators/LessThanOperator.d.ts

@@ -4,5 +4,7 @@ export declare class LessThanOperator extends AbstractOperator<number | string>
     constructor();
     /** {@inheritDoc ICondition.IOperator.createPredicate} */
     createPredicate(param: number | string, ctx: ICondition.IContext): Promise<ICondition.Predicate | null>;
+    /** {@inheritDoc ICondition.IOperator.validateParam} */
+    validateParam(param: number | string, lhsSelector?: ICondition.ISelector | null): string | null;
 }
 //# sourceMappingURL=LessThanOperator.d.ts.map

package/types/src/condition/BuiltInOperators/NotOperator.d.ts

@@ -6,6 +6,8 @@ export declare class NotOperator extends AbstractOperator<ICondition.Input> impl
     isCombinator(): boolean;
     /** {@inheritDoc ICondition.IOperator.createPredicate} */
     createPredicate(param: ICondition.Input, ctx: ICondition.IContext): Promise<ICondition.Predicate | null>;
+    /** {@inheritDoc ICondition.IOperator.validateParam} */
+    validateParam(param: ICondition.Input, lhsSelector?: ICondition.ISelector | null): string | null;
     /** {@inheritDoc ICondition.IOperator.toString} */
     toString(param?: ICondition.Input, lhsSelector?: ICondition.ISelector): string | undefined;
 }