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

package/types/src/sheet/WorksheetCollection.d.ts

@@ -0,0 +1,39 @@
+import { ICollection, AbstractCollection } from '../type';
+import { IListener } from '../listener';
+import { IWorksheetCollection } from './IWorksheetCollection';
+import { IWorksheet } from './IWorksheet';
+import { ISheet } from './ISheet';
+/**
+ * Implementation for {@link IWorksheetCollection}.
+ *
+ * @remarks
+ * A front over the workbook's own sheet state — the workbook keeps the store and the events,
+ * this class keeps the API. `onCollectionChange` is the workbook's `onSheetsChange`, forwarded
+ * with this collection as the source.
+ */
+export declare class WorksheetCollection extends AbstractCollection<IWorksheet, IWorksheetCollection.GetItemsOptions> implements IWorksheetCollection {
+    private _add;
+    private _get;
+    private _addListeners;
+    private _getSelected;
+    constructor(add: (options: IWorksheetCollection.AddOptions | string | number) => IWorksheet, get: (name?: string, visibility?: ISheet.Visibility) => IWorksheet[], addListeners: (listeners: ICollection.IListeners, options?: IListener.Options) => IListener.Remove, getSelected: () => IWorksheet | null);
+    /** {@inheritDoc IWorksheetCollection.getActive} */
+    getActive(): IWorksheet | null;
+    /** {@inheritDoc IWorksheetCollection.getAt} */
+    getAt(index: number): IWorksheet | null;
+    /** {@inheritDoc IWorksheetCollection.getByIndex} */
+    getByIndex(index: number): IWorksheet | null;
+    /** {@inheritDoc IWorksheetCollection.getAll} */
+    getAll(): IWorksheet[];
+    /** {@inheritDoc IWorksheetCollection.add} */
+    add(options?: IWorksheetCollection.AddOptions | string | number): IWorksheet;
+    /** {@inheritDoc AbstractCollection._getItems} */
+    protected _getItems(options?: IWorksheetCollection.GetItemsOptions): IWorksheet[];
+    /** {@inheritDoc IWorksheetCollection.getByName} */
+    getByName(name: string): IWorksheet;
+    /** {@inheritDoc ICollection.addListeners} */
+    addListeners(listeners: ICollection.IListeners, options?: IListener.Options): IListener.Remove;
+    /** {@inheritDoc IWorksheetCollection.isIWorksheetCollection} */
+    get isIWorksheetCollection(): true;
+}
+//# sourceMappingURL=WorksheetCollection.d.ts.map

package/types/src/sheet/_Anomalies.d.ts

