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

package/types/src/.generated/wasm/fonts.d.ts

@@ -0,0 +1,161 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * A face's names and style (`sheetxl_text::identity::FaceIdentity`).
+ */
+export class FaceInfo {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * The `fsSelection` bold bit.
+     */
+    bold: boolean;
+    /**
+     * The family as GDI and Excel name it (`name` id 1).
+     */
+    family: string;
+    /**
+     * `name` id 4.
+     */
+    full_name: string;
+    /**
+     * The `fsSelection` italic bit.
+     */
+    italic: boolean;
+    /**
+     * `name` id 6.
+     */
+    postscript_name: string;
+    /**
+     * The style within `family` (`name` id 2).
+     */
+    subfamily: string;
+    /**
+     * The designer's family (`name` id 16), or `family`.
+     */
+    typographic_family: string;
+    /**
+     * `name` id 5, up to its first `;`.
+     */
+    version: string;
+    /**
+     * `usWeightClass`.
+     */
+    weight: number;
+}
+
+/**
+ * A face's tables, as the text of the files the sdk reads.
+ */
+export class FaceTables {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * The `.hinted.json`, or `undefined` when no sizes were asked for.
+     */
+    get hinted(): string | undefined;
+    /**
+     * The `.hinted.json`, or `undefined` when no sizes were asked for.
+     */
+    set hinted(value: string | null | undefined);
+    /**
+     * The `.metrics.json`.
+     */
+    metrics: string;
+}
+
+/**
+ * The faces of one font file: one for a `.ttf` or `.otf`, each member of a `.ttc` or `.otc`.
+ */
+export class FontFile {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * The tables of face `index`, recorded as `family`, with hinted widths at every ppem from
+     * `first_ppem` to `last_ppem` (none when `last_ppem < first_ppem`). `source_file`, when
+     * given, is recorded as the font file's name (`MetricsCapture::with_source_file`).
+     *
+     * The hinting is the slow part: about 1.2 s a face over 6-120 ppem; call per face so a host
+     * can report progress between them.
+     */
+    capture(index: number, family: string, first_ppem: number, last_ppem: number, source_file?: string | null): FaceTables;
+    /**
+     * The number of usable faces.
+     */
+    face_count(): number;
+    /**
+     * The names and style of face `index`.
+     */
+    identity(index: number): FaceInfo;
+    /**
+     * Opens a font file's bytes.
+     *
+     * Throws when the bytes are not a font. A collection member that is not a usable face is
+     * left out, so [`Self::face_count`] can be less than the file's own count.
+     */
+    constructor(bytes: Uint8Array);
+}
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_faceinfo_free: (a: number, b: number) => void;
+    readonly __wbg_facetables_free: (a: number, b: number) => void;
+    readonly __wbg_fontfile_free: (a: number, b: number) => void;
+    readonly __wbg_get_faceinfo_bold: (a: number) => number;
+    readonly __wbg_get_faceinfo_family: (a: number, b: number) => void;
+    readonly __wbg_get_faceinfo_full_name: (a: number, b: number) => void;
+    readonly __wbg_get_faceinfo_italic: (a: number) => number;
+    readonly __wbg_get_faceinfo_postscript_name: (a: number, b: number) => void;
+    readonly __wbg_get_faceinfo_subfamily: (a: number, b: number) => void;
+    readonly __wbg_get_faceinfo_typographic_family: (a: number, b: number) => void;
+    readonly __wbg_get_faceinfo_version: (a: number, b: number) => void;
+    readonly __wbg_get_faceinfo_weight: (a: number) => number;
+    readonly __wbg_get_facetables_hinted: (a: number, b: number) => void;
+    readonly __wbg_get_facetables_metrics: (a: number, b: number) => void;
+    readonly __wbg_set_faceinfo_bold: (a: number, b: number) => void;
+    readonly __wbg_set_faceinfo_family: (a: number, b: number, c: number) => void;
+    readonly __wbg_set_faceinfo_full_name: (a: number, b: number, c: number) => void;
+    readonly __wbg_set_faceinfo_italic: (a: number, b: number) => void;
+    readonly __wbg_set_faceinfo_postscript_name: (a: number, b: number, c: number) => void;
+    readonly __wbg_set_faceinfo_subfamily: (a: number, b: number, c: number) => void;
+    readonly __wbg_set_faceinfo_typographic_family: (a: number, b: number, c: number) => void;
+    readonly __wbg_set_faceinfo_version: (a: number, b: number, c: number) => void;
+    readonly __wbg_set_faceinfo_weight: (a: number, b: number) => void;
+    readonly __wbg_set_facetables_hinted: (a: number, b: number, c: number) => void;
+    readonly __wbg_set_facetables_metrics: (a: number, b: number, c: number) => void;
+    readonly fontfile_capture: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
+    readonly fontfile_face_count: (a: number) => number;
+    readonly fontfile_identity: (a: number, b: number, c: number) => void;
+    readonly fontfile_new: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
+    readonly __wbindgen_export: (a: number, b: number) => number;
+    readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_export3: (a: number, b: number, c: number) => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

package/types/src/.generated/wasm/fonts_bg.inline.d.ts

