@sheetxl/sdk 0.7.28-beta.4 → 0.8.0-beta.10

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

@@ -2,21 +2,23 @@ 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 { 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 +28,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;
@@ -75,10 +83,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 +97,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 +109,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 +163,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 +253,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,12 +266,43 @@ 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.
@@ -275,9 +343,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;
 }

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

@@ -5,7 +5,9 @@ export declare class OrOperator extends AbstractOperator<readonly ICondition.Inp
     /** {@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/StartsWithOperator.d.ts

@@ -4,5 +4,7 @@ export declare class StartsWithOperator extends AbstractOperator<string> impleme
     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=StartsWithOperator.d.ts.map

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

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

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

@@ -4,6 +4,12 @@ export declare class TopNOperator extends AbstractOperator<ICondition.TopNOption
     constructor();
     /** {@inheritDoc ICondition.IOperator.createPredicate} */
     createPredicate(param: ICondition.TopNOption, ctx: ICondition.IContext): ICondition.Predicate;
+    /**
+     * {@inheritDoc ICondition.IOperator.validateParam}
+     *
+     * Excel's Top 10 dialog takes 1 to 1000 items, or 1 to 100 percent.
+     */
+    validateParam(param: ICondition.TopNOption, lhsSelector?: ICondition.ISelector | null): string | null;
     /** {@inheritDoc ICondition.IOperator.createDefaultParam} */
     createDefaultParam(lhsSelector?: ICondition.ISelector): ICondition.TopNOption;
     /** {@inheritDoc ICondition.IOperator.toString} */

package/types/src/condition/BuiltinSelectors/BaseSelector.d.ts

@@ -1,14 +1,19 @@
 import { InteropScalarType, Scalar } from '@sheetxl/primitives';
 import { MaybePromise } from '@sheetxl/utils';
 import { ICondition } from '../ICondition';
+/**
+ * A selector that gates and does not project: a value it accepts is read as itself, any other
+ * is {@link ICondition.NotApplicable}.
+ */
 export declare class BaseSelector<T extends Scalar = Scalar, I extends Scalar = T> implements ICondition.ISelector<T, I> {
     protected _name: string;
     protected _type: InteropScalarType | null;
     protected _inputType: InteropScalarType | null;
     protected _title: string | undefined;
     protected _description: string | undefined;
-    protected _renderingHints: readonly string[] | null;
-    constructor(options: ConstructorOptions);
+    protected _gate: ((value: I) => boolean) | null;
+    protected _defaultCondition: ICondition.DefaultCondition | null;
+    constructor(options: ConstructorOptions<I>);
     /** {@inheritDoc ICondition.ISelector.createTransformer} */
     createTransformer(ctx: ICondition.IContext): MaybePromise<ICondition.Transformer<T, I> | null>;
     /** {@inheritDoc ICondition.ISelector.getName} */
@@ -29,15 +34,25 @@ export declare class BaseSelector<T extends Scalar = Scalar, I extends Scalar =
     getTitle(): string;
     /** {@inheritDoc ICondition.ISelector.getDescription} — resolved at display; see {@link getTitle}. */
     getDescription(): string;
-    /** {@inheritDoc ICondition.ISelector.getRenderHints} */
-    getRenderHints(): readonly string[] | null;
+    /** {@inheritDoc ICondition.ISelector.getDefaultCondition} */
+    getDefaultCondition(_context?: ICondition.DefaultConditionContext): ICondition.DefaultCondition | null;
 }
-export interface ConstructorOptions {
+export interface ConstructorOptions<I extends Scalar = Scalar> {
     name: string;
     type: InteropScalarType | null;
     inputType?: InteropScalarType | null;
     title?: string;
     description?: string;
-    renderingHints?: string | string[];
+    /**
+     * The selector's domain: whether a (non-blank) value is of the kind it reads. Omitted, every
+     * value is.
+     */
+    gate?: (value: I) => boolean;
+    /**
+     * What {@link ICondition.ISelector.getDefaultCondition} returns.
+     */
+    defaultCondition?: ICondition.DefaultCondition | null;
 }
+/** A number: what Whole, Number, Date and Time read. A boolean is not one (DIFFERENCES-CONDITIONS §1). */
+export declare const isNumberValue: (value: Scalar) => boolean;
 //# sourceMappingURL=BaseSelector.d.ts.map