@@ -0,0 +1,109 @@
+import { IRange } from '@sheetxl/primitives';
+import { ICell } from '../cell';
+import { ISpatialMap, ISpatialQuery } from '../collections';
+import { ICellStyle, IStyleCollection } from '../style';
+import { IProperties } from '../type';
+import { IWorksheet } from './IWorksheet';
+import { IgnoredErrors } from './_IgnoredErrors';
+import { CellKind } from './_Kinds';
+/**
+ * The findings at a cell, interned per map: equal findings are one object, in rank order, so a
+ * region's payload identity is its content and the fragments of one finding regroup.
+ * @internal
+ */
+export type AnomalySet = readonly ICell.Anomaly[];
+type StyleMap = ISpatialQuery<IProperties.ICellRanged<ICellStyle.Properties>>;
+/** What the role layer is read from: a sheet's content and its formulas, as they are now. @internal */
+export interface RoleSource {
+    readonly sheet: IWorksheet;
+    /** The extent the checks run over; `null` for an empty sheet. */
+    readonly bounds: IRange.Coords | null;
+    /** What each cell holds (`ICellRange.Feature.Kind`). */
+    readonly kinds: ISpatialQuery<CellKind>;
+    readonly contentful: ISpatialQuery<unknown>;
+    readonly formulas: ISpatialQuery<unknown>;
+}
+/** What the checks read. Everything is the sheet as it is now; nothing here is written. @internal */
+export interface AnomalySource extends RoleSource {
+    /** Each cell's job (`ICellRange.Feature.Role`), the layer the pairing reads. */
+    readonly roles: ISpatialQuery<ICell.Role>;
+    /** The direct styles that carry font, number format and alignment. */
+    readonly contentStyles: StyleMap;
+    /** The direct fills. */
+    readonly fillStyles: StyleMap;
+    /** Where the named styles, Normal among them, are read. */
+    readonly styles: IStyleCollection;
+    readonly ignored: IgnoredErrors;
+    /** Excel draws no unlocked-formula indicator on a protected sheet. */
+    readonly isProtected: boolean;
+    /** The font colors the workbook's other sheets write their roles in ({@link roleColorsOf}). */
+    readonly workbookRoleColors: () => ReadonlySet<string>;
+}
+type Rect = IRange.Coords;
+/** @internal */
+export type Evidence = ICell.Anomaly['evidence'];
+/** One sheet's findings at their first-pass rank, before the workbook's repeats are counted. @internal */
+export interface AnomalyFindings {
+    readonly entries: readonly ISpatialMap.Entry<ICell.Anomaly>[];
+    /** For each repeat-ranked finding, its identity across sheets and the rectangles it holds here. */
+    readonly repeats: ReadonlyMap<ICell.Anomaly, {
+        readonly key: string;
+        readonly count: number;
+    }>;
+}
+/**
+ * The first pass: where the error checks fire on one sheet, each finding ranked alone.
+ *
+ * @remarks
+ * Every check reads the sheet's partitions and its formulas' references, at the altitude of a
+ * region: a formula region is one authored formula, so its references are a function of the
+ * cell's position, and the cells a check names are found by rectangle arithmetic against the
+ * partitions. No check reads a cell.
+ * @internal
+ */
+export declare function findAnomalies(source: AnomalySource): AnomalyFindings;
+/** How often each repeat-ranked finding occurs over the sheets given, by identity. @internal */
+export declare function repeatsOf(sheets: readonly AnomalyFindings[]): Map<string, number>;
+/**
+ * The second pass: one sheet's map, each repeat-ranked finding's rank divided by how often it
+ * occurs in the workbook (`repeats`), so the exception ranks above the pattern.
+ * @internal
+ */
+export declare function buildAnomalies(own: AnomalyFindings, repeats: ReadonlyMap<string, number>, ignored: IgnoredErrors): ISpatialMap<AnomalySet>;
+/** The findings so far, one rectangle list per distinct finding. @internal */
+export declare class _Findings {
+    private readonly _groups;
+    /** The rank of a check's finding before its evidence scales it. */
+    weightOf(check: ICell.ErrorCheck): number;
+    /** `rank` is a function of the check and the evidence, so one finding has one. */
+    add(check: ICell.ErrorCheck, evidence: Evidence, rect: Rect, rank?: number): void;
+    /**
+     * One entry per merged rectangle of each finding (a finding's rectangles may overlap), and the
+     * count of those rectangles for the repeat-ranked ones.
+     */
+    result(): AnomalyFindings;
+}
+/** A formula region: one authored formula over a rectangle. @internal */
+export interface FormulaRegion {
+    readonly coords: Rect;
+    /** The formula in R1C1, which is what agrees between two cells of one run. */
+    readonly r1c1: string;
+}
+/**
+ * The role layer (`ICellRange.Feature.Role`): the kind layer refined by what a formula reads and
+ * by who reads a cell. Typed cells are `label` (nothing reads them) or `input` (something does); a
+ * formula is a `link`, a `reference`, else `computed` where something reads it and `output` where
+ * nothing does. "Who reads it" is this sheet's own formulas (`referencesOf`); a reader on another
+ * sheet is not seen, so a cell only another sheet reads is a `label` or an `output` here.
+ * @internal
+ */
+export declare function buildRoles(source: RoleSource): ISpatialMap<ICell.Role>;
+/**
+ * The font colors a sheet's roles are written in: the plurality color of each role, typed cells'
+ * among them. A workbook's role colors are the union over its sheets, which is what tells the
+ * inputs' blue from a decorative red on a sheet whose own typed numbers are mostly black years.
+ * @internal
+ */
+export declare function roleColorsOf(source: AnomalySource): ReadonlySet<string>;
+export {};
+//# sourceMappingURL=_Anomalies.d.ts.map

package/types/src/sheet/_AnomalyFormulaChecks.d.ts