@@ -0,0 +1,3 @@
+/** The WebAssembly binary `fonts_bg.wasm`, base64-encoded. */
+declare const wasmBase64: string;
+export default wasmBase64;

package/types/src/.generated/wasm/sdk.d.ts

@@ -0,0 +1,122 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * A face's measures, filled once by the host from a shipped table or a canvas, then wrapped
+ * against any number of times (DESIGN-FONTS §6.2, shape C; DESIGN-FONTS §4).
+ */
+export class MetricsTable {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Records design-unit advances, `codepoints[i]` → `advances[i]`, in `units_per_em` units:
+     * what a `.metrics.json` lists, and what [`Self::fill_hinting`] rounds from.
+     */
+    fill(units_per_em: number, codepoints: Uint32Array, advances: Uint16Array): void;
+    /**
+     * Records hinted deltas at `ppem`, `codepoints[i]` → `deltas[i]`, from a `.hinted.json`;
+     * the table measures GDI's whole-pixel widths from then on.
+     */
+    fill_hinting(ppem: number, codepoints: Uint32Array, deltas: Int16Array): void;
+    /**
+     * Records per-em advances, `codepoints[i]` → `per_em[i]`: a canvas's measures, or
+     * characters measured on demand after [`Self::fill`].
+     */
+    fill_per_em(codepoints: Uint32Array, per_em: Float32Array): void;
+    /**
+     * Records Excel's row pitch at every integer ppem from `first_ppem`, from a `.rows.json`;
+     * `line_pitch` and `wrap` size lines by it from then on. `false` with fewer than two sizes.
+     */
+    fill_rows(first_ppem: number, pitches: Uint16Array): boolean;
+    /**
+     * Whether nothing has been recorded.
+     */
+    is_empty(): boolean;
+    /**
+     * The number of characters recorded.
+     */
+    len(): number;
+    /**
+     * Excel's row height for this face at `px` pixels per em.
+     */
+    line_pitch(px: number): number;
+    /**
+     * An empty table for a face with these vertical metrics per em (`usWinAscent / unitsPerEm`,
+     * `usWinDescent / unitsPerEm`): what the host's own table keeps, whether it came from a
+     * `.metrics.json` or a canvas.
+     */
+    constructor(ascent: number, descent: number);
+    /**
+     * The advance width of `text` at `px` pixels per em.
+     */
+    text_width(text: string, px: number, letter_spacing: number, super_sub: boolean): number;
+    /**
+     * Wraps `text`; `max_width` and `max_height` of zero or less mean none. Returns the lines
+     * flat, eight numbers each (`sheetxl_text::wrap::Wrapped::flatten`).
+     *
+     * Scalars rather than an options object, deliberately: each crosses for free, an object
+     * would be marshalled.
+     */
+    wrap(text: string, px: number, max_width: number, max_height: number, indent: number, letter_spacing: number, super_sub: boolean): Float32Array;
+}
+
+/**
+ * The alphabetic baseline's offset from the top of a line box of [`line_pitch`] height.
+ */
+export function baseline(ascent: number, descent: number): number;
+
+/**
+ * The number of Unicode scalar values in `text` (not `text.length`, which counts UTF-16 units).
+ */
+export function char_count(text: string): number;
+
+/**
+ * Excel's line pitch for a font: `ascent + descent + 2`, in whole pixels.
+ */
+export function line_pitch(ascent: number, descent: number): number;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_metricstable_free: (a: number, b: number) => void;
+    readonly baseline: (a: number, b: number) => number;
+    readonly char_count: (a: number, b: number) => number;
+    readonly line_pitch: (a: number, b: number) => number;
+    readonly metricstable_fill: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly metricstable_fill_hinting: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly metricstable_fill_per_em: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly metricstable_fill_rows: (a: number, b: number, c: number, d: number) => number;
+    readonly metricstable_is_empty: (a: number) => number;
+    readonly metricstable_len: (a: number) => number;
+    readonly metricstable_line_pitch: (a: number, b: number) => number;
+    readonly metricstable_new: (a: number, b: number) => number;
+    readonly metricstable_text_width: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+    readonly metricstable_wrap: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
+    readonly __wbindgen_export: (a: number, b: number) => number;
+    readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
+    readonly __wbindgen_export3: (a: number, b: number, c: number) => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

package/types/src/.generated/wasm/sdk_bg.inline.d.ts

@@ -0,0 +1,3 @@
+/** The WebAssembly binary `sdk_bg.wasm`, base64-encoded. */
+declare const wasmBase64: string;
+export default wasmBase64;

package/types/src/address/AddressUtils.d.ts