@@ -0,0 +1,125 @@
+import { IRange } from '@sheetxl/primitives';
+import { ICalculation } from '../calculation';
+import { SpatialMap } from '../collections';
+import { IWorksheet } from './IWorksheet';
+import { AnomalySource, FormulaRegion, RoleSource, _Findings } from './_Anomalies';
+type Node = ICalculation.FormulaNode;
+type Rect = IRange.Coords;
+type At = IRange.CellCoords;
+/**
+ * `repeatedReference`: the same cell or range counted twice in one sum — `SUM(F24:F29)+F25`,
+ * `N20-N23-N23-N26`. Two references overlap when they share a cell; they count twice when they
+ * carry the same sign, so `SUM(B2:B9)-B5` (taking one out) does not fire.
+ */
+export declare function checkRepeatedReference(source: AnomalySource, regions: readonly FormulaRegion[], findings: _Findings): void;
+/**
+ * `degenerateCall`: an aggregate that aggregates nothing — `AVERAGE(J96)` over one cell, or
+ * `SUM(360,365)` over typed numbers.
+ */
+export declare function checkDegenerateCall(source: AnomalySource, regions: readonly FormulaRegion[], findings: _Findings): void;
+/**
+ * `sumIncludesSubtotal`: a sum that holds a cell that is itself a sum of the sum's own cells
+ * (`SUM(F17:F21)` where F21 sums F17:F20; `=F21+F18` likewise), or a summed range holding a
+ * percent-formatted ratio (`=F19/F18`, a margin row inside a total). The cell may be on the sheet
+ * the sum reads. A ratio of a typed divisor (`=F3/12`) is an allocation and does not fire, nor
+ * does a ratio the sheet does not show as a percent (a per-unit line item).
+ */
+export declare function checkSumIncludesSubtotal(source: AnomalySource, regions: readonly FormulaRegion[], findings: _Findings): void;
+/**
+ * `misalignedReference`: a formula in the row that closes (or opens) its block sums the block and
+ * also adds a cell outside it — `=SUM(K51:K53)+J46`. A block is the contentful lines in the
+ * region's own columns (rows) between blank lines that span them; a row-wise total reads the
+ * same with the axes swapped. A term is aligned when it lands inside the block in the cell's own
+ * column. Only a sum with an aligned term fires, so a grand total of other blocks' totals does not;
+ * and only a term added the way an aligned one is, so `=D20-D18` (a deduction) does not.
+ */
+export declare function checkMisalignedReference(source: AnomalySource, regions: readonly FormulaRegion[], findings: _Findings): void;
+/**
+ * `approximateMatch`: a lookup that matches the nearest key rather than the key — `MATCH` with a
+ * type of `1` or `-1` or none, `VLOOKUP` / `HLOOKUP` without `FALSE`, `XMATCH` / `XLOOKUP` with a
+ * match mode of `1` or `-1`. Fires even on a sorted selector: the type is the fact. A type read
+ * from a cell is not known here and does not fire.
+ */
+export declare function checkApproximateMatch(source: AnomalySource, regions: readonly FormulaRegion[], findings: _Findings): void;
+/**
+ * `lookupShape`: a lookup whose two arrays do not line up — `INDEX(M30:M32,MATCH(x,L29:L31,0))`, or
+ * `XLOOKUP(x,L29:L31,M30:M32)`. The position found in one is read from the other, so a different
+ * start or end along the vector's axis reads the wrong line.
+ */
+export declare function checkLookupShape(source: AnomalySource, regions: readonly FormulaRegion[], findings: _Findings): void;
+/**
+ * `externalReference`: a formula that reads outside this workbook or nowhere — `[1]Sheet!A1` to
+ * another workbook (`kind: 'workbook'`), a `#REF!` left by a deletion (`'deleted'`), a function
+ * a converter wrapped as unknown (`_XLUDF.`, `'udf'`).
+ */
+export declare function checkExternalReference(source: AnomalySource, regions: readonly FormulaRegion[], findings: _Findings): void;
+/** One term of a sum: a reference, added (`1`) or taken away (`-1`). */
+export interface Leaf {
+    readonly node: Node;
+    readonly sign: 1 | -1;
+}
+/**
+ * Every sum in a tree, as the references it adds and takes away. A sum is a `SUM` or a run of
+ * `+` and `-`, with parentheses read through; anything else (`*`, `IF`, `AVERAGE`) ends it, and
+ * its arguments start sums of their own. A reference that is not summed (`AVERAGE(B2:B9)`,
+ * `INDEX(B2:B9,3)`) is in no sum.
+ * @internal
+ */
+export declare function additiveChains(root: Node): Leaf[][];
+/** Every node of a tree, the root first. @internal */
+export declare function nodesOf(root: Node): Generator<Node>;
+/** @internal */
+export declare function treeOf(sheet: IWorksheet, region: FormulaRegion): Node | null;
+/** A sheet's formula regions, indexed by where they lie. @internal */
+export interface SheetFormulas {
+    readonly sheet: IWorksheet;
+    readonly regions: readonly FormulaRegion[];
+    readonly index: SpatialMap<FormulaRegion>;
+}
+/**
+ * The sheets a build's references land on, by lower-case name: this one, and each other sheet of
+ * the workbook read once, as its formula partition.
+ * @internal
+ */
+export declare class _Sheets {
+    private readonly _source;
+    readonly own: string;
+    private readonly _formulas;
+    private readonly _sheets;
+    constructor(_source: AnomalySource, regions: readonly FormulaRegion[]);
+    /** The worksheet a reference's sheet name names, or `null` when the workbook has none. */
+    sheetOf(name: string): IWorksheet | null;
+    formulasOf(name: string): SheetFormulas | null;
+}
+/** The sheet reader of one build, shared by its checks. @internal */
+export declare function sheetsOf(source: AnomalySource, regions: readonly FormulaRegion[]): _Sheets;
+/** `SUM`, with the file format's `_xlfn.` / `_xlws.` spelling taken off. @internal */
+export declare const functionName: (node: Node) => string;
+/** @internal */
+export declare const firstCellOf: (region: FormulaRegion) => At;
+/**
+ * Where a fact found at a region's first cell holds: the whole region when it holds at its last
+ * cell as well, otherwise the first cell alone; `null` when it does not hold at the first cell.
+ * A filled formula moves every relative reference by the same step, so the two ends decide it.
+ * @internal
+ */
+export declare function extentOf(region: FormulaRegion, holds: (at: At) => boolean): Rect | null;
+/** A reference in R1C1, read from `at`, with its sheet when it names one. @internal */
+export declare const imageOf: (node: Node, at: At) => string;
+/** @internal */
+export declare const isReference: (node: Node) => boolean;
+/** Strips parentheses. @internal */
+export declare function unwrap(node: Node): Node;
+/** The number a literal argument is (`-1`, `(1)`, `TRUE` as `1`), or `undefined`. @internal */
+export declare function numberOf(node: Node): number | undefined;
+/** The sheet name references are compared under. @internal */
+export declare const ownSheetName: (source: RoleSource) => string;
+/** A reference read from a cell: its sheet (lower case) and its cells. @internal */
+export interface Resolved {
+    readonly sheet: string;
+    readonly rect: Rect;
+}
+/** Where a cell or range reference lands when its formula sits at `at`; `null` for anything else. @internal */
+export declare function resolve(node: Node, at: At, own: string): Resolved | null;
+export {};
+//# sourceMappingURL=_AnomalyFormulaChecks.d.ts.map

package/types/src/sheet/_AnomalyLabelChecks.d.ts

@@ -0,0 +1,21 @@
+import { AnomalySource, FormulaRegion, _Findings } from './_Anomalies';
+/**
+ * `linkLabelMismatch`: a link to another sheet whose target row is labeled other than the row it
+ * sits in — the row labeled Interest reading the row labeled Tax. Labels compare after case,
+ * punctuation and spacing are dropped; a row with no label on either side says nothing.
+ *
+ * Rows only: column headers differ between a model's sheets as a matter of layout (`2026P` against
+ * `Millions`), and on the v2 goldens the column pair found no planted link the row pair missed.
+ */
+export declare function checkLinkLabelMismatch(source: AnomalySource, regions: readonly FormulaRegion[], findings: _Findings): void;
+/**
+ * `keyLabelMismatch`: a lookup keyed by a typed string that is neither the label of the row nor
+ * of the column the formula sits in — `MATCH("Tax",…)` in the row labeled Interest.
+ */
+export declare function checkKeyLabelMismatch(source: AnomalySource, regions: readonly FormulaRegion[], findings: _Findings): void;
+/**
+ * `signVsSiblings`: a link into a row that the sheet's other links into that row read with the
+ * other sign — `=-'Debt'!C20` where two other links read `='Debt'!D20`, `='Debt'!E20`.
+ */
+export declare function checkSignVsSiblings(source: AnomalySource, regions: readonly FormulaRegion[], findings: _Findings): void;
+//# sourceMappingURL=_AnomalyLabelChecks.d.ts.map

package/types/src/sheet/_CellBuffer.d.ts

@@ -6,7 +6,7 @@ import { ICellRange } from '../cellRange';
 import { ICell } from '../cell';
 import { ICellStyle } from '../style';
 import { InternalTupleUpdate } from './_SheetStateTypes';