@@ -71,6 +71,15 @@ export declare function stringToSheetRange(str: string, rangeDefault?: Readonly<
  * This doesn't fail but will return null if unable to parse.
  */
 export declare function stringToWorkbookRange(str: string, defaultRange?: Readonly<IRange.Coords>, allowR1C1?: boolean): Partial<IRange.FixableCoords> | null;
+/**
+ * Splits an address list at its `,` separators, skipping those inside a quoted sheet name
+ * (`'Q1, Q2'!A1`) or a structured reference's brackets (`Table1[[#Headers],[Qty]]`).
+ *
+ * @remarks
+ * Whitespace around a separator is dropped. Inside brackets a `'` escapes the character after it
+ * when that is `[`, `]`, `#` or `'`, as in a column specifier.
+ */
+export declare function splitAddressList(address: string): string[];
 /**
  * Parse a string into an array of coords.
  *
@@ -106,7 +115,7 @@ export declare function fasterStringToCell(address: string, _reuse: IRange.Fixab
 export declare function fastStringToCol(address: string): number;
 /**
  * `Fast` decode ranges but has no error checking.
- * If does not support fixed cells, sheets, or partials. Useful
+ * Absolute markers (`$A$1`) are read as relative. Does not support sheets or partials. Useful
  * for reading from save strings.
  */
 export declare function fastStringToRange(address: string, _reuse?: IRange.Coords): IRange.Coords;

package/types/src/address/_StructuredAddress.d.ts

@@ -0,0 +1,58 @@
+import { IRange } from '@sheetxl/primitives';
+import { INamed } from '../named';
+import { IWorksheet } from '../sheet';
+import { ITable } from '../table';
+/**
+ * A structured reference as an address spells it — `Table1[[#Headers],[Qty]:[Price]]` — by name.
+ *
+ * @remarks
+ * The same reading the formula parser gives the text, before linking turns names into ids: a
+ * well-formed reference reads identically through both. Where the formula parser lets a malformed
+ * one through as something else (`Table1[#Foo]` as the data body), this rejects it.
+ */
+export interface StructuredAddress {
+    /** The table's name; `''` for an unqualified reference (`[Qty]`). */
+    table: string;
+    /** The section, numbered as `StructuredReference.spec` numbers it. */
+    spec: number;
+    /** The first (or only) column's name, or `null` for every column. */
+    columnFrom: string | null;
+    /** The last column's name; the same as {@link columnFrom} for a single column. */
+    columnTo: string | null;
+    /** `@` / `#This Row`: only the row of the cell it is read from. */
+    isThisRow: boolean;
+}
+/**
+ * Reads `text` as a structured reference, or returns `null` when it is not one.
+ *
+ * @remarks
+ * Takes the canonical spelling: English section words and `,` between items. A reference into
+ * another workbook (`[1]!Table1[Col]`) is not read.
+ */
+export declare function parseStructuredAddress(text: string): StructuredAddress | null;
+/**
+ * What a structured-reference address is resolved against.
+ */
+export interface StructuredAddressContext {
+    /** The table a name designates. */
+    getTable(name: string): ITable | null;
+    /**
+     * The cell an address is read from — the active cell. An unqualified reference takes the table
+     * there, and `@` takes its row.
+     */
+    getAnchor(): {
+        sheet: IWorksheet;
+        coords: IRange.CellCoords;
+    } | null;
+}
+/** The table `named` designates, or `null` when it is not a table's name. */
+export declare function namedTable(named: INamed | null | undefined): ITable | null;
+/**
+ * The cells a structured-reference address designates, scoped by sheet name, or `null` when `text`
+ * is not a structured reference.
+ *
+ * @throws {@link ExpectedError} when `text` is a structured reference that designates no cells, or a
+ * reference into another workbook.
+ */
+export declare function resolveStructuredAddress(text: string, ctx: StructuredAddressContext): IRange.FixableCoords | null;
+//# sourceMappingURL=_StructuredAddress.d.ts.map

package/types/src/anomalies/_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 '../sheet/IWorksheet';
+import { IgnoredErrors } from '../sheet/_IgnoredErrors';
+import { CellKind } from '../sheet/_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/anomalies/_FocusTable.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Per focus, the share of a class of finding's regions that held a planted defect of that kind on the
+ * SpreadsheetBench v2 Debugging inputs, and `prior`, the kind's rate over every region. A class is
+ * `check/evidence key/repeats` (`ICellRange.AnomalyFocus`).
+ * @internal
+ */
+export declare const ANOMALY_FOCUS_TABLE: Readonly<Record<string, {
+    readonly prior: number;
+    readonly classes: Readonly<Record<string, number>>;
+}>>;
+//# sourceMappingURL=_FocusTable.d.ts.map

package/types/src/anomalies/_FormulaChecks.d.ts

@@ -0,0 +1,133 @@
+import { IRange } from '@sheetxl/primitives';
+import { ICalculation } from '../calculation';
+import { SpatialMap } from '../collections';
+import { IWorksheet } from '../sheet/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;
+/**
+ * `errorConstant`: a formula that is only an error value — `=#DIV/0!`, `=#REF!`. Nobody types
+ * one; it is what a converter leaves when it drops the formula that computed the error. When the
+ * block sits against a data table (`=TABLE(…)`) that spills less than the block covers,
+ * `dataTable` names the table's anchor and `extent` the rectangle the two cover together: the
+ * table's results were replaced by constants.
+ */
+export declare function checkErrorConstant(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=_FormulaChecks.d.ts.map

package/types/src/anomalies/_LabelChecks.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=_LabelChecks.d.ts.map