-import { SheetMutationContext } from './Sheet';
+import { SheetMutationContext } from './Worksheet';
 import { ScanStyleUpdate } from './_SheetMutations';
 /**
  * What {@link CellBuffer} needs from its sheet.
@@ -34,6 +34,11 @@ export interface CellBufferContext {
     isLocalStyle(transaction: ITransaction, rowIndex: number, colIndex: number, update: ICellStyle.Update): boolean;
     /** What the sheet's cell writes are made through; the held ones are scanned and written with it. */
     getMutations(): SheetMutationContext;
+    /**
+     * Whether a write is to be made as it comes: a batch it would be held in is told of each of its
+     * steps, and a held write would be told late.
+     */
+    isMadeAsItComes(): boolean;
 }
 /**
  * Single-cell writes made inside an open transaction, held and made as ONE write when something
@@ -163,6 +168,11 @@ export declare class CellBuffer {
     getGeneration(): number;
     /** Makes the held writes, as one. */
     flush(): void;
+    /**
+     * Makes the held writes and closes the transaction they were held in, so what is written next is
+     * not nested in it. A transaction still open inside that one keeps it open.
+     */
+    release(): void;
     /** Drops the held writes: the transaction they were made in rolled back, or the sheet closed. */
     discard(): void;
     private _toRange;

package/types/src/sheet/_CopyUtils.d.ts

@@ -1,8 +1,8 @@
 import { IRange } from '@sheetxl/primitives';
 import { IMovable } from '../movable';
 import { ICellRange, ICellHeaderRange } from '../cellRange';
-import { ISheet } from './ISheet';
-import { Sheet } from './Sheet';
+import { IWorksheet } from './IWorksheet';
+import { Worksheet } from './Worksheet';
 /**
  * The pasted images of `areas` (absolute ranges within the marked source `coordFrom`):
  * each area's offset within the source, tiled across the fitted destination `rangeTo` with
@@ -15,19 +15,26 @@ import { Sheet } from './Sheet';
  * is already LCM-expanded or clipped, so tiling here is a pure function of the two ranges.
  */
 export declare function tileMarkedAreas(areas: readonly IRange.Coords[], coordFrom: Readonly<IRange.Coords>, rangeTo: Readonly<IRange.Coords>, transpose?: boolean): IRange.Coords[];
+/**
+ * Runs every part's `prepare`, and waits only when one of them has something to wait for: with
+ * nothing to prepare, the paste stays in its caller's synchronous extent.
+ */
+export declare function prepareParts<D, O>(parts: readonly {
+    prepare?(destination: D, options?: O): Promise<void> | void;
+}[], destination: D, options?: O): Promise<void> | void;
 /**
  * Converts a header snapshot to sheet.
  */
 export declare function headerToSheetSnapshot(rangeMark: ICellHeaderRange, coordMark: IRange.Coords, optionsMark: ICellHeaderRange.CopyOptions): Partial<ICellRange.ISnapshot>;
 /**
- * Wraps a copySheetTo function into a ISheet.ISnapshot.
+ * Wraps a copySheetTo function into a IWorksheet.ISnapshot.
  * * This will error if snapshot is a cut and called a second.
  * @internal
  */
-export declare function callbackToSheetSnapshot(sheetFrom: ISheet, sheetMark: ISheet, coordsFrom: readonly IRange.Coords[], description: string, optionsMark: ICellRange.CopyOptions, copySheetTo: (sheetRange: ICellRange, options?: ICellRange.CopyOptions) => Promise<IRange.Coords> | IRange.Coords): ICellRange.ISnapshot;
+export declare function callbackToSheetSnapshot(sheetFrom: IWorksheet, sheetMark: IWorksheet, coordsFrom: readonly IRange.Coords[], description: string, optionsMark: ICellRange.CopyOptions, copySheetTo: (sheetRange: ICellRange, options?: ICellRange.CopyOptions) => IRange.Coords): ICellRange.ISnapshot;
 /**
  * Converts an array of Snapshots into a single snapshot.
  */
-export declare function arrToSheetSnapshot(snapshots: Partial<ICellRange.ISnapshot>[], sheet: ISheet, sheetMark: ISheet, coordsMark: IRange.Coords, optionsMark: ICellRange.CopyOptions, descriptionMark: string, snapshotNative?: ICellRange.ISnapshot | null): ICellRange.ISnapshot;
-export declare function movablesToSheetSnapshot(sheetMark: Sheet, coordsMark: readonly IRange.Coords[], movablesSelectionMark: readonly IMovable[], markOptions: ICellRange.CopyOptions): ICellRange.ISnapshot<ISheet> | null;
+export declare function arrToSheetSnapshot(snapshots: Partial<ICellRange.ISnapshot>[], sheet: IWorksheet, sheetMark: IWorksheet, coordsMark: IRange.Coords, optionsMark: ICellRange.CopyOptions, descriptionMark: string, snapshotNative?: ICellRange.ISnapshot | null): ICellRange.ISnapshot;
+export declare function movablesToSheetSnapshot(sheetMark: Worksheet, coordsMark: readonly IRange.Coords[], movablesSelectionMark: readonly IMovable[], markOptions: ICellRange.CopyOptions): ICellRange.ISnapshot<IWorksheet> | null;
 //# sourceMappingURL=_CopyUtils.d.ts.map

package/types/src/sheet/_IgnoredErrors.d.ts

@@ -0,0 +1,46 @@
+import { IRange } from '@sheetxl/primitives';
+import { CoordUtils } from '@sheetxl/utils';
+import { ICell } from '../cell';
+import { ISpatialMap } from '../collections';
+import { IWorksheet } from './IWorksheet';
+/**
+ * The checks a cell ignores, interned: equal sets are one object, in the schema's order, so a
+ * region's payload identity is its content and two fragments of one ignore regroup.
+ * @internal
+ */
+export type ErrorCheckSet = readonly ICell.ErrorCheck[];
+/** The interned set of `checks`; `null` for none (an unknown name is dropped). */
+export declare function internChecks(checks: Iterable<ICell.ErrorCheck>): ErrorCheckSet | null;
+/**
+ * The cells where Excel's error checks are ignored: one spatial map whose payload is the set of
+ * checks a cell ignores. Presence is the ignore; an entry goes when its set empties. Immutable;
+ * each change returns a new holder.
+ *
+ * @remarks
+ * Excel's rules (`openpy-parity/probe-ignored-errors.ps1`, 2026-10-18): the regions move with
+ * structural edits like cell content, an insert inside one splitting it; they are never copied
+ * (copy, paste, fill, the destination of a cut); and writing or clearing a cell, contents or
+ * formats, removes its ignores.
+ * @internal
+ */
+export declare class IgnoredErrors {
+    static readonly Empty: IgnoredErrors;
+    private readonly _map;
+    private constructor();
+    /** From {@link IWorksheet.JSON.ignoredErrors}; references that overlap ignore the union. */
+    static fromJSON(json: IWorksheet.JSON['ignoredErrors'], entireCoords: IRange.Coords): IgnoredErrors;
+    isEmpty(): boolean;
+    /** The map, for the sheet's range-state readers; `null` when nothing is ignored. */
+    getMap(): ISpatialMap<ErrorCheckSet> | null;
+    /** The checks `cell` ignores, or `null`. */
+    getAt(cell: IRange.CellCoords): ErrorCheckSet | null;
+    /** With `check` ignored, or no longer ignored, over `ranges`. */
+    set(ranges: readonly IRange.Coords[], check: ICell.ErrorCheck, ignored: boolean): IgnoredErrors;
+    /** Shifted by a structural edit of `ranges`, one range at a time, in order. */
+    shift(ranges: readonly IRange.Coords[], direction: IRange.Direction, coordValidator?: CoordUtils.CoordValidator): IgnoredErrors;
+    /** Without any ignore over `ranges`, for cells written or cleared. */
+    remove(...touched: (readonly IRange.Coords[])[]): IgnoredErrors;
+    /** As {@link IWorksheet.JSON.ignoredErrors}, in range order, or `null` when nothing is ignored. */
+    toJSON(entireCoords: IRange.Coords): IWorksheet.JSON['ignoredErrors'] | null;
+}
+//# sourceMappingURL=_IgnoredErrors.d.ts.map

package/types/src/sheet/_InvalidSheetRange.d.ts

@@ -2,13 +2,13 @@ import { IRange, Scalar, IRangeStats } from '@sheetxl/primitives';
 import { IListener } from '../listener';
 import { ICellStyle } from '../style';
 import { ICell } from '../cell';
-import { ISheet } from './ISheet';
+import { IWorksheet } from './IWorksheet';
 import { ICellRange, ICellRegions, ICellRanges, ICellHeaderRanges } from '../cellRange';
 import { SheetRanges, SheetRangesOptions } from './SheetRanges';
 export declare function RETURN_FALSE(): boolean;
 export declare function RETURN_TRUE(): boolean;
 export declare function RETURN_NULL(): any;
-export declare function getInvalidCell(sheet: ISheet | null): ICell;
+export declare function getInvalidCell(sheet: IWorksheet | null): ICell;
 /**
  * This is for 0 size ranges.
  * @internal
@@ -42,6 +42,7 @@ export declare class InvalidSheetRanges extends SheetRanges {
     getStats(): IRangeStats;
     getCounts(): ICellRange.Counts;
     getRegions(): ICellRegions;
+    getAnomalies(): ICellRegions;
     getDirectPrecedents(): Promise<ICellRanges | null>;
     getDirectDependents(): Promise<ICellRanges | null>;
     getPrecedents(): Promise<ICellRanges | null>;

package/types/src/sheet/_Kinds.d.ts

@@ -0,0 +1,34 @@
+import { Scalar } from '@sheetxl/primitives';
+import { ISparseGrid, ISpatialMap, ISpatialQuery } from '../collections';
+/**
+ * What a cell holds (`ICellRange.Feature.Kind`). A formula cell is the kind of its result.
+ * @internal
+ */
+export declare const CellKind: {
+    readonly Number: "number";
+    /** A number under a date or time format. */
+    readonly Date: "date";
+    readonly Text: "text";
+    /** Text a typed entry would read as a number: Excel's number stored as text. */
+    readonly NumberText: "numberText";
+    readonly Boolean: "boolean";
+    readonly Error: "error";
+    readonly RichData: "richData";
+};
+/** @internal */
+export type CellKind = typeof CellKind[keyof typeof CellKind];
+/** What the kinds are read from. @internal */
+export interface KindSource {
+    readonly values: ISparseGrid<Scalar>;
+    /** The date-category number formats, by where they are applied. */
+    readonly dateFormats: ISpatialQuery<string>;
+    /** The number a text would enter as if typed, or `null`. */
+    parseNumber(text: string): number | null;
+}
+/**
+ * The kind partition of one sheet: one scan of the values, the same pass the reconciled error
+ * view makes, then the numbers under a date format become dates.
+ * @internal
+ */
+export declare function buildKinds(source: KindSource): ISpatialMap<CellKind>;
+//# sourceMappingURL=_Kinds.d.ts.map

package/types/src/sheet/_Labels.d.ts

@@ -0,0 +1,38 @@
+import { IRange } from '@sheetxl/primitives';
+import { IWorksheet } from './IWorksheet';
+/**
+ * A label and where it was read from.
+ * @internal
+ */
+export interface FoundLabel {
+    /** The label as the cell shows it. */
+    readonly text: string;
+    /** The label's cell, `B4`. */
+    readonly address: string;
+    readonly coords: IRange.CellCoords;
+}
+/**
+ * The text that labels a cell's row (`'row'`) or column (`'column'`).
+ *
+ * @remarks
+ * Deterministic, and the address is always returned so a reader can judge it:
+ *
+ * 1. The first cell of the line within the cell's current region (Ctrl+Shift+*), when it is text —
+ *    the row label at the left edge of the block, the header at its top.
+ * 2. Otherwise the first cell of each earlier run of filled cells on that line, nearest first —
+ *    leftward for a row, upward for a column — when it is text. Only a run's edge is read: a text
+ *    in the middle of a run of values (a scenario name, a unit) is part of the data, not the line's
+ *    label. The cost is the runs on the line, not its cells; there is no cap, because a cap is
+ *    only a different arbitrary answer.
+ *
+ * `null` when the cell is itself the first cell of the line or no run before it starts with text.
+ * @internal
+ */
+export declare function findLabel(sheet: IWorksheet, cell: IRange.CellCoords, axis: 'row' | 'column'): FoundLabel | null;
+/**
+ * A label reduced to what two labels are compared on: case, punctuation and runs of space
+ * dropped, so `Total Revenue:` and `total  revenue` agree.
+ * @internal
+ */
+export declare const normalizeLabel: (text: string) => string;
+//# sourceMappingURL=_Labels.d.ts.map

package/types/src/sheet/_RangeStateSweep.d.ts

@@ -1,9 +1,8 @@
 import { IRange } from '@sheetxl/primitives';
-import { RunCoords } from '@sheetxl/utils';
-import { RangeSweep, PieceStore } from '../collections/_RangeSweep';
+import { RangeSweep, RunCoords, PieceStore } from '@sheetxl/utils';
 import { RangeState } from './_SheetStateTypes';
 import { SheetReadContext } from './_SheetStateReader';
-export { type PieceStore } from '../collections/_RangeSweep';
+export { type PieceStore } from '@sheetxl/utils';
 export declare function collectPieces(ctx: SheetReadContext, bounds: IRange.Coords, searchTypes: RangeState.SearchTypes | null, injectReferences: IRange.JSONReference<any>[][] | undefined, containedBounds: IRange.Coords | undefined, hiddenRows: readonly RunCoords[] | null, hiddenColumns: readonly RunCoords[] | null): PieceStore | null;
 /**
  * The range-state sweep: regions materialize as `RangeState.Intersection` (values merged by type

package/types/src/sheet/_ScalarListFactory.d.ts

@@ -37,7 +37,7 @@ export declare class ScalarListFactory {
      */
     readonly createList: (values: Scalar[], length?: number, hint?: number) => IListLike<Scalar>;
     /**
-     * The list for a run as a file holds it (`ISheet.JSON` data): numbers and booleans as they are,
+     * The list for a run as a file holds it (`IWorksheet.JSON` data): numbers and booleans as they are,
      * strings as their id in this factory's collection, errors and rich data typed. One look at each
      * value classifies it into a reused scratch; nothing is resolved for a typed run.
      *

package/types/src/sheet/_SheetAutoFillUtils.d.ts

@@ -2,8 +2,8 @@ import { IRange } from '@sheetxl/primitives';
 import { ICellRange } from '../cellRange';
 import { ICell } from '../cell';
 import { IAutoFill } from '../autoFill';
-import { ISheet } from './ISheet';
-import { SheetMutationContext } from './Sheet';
+import { IWorksheet } from './IWorksheet';
+import { SheetMutationContext } from './Worksheet';
 /**
  * The default fill a range implies — which cells it reads, which it covers, which types can be
  * offered, and the one to open on. See {@link ICellRange.getDefaultAutoFillCriteria}.
@@ -11,7 +11,7 @@ import { SheetMutationContext } from './Sheet';
  * @returns `null` when the range is one cell deep along the direction — there is nowhere to fill.
  * @internal
  */
-export declare function getDefaultAutoFillCriteria(sheet: ISheet, rangeCoords: IRange.Coords, direction?: IRange.Direction, destination?: IRange.Coords): IAutoFill.DefaultCriteria | null;
+export declare function getDefaultAutoFillCriteria(sheet: IWorksheet, rangeCoords: IRange.Coords, direction?: IRange.Direction, destination?: IRange.Coords): IAutoFill.DefaultCriteria | null;
 /**
  * Resolve a raw destination to the nearest destination {@link autoFill} accepts — what
  * {@link ICellRange.AutoFillOptions.snap} runs before the fill.

package/types/src/sheet/_SheetAutoFitUtils.d.ts

@@ -1,7 +1,7 @@
 import { IRange } from '@sheetxl/primitives';
 import { Size } from '@sheetxl/utils';
 import { ICellRange } from '../cellRange';
-import { Sheet } from './Sheet';
+import { Worksheet } from './Worksheet';
 /**
  * Automatically adjusts row heights and column widths to fit cell content and styles.
  * - Merges and sorts input ranges for efficient processing.
@@ -15,7 +15,7 @@ import { Sheet } from './Sheet';
  * @param options AutoFit options (axis, expandOnly, skipCustomSize, etc).
  * @internal
  */
-export declare function doAutoFit(sheet: Sheet, ranges: readonly IRange.Coords[], options?: ICellRange.AutoFitOptions): void;
+export declare function doAutoFit(sheet: Worksheet, ranges: readonly IRange.Coords[], options?: ICellRange.AutoFitOptions): void;
 /**
  * The size `range`'s content needs — what {@link doAutoFit} would commit, reduced to a `Size`
  * instead of written.
@@ -42,5 +42,5 @@ export declare function doAutoFit(sheet: Sheet, ranges: readonly IRange.Coords[]
  * @param options Measurement options (axes, minContent, formulaView).
  * @internal
  */
-export declare function doBestFit(sheet: Sheet, range: IRange.Coords, options?: ICellRange.BestFitOptions): Size;
+export declare function doBestFit(sheet: Worksheet, range: IRange.Coords, options?: ICellRange.BestFitOptions): Size;
 //# sourceMappingURL=_SheetAutoFitUtils.d.ts.map