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

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

@@ -223,6 +223,12 @@ export declare class SheetCell implements ICell {
     getWorksheet(): IWorksheet;
     /** {@inheritDoc ICell.select} */
     select(options?: ITypes.SelectOptions): Promise<boolean>;
+    /**
+     * Follows an address as this cell's sheet follows a link: what a link beside the cells (a picture's)
+     * opens with.
+     * @internal
+     */
+    _openAddress(address: string, options: ITypes.SelectOptions | null, target?: string, features?: string): Promise<boolean>;
     /** {@inheritDoc ICell.getColumn} */
     getColumn(): ITable.IColumn | null;
     /** {@inheritDoc ICell.getTable} */
@@ -371,8 +377,8 @@ export declare class SheetCell implements ICell {
     /** {@inheritDoc ICell.getSpillKind} */
     getSpillKind(): ITypes.FormulaArrayKind | null;
     /**
-     * The spill entry this cell answers for: the first live one, else a blocked one so the UI can
-     * still show the range it would have taken.
+     * The spill entry this cell answers for: a live one, else a blocked one, so the UI can show the
+     * range it would have taken. Where blocked ones overlap, the one anchored here, else the first.
      */
     protected _getSpillEntry(): SpillEntry | null;
     /** {@inheritDoc ICell.isSpillOverflow} */

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

@@ -1,26 +1,26 @@
 import { IRange, Scalar, InteropScalar, IRangeStats, IRuntime } from '@sheetxl/primitives';
 import { CoordUtils, Size, Bounds, Point } from '@sheetxl/utils';
 import { ITypes, ICollection, IProperties } from '../type';
-import { IWorkbook } from '../workbook';
-import { IListener } from '../listener';
 import { ITransaction } from '../transaction';
-import { BatchHandle } from '../transaction/_BatchHandle';
+import { IListener } from '../listener';
 import { IResource, IResourceCollection } from '../resource';
 import { IStringCollection } from '../string';
 import { IProtection } from '../protection';
 import { IComment, ICommentCollection } from '../comment';
 import { IColor } from '../color';
 import { IHyperlink } from '../hyperlink';
+import { IWorkbook } from '../workbook';
 import { ISort } from '../sort';
 import { IAutoFill } from '../autoFill';
+import { ITable, ITableCollection } from '../table';
+import { INamedCollection } from '../named';
+import { IModuleCollection } from '../scripting';
+import { BatchHandle } from '../transaction/_BatchHandle';
 import { IAnchored } from '../anchored';
 import { Anchored } from '../anchored/Anchored';
 import { IAnchoredMap } from '../anchored/IAnchoredMap';
-import { ITable, ITableCollection } from '../table';
 import { NamedTableSource } from '../table/_NamedTableSource';
 import { AnchoredTable } from '../table/AnchoredTable';
-import { INamedCollection } from '../named';
-import { IModuleCollection } from '../scripting';
 import { ModuleCollection } from '../scripting/ModuleCollection';
 import { IMovable, IMovableCollection } from '../movable';
 import { Movable } from '../movable/Movable';
@@ -75,9 +75,9 @@ import { ProtectionCheck } from './_SheetCoords';
 import { WorksheetProtection } from '../sheetProtection/WorksheetProtection';
 import { Outline } from '../outline/Outline';
 import { PageLayout } from '../print/PageLayout';
-import { SheetCellOptions } from './SheetCell';
 import { ICalculation } from '../calculation';
 import { ICalcGrid } from '../calculation/grid';
+import { SheetCellOptions } from './SheetCell';
 import * as _SheetFilterUtils from './_SheetFilterUtils';
 /** The font colors a workbook writes its roles in, and a key that compares by content. */
 interface WorkbookRoleColors {
@@ -508,19 +508,6 @@ export declare class Worksheet implements IWorksheet {
      * @internal
      */
     protected _getKinds(): ISpatialMap<CellKind>;
-    /**
-     * The sheet's grid: the synchronous half of the calculation service for this sheet
-     * (DESIGN-CALC-SERVICE §13.23, §13.24), holding everything a cell contains - the formulas, the
-     * values and the indexes over them - and forwarding every verb to its backend.
-     *
-     * @remarks
-     * A plain field, NOT part of `State` (§13.24 a): one grid serves every version of the sheet, so
-     * a versioned slot would answer with the CURRENT maps from a historic record - which the sheet
-     * reads (`_resolveInheritedFormats`, the snapshot sheets). What the grid HOLDS versions, in its
-     * own record; its reads take the transaction to answer for. Opened by `_fromJSON`, so it is
-     * absent until then; a snapshot sheet is handed the source's grid by `_clone`.
-     * @internal
-     */
     protected _calcGrid: ICalcGrid;
     /** `false` for a snapshot sheet, which holds its source's grid and must not close it. */
     protected _ownsCalcGrid: boolean;
@@ -1777,14 +1764,6 @@ export declare class Worksheet implements IWorksheet {
     getRowHeaders(): ISheetHeader;
     /** {@inheritDoc IWorksheet.getColumnHeaders} */
     getColumnHeaders(): ISheetHeader;
-    /**
-     * The sheet's grid, whatever the calculation hands back (DESIGN-CALC-SERVICE §5): opened from
-     * `json` (§6.6), the file's formulas, array extents and cached values, trusted. What the engine
-     * makes of them arrives through the grid's `onComplete`, before this returns when the engine is
-     * `Running`. The grid holds every cell map, and answers an `Off` save and a start's seed itself.
-     * A snapshot sheet over another sheet's state (a copy) shares the grid: the owner answers, with
-     * the state as it is now.
-     */
     protected _openCalcGrid(json: ICalcGrid.JSON | undefined): ICalcGrid;
     /** {@inheritDoc IWorksheet.toJSON} */
     toJSON(options?: IWorksheet.ToJSONOptions): Promise<IWorksheet.JSON>;
@@ -1923,16 +1902,6 @@ export declare class Worksheet implements IWorksheet {
     getCharts(): IChartCollection;
     /** @internal */
     protected _validateOrRemoveOverlaps(rangeCoords: IRange.Coords, type: string, table?: ITable | null, removeIfContains?: boolean, absorbAutoTable?: boolean): void;
-    /**
-     * The filter and sort criteria a sheet AutoFilter hands over to a table built in its place.
-     *
-     * @remarks
-     * Read BEFORE `_validateOrRemoveOverlaps` absorbs the AutoFilter and replayed once the table
-     * exists. Excel moves them across only when the table takes EXACTLY the AutoFilter's range —
-     * probed: one extra row or column, or a shifted start, and the new table starts clean. Answers
-     * `null` when there is nothing to carry, which is the common case.
-     * @internal
-     */
     protected _getAutoTableCarryOver(rangeCoords: IRange.Coords): {
         conditions: ICondition.Input[];
         sorts: ISort.Options[];
@@ -2100,16 +2069,6 @@ export declare class Worksheet implements IWorksheet {
     protected _getStyle(ranges: IRange.Coords[], anchor?: IRangeSelection.Coords, updateStyles?: (update: ICellStyle.Update, options?: ICellStyle.UpdateOptions) => void): ICellStyle;
     /** @internal */
     protected _initHeadersState(jsonColumns?: ISheetHeader.JSON, jsonRows?: ISheetHeader.JSON): void;
-    /**
-     * Tells the grid which rows or columns are hidden now, from inside the operation that changed
-     * them: the formulas that skip hidden cells recalculate under that operation.
-     *
-     * @remarks
-     * A restore is heard here too, with no operation open, and is not told: the grid's record of
-     * the set is restored with the sheet's, and the engine's with its own history
-     * (DESIGN-CALC-SERVICE §7.5). Telling it as well would land the restored set under the snapshot
-     * being left.
-     */
     protected _tellHidden(axis: IRange.Axis): void;
     /**
      * Drop every read-through cache that a data change can invalidate.

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

@@ -0,0 +1,13 @@
+import { IFormulaContext, IRuntime, Scalar } from '@sheetxl/primitives';
+/**
+ * Reads delimited text into rows of values, each field read as typed entry: what
+ * `IDeferContext.parseText` answers, and what a CSV import writes.
+ *
+ * @remarks
+ * Empty fields are blank. A last line with nothing on it is the file's closing newline, not a row.
+ * Rows are padded with blanks to the widest.
+ *
+ * @internal
+ */
+export declare const parseDelimitedText: (runtime: IRuntime, text: string, options?: IFormulaContext.IDeferContext.ParseTextOptions) => Promise<Scalar[][]>;
+//# sourceMappingURL=_DelimitedText.d.ts.map

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

@@ -11,18 +11,6 @@ import { IWorksheet } from './IWorksheet';
 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;

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

@@ -3,25 +3,6 @@ import { IStringCollection } from '../string';
 import { IRichDataKind, IRichDataCollection } from '../richData';
 import { IListLike } from '../collections';
 import { MixedTypedArrayList } from '../collections/MixedTypedArrayList';
-/**
- * Makes the list a run of cell values is stored as, over the sheet's string collection.
- *
- * The representation is chosen from what the writer saw ({@link Tuple.Hint}) and the run's length,
- * never by looking at the values again:
- * - shorter than {@link ScalarListFactory.TypedThreshold}: a plain array (a typed list costs
- *   more than its values below that, measured at 64 on Node);
- * - one value throughout: a `RepeatingList` of period 1, which the engine reads once;
- * - otherwise a {@link MixedTypedArrayList}, strings, errors and rich values by id.
- *
- * @remarks
- * The typed list is the representation that crosses threads: a worker or the Rust engine reads
- * the codes and numbers from (shared) array buffers, and a string travels as its id into the
- * string table, a rich value as its id into the rich data collection (DESIGN-RICH-DATA-REGISTRY
- * §3.3; the wire format is DESIGN-CALC-SERVICE G7). A factory made with no rich data collection
- * keeps a run holding rich data as a plain array of the values.
- *
- * @internal
- */
 export declare class ScalarListFactory {
     /** Below this length a run is a plain array. */
     static readonly TypedThreshold = 64;

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

@@ -3,13 +3,6 @@ import { ICell } from '../cell';
 import { ICellRange, ICellRanges } from '../cellRange';
 import { IWorksheetProtection } from '../sheetProtection';
 import { SheetCoordContext } from './Worksheet';
-/**
- * Coordinate/address resolution for a {@link Sheet}: parses addresses into coords, validates bounds,
- * runs protection checks, and constructs the `ICellRange`/`ICellRanges` handles. Functions take a
- * {@link SheetCoordContext} (the caches/options/collections they read) rather than the sheet
- * instance; `Sheet` keeps thin delegators. See `private-assets/design/SHEET-SPLIT-DESIGN.md` §5.
- * @internal
- */
 /**
  * A callback that, given the parsed coords of an operation, returns the protection keys the operation
  * requires. Passed to {@link rangesToCoords} / {@link rangeToCoords} / {@link protectionCheck} so the

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

@@ -40,14 +40,6 @@ export interface FilterRuns {
  * Read-only: resolves every condition and settles the final visible and hidden runs.
  */
 export declare function evalFilter(sheet: Worksheet, coords: Readonly<IRange.Coords>, condition: ICondition.Input | ICondition.RangeOptions | null | undefined): Promise<FilterRuns>;
-/**
- * Writes the hidden bits {@link evalFilter} settled. Inside the caller's open transaction.
- *
- * @remarks
- * Full recompute, every apply (DESIGN-FILTER.md §2): unhide every row/column that now matches,
- * then hide every row/column that doesn't — including one the user hid manually, matching real
- * Excel AutoFilter (there's no persisted "hidden by filter" vs. "hidden by user" bit to preserve).
- */
 export declare function applyFilterRuns(sheet: Worksheet, runs: FilterRuns, options?: ITransaction.OperationOptions): void;
 /**
  * Sheet specific filter utils. Mirrors `_SheetSortUtils.doSort`: {@link evalFilter}, then one

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

@@ -71,16 +71,6 @@ export interface SheetReadContext {
      */
     getRoles?(): ISpatialMap<ICell.Role>;
 }
-/**
- * The read engine for a {@link Sheet}'s versioned state.
- *
- * These are stateless free functions: they take the pieces of sheet state they need explicitly
- * (spatial maps, headers) and never reach back into the `Sheet` instance. `Sheet` keeps thin
- * delegators that forward its internal fields here (see `_getRangedEntries`). Extracting the logic
- * this way keeps it testable in isolation and lets the state re-key / feature-map reworks touch a
- * small, self-contained surface. See `private-assets/design/SHEET-SPLIT-DESIGN.md` §5.2.
- * @internal
- */
 /** Header iterator options that walk only the visible spans (used for the ignore-hidden paths). */
 export declare const OptionRangeIteratorVisibleOnly: ICellHeaderRange.IteratorOptions;
 export interface GetTypedRangeOptions<T = any, E = any> {

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

@@ -297,9 +297,6 @@ export declare namespace RangeState {
         readonly Spills: "spills";
         readonly CalcStatus: "calcStatus";
         readonly CalcError: "calcError";
-        /**
-         * In a reference cycle, or downstream of one — evaluates to `0` (DESIGN-CIRCULAR-CALC.md §7).
-         */
         readonly Circular: "circular";
         /**
          * Error VALUES (the `Error` scalar kind). Backed by the RECONCILED view

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

@@ -189,7 +189,7 @@ export declare function mergeOptions(optionsA: any, optionsB: any): any;
 /**
  * Returns a regEx. Either a regular regex or a Excel like wildcard regex.
  */
-export declare function builtFindReg(findText: string, matchCase: boolean, useRegex: boolean): RegExp;
+export declare function builtFindReg(findText: string, matchCase: boolean, useRegex: boolean, matchEntireCell: boolean): RegExp;
 export declare function rangeTopLeft(range: IRange.Coords): IRange.Coords;
 /**
  * Given a selection, find the 'natural' bounding area to sort.

package/types/src/sheet/style/_RowLine.d.ts

@@ -0,0 +1,32 @@
+import { IFont } from '../../font/IFont';
+import { LineBox, LineHeightRule } from '../../text/_LineBox';
+/** One pixel above the font's box and one below. */
+export declare const CELL_GUTTER_PX = 2;
+/** The `format` of a `.rows.json` this version reads. */
+export declare const ROWS_FORMAT = "sheetxl-font-rows/1";
+/**
+ * A `.rows.json`, shipped beside a face's tables: Excel's row height for the face, in px at
+ * 96 dpi, at every integer ppem from `firstPpem` up to Excel's 409 pt cap.
+ */
+export interface RowsJSON {
+    format: typeof ROWS_FORMAT;
+    family: string;
+    weight: number;
+    italic: boolean;
+    firstPpem: number;
+    /** `pitches[i]` is the pitch at `firstPpem + i`. */
+    pitches: number[];
+}
+/**
+ * Records a face's `.rows.json`; cells in that face size their lines by it from then on.
+ *
+ * @throws when the format is not one this reads, or fewer than two sizes are listed.
+ */
+export declare function registerRows(json: RowsJSON): void;
+/** Whether a face's `.rows.json` has been recorded. */
+export declare function hasRows(face: IFont.AdvanceTable.Face): boolean;
+/** The height of a row sized to one line of text in `table`'s face at `px` pixels per em. */
+export declare const rowLineHeight: LineHeightRule;
+/** The line a cell gives one line of text in `table`'s face at `px` pixels per em. */
+export declare function cellLine(table: IFont.AdvanceTable, px: number): LineBox;
+//# sourceMappingURL=_RowLine.d.ts.map

package/types/src/sheet/style/_StyleUtils.d.ts

@@ -15,6 +15,12 @@ export declare function resolveAlwaysUnlocked(styles: IStyleCollection, direct:
  * @internal
  */
 export declare function resolveShowFormulas(styles: IStyleCollection, direct: Readonly<ICellStyle.Properties> | null | undefined): boolean;
+/**
+ * The number format a cell with these direct content properties was given: its own, then its named
+ * style's. A named style's `General` is no format, and Normal's is not given to any cell.
+ * @internal
+ */
+export declare function resolveGivenNumberFormat(styles: IStyleCollection, direct: Readonly<ICellStyle.Properties> | null | undefined): string | undefined;
 /**
  * The formula entries over `bounds` that protection lets a reader see.
  *
@@ -45,19 +51,5 @@ export declare function isEqualStrokeProperties(a: IBorders.StrokeProperties | u
  * same pieces a real stroke would.
  */
 export declare function splitBorderRange(border: IBorders.Properties, rangeFrom: IRange.Coords, rangeTo: IRange.Coords, isColumn: boolean): Partial<IBorders.Properties> | null | undefined;
-/**
- * Performs a shift but uses the entire range to ensure edge styles.
- *
- * @param options
- * @param entireRange
- *
- * @remarks
- * Returns an entry but requires the value be set/cloned.
- *
- * An entry that reaches the sheet's far edge is a header's: it keeps reaching it. An entry that
- * only starts at the near edge is an ordinary block, and moves or grows as the shift says: an
- * insert at its first row or column moves it whole, one strictly inside grows it (Excel-probed
- * 2026-10-18 for a fill and a merge: `A1:A3` + insert rows 1:2 is `A3:A5`, + insert row 2 is `A1:A4`).
- */
 export declare function getEdgeAwareShifted<T = any>(options: ISpatialMap.ShiftDetails<T>, entireRange?: IRange.Coords): ISpatialMap.Entry<T> | null;
 //# sourceMappingURL=_StyleUtils.d.ts.map

package/types/src/sheetView/_SheetViewUtils.d.ts

@@ -9,7 +9,6 @@ export declare const EmptyFreezePanes: IWorksheetView.FreezePanes;
  */
 export declare const EmptySelection: IRangeSelection.Coords;
 export declare const DefaultSheetProperties: IWorksheetView.Properties;
-/** The zoom a view mode opens at before one is set in it. Measured against Excel. */
 export declare const DefaultViewModeZoom: Readonly<Record<IWorksheetView.ViewMode, number>>;
 /**
  * A simple stepper.

package/types/src/slicer/_BuiltInSlicerStyles.d.ts

@@ -1,9 +1,4 @@
 import { ISlicerStyle } from './ISlicerStyle';
-/**
- * Excel's built-in slicer styles, taken from Excel (each built-in duplicated and saved, the dxfs
- * read back; `private-assets/design/shapes/fixtures/slicers/`). Light 1–6 and Dark 1–6 are each one
- * design over the six accents; Other 1 and 2 stand alone.
- */
 /** The style a slicer is given when nothing names another. */
 export declare const DefaultSlicerStyleName: string;
 /**

package/types/src/style/ICellStyle.d.ts

@@ -147,6 +147,10 @@ export interface ICellStyle extends IFillable<ICellStyle, IFill.ISolid | IFill.I
     /**
      * Measure the text using the styling properties
      *
+     * @remarks
+     * The vertical metrics are a cell's line: `lineHeight` is the height of a row sized to one
+     * line of this text, which leaves room around the font's ascent and descent as Excel does.
+     *
      * @param text The text to measure.
      * @param size Size @defaultValue 'to the cell font.size'
      * @param family Family @defaultValue 'to the cell font.family'

package/types/src/table/AnchoredTable.d.ts

@@ -238,27 +238,6 @@ export declare class AnchoredTable extends AbstractAnchored<State, ITable.Events
      * props, where {@link _showTotalsFromProps} finds it when the row comes back.
      */
     private _holdTotalsFromCells;
-    /**
-     * Keep every totals EXPRESSION a live formula while its row is hidden.
-     *
-     * @remarks
-     * Excel's held totals formulas are live (probed, T2): hidden, they follow a column rename, a table
-     * rename, a row inserted above and a row added to the table, A1 references included. Text in the
-     * props follows none of that. So while the row is hidden each expression is ALSO a watch - a
-     * formula the engine holds without a cell, which gets everything a cell formula gets - anchored
-     * on the row below the table, where the totals row was and will be again. It moves with that row
-     * on an insert, as the table's end does; when the table's end moves without one (a resize, an
-     * auto expansion) it is re-anchored with the text it has by then, which is a move and leaves its
-     * references where they were. Only the row matters: the text is A1, so it reads the same from
-     * any column, and a column shift inside the table is no reason to touch it.
-     *
-     * The props keep the text the watch was made from. They are what a snapshot can restore and what
-     * there is to read until the engine has registered the watch; {@link _readHeldTotal} prefers what
-     * the engine has. A function number needs none of this - it is spelled from the column's name
-     * when it is shown - and neither does a label.
-     *
-     * Derived from state, like the listeners, and called wherever they are re-derived.
-     */
     private _syncHeldTotals;
     /**
      * A held expression as the model's grid holds it, or `null` when it holds none - not registered
@@ -266,22 +245,6 @@ export declare class AnchoredTable extends AbstractAnchored<State, ITable.Events
      */
     private _readHeldTotal;
     private _removeHeldTotals;
-    /**
-     * Keep every calculated column's formula a live formula.
-     *
-     * @remarks
-     * A calculated column remembers its formula apart from its cells - any of them may hold
-     * something else, the first included - and Excel's is live (probed, G5 of
-     * `probe-table-columnfill-edges.ps1`): it follows a sheet row inserted above the table, a column
-     * inserted inside it and a column rename, exceptions or not. It is the problem
-     * {@link _syncHeldTotals} solves and the same holder: the text in the column props, and a watch
-     * made from it, here on a body cell of the column.
-     *
-     * The text is always the formula as it reads in the FIRST body row, which is how a file stores
-     * it and what {@link _readHeldCalculated} images, wherever in the body the watch has been pushed
-     * to. So a watch is only made again when it has left the column's body, or when the props hold
-     * a different text.
-     */
     private _syncHeldCalculated;
     /**
      * A calculated column's formula as the engine has it now, as it reads in the first body row, or
@@ -303,19 +266,6 @@ export declare class AnchoredTable extends AbstractAnchored<State, ITable.Events
      * after it.
      */
     private _calculatedTextAt;
-    /**
-     * What Excel gives a totals row the FIRST time it is shown, and never again: an aggregate in the
-     * last column, chosen by what the column holds. Held in the props, which is where
-     * {@link _showTotalsFromProps} is about to look.
-     *
-     * @remarks
-     * Probed (`probe-table-totals-firstshow.ps1`): `109` (sum) when every cell of the body that holds
-     * anything holds a number - a formula's result counts, and so does a currency or a percent
-     * format - and `103` (count) as soon as one is text, a boolean, an error, or a number shown as a
-     * date or a time, and for a column with nothing in it. A row shown a second time is given
-     * nothing, even when the aggregate was cleared in between, which is what `totalsRowShown` records.
-     * The `Total` label is the first column's from the day the table is made.
-     */
     private _holdFirstShowTotals;
     /**
      * The region a bare cursor on this table traverses within, or `null` to leave the move alone.
@@ -465,61 +415,8 @@ export declare class AnchoredTable extends AbstractAnchored<State, ITable.Events
     /** @internal */
     protected _processExpandListener(): void;
     private _onExpandListenerEvent;
-    /**
-     * A formula has been entered in the row just below the table: that row becomes the totals row, in
-     * the one step of the expansion (Excel: `Table AutoExpansion`).
-     *
-     * @remarks
-     * Probed (`probe-table-autototals.ps1`). What was entered stays where it is and is its column's
-     * total from here on. The other columns total nothing - not the `Total` label a table is made
-     * with, not the aggregate a first showing gives - unless the table has shown a totals row before,
-     * whose totals then come back beside it as they would with the row toggled on.
-     */
     private _takeRowBelowAsTotals;
-    /**
-     * What a commit that wrote into the body means for the columns it wrote to: a formula to fill
-     * down the column, a formula to remember, or one to forget.
-     *
-     * @remarks
-     * Probed (`probe-table-columnfill.ps1` and `-edges.ps1`). A formula written to ONE body cell is
-     * filled down its column when every other body cell of the column is blank, or when the column
-     * is calculated and every other body cell still holds one formula - so editing the formula of
-     * a calculated column edits the column, and a column holding an exception, a blank one
-     * included, is left alone. Nothing is asked about what the written cell held before. A write of
-     * two cells or more never fills, whatever it wrote. The fill is a commit of its own (Excel:
-     * `Fill`), recorded after the write it follows, so the first undo takes back the fill and
-     * leaves the formula that was typed. Hidden and filtered rows are filled like any other, and
-     * the totals row never is.
-     *
-     * A write that fills nothing can still change what the column remembers, and that is part of
-     * the write, not a step of its own: a formula written over the whole body in one write is
-     * remembered, and a column left with no formula in it at all remembers none.
-     *
-     * Everything here is asked of whole rectangles and of formula blocks - a filled column is one
-     * block - never cell by cell.
-     *
-     * @param changed Every range the commit changed, unclipped.
-     * @param bodyBefore The body as it was when the commit landed. A row the table has taken since
-     * is not one the write could have filled from: a formula written just below a table becomes a
-     * row of it and fills nothing.
-     */
     private _processBodyWrite;
-    /**
-     * A table has just been made over cells that were already there: a column whose cells hold one
-     * formula is a calculated column from the start.
-     *
-     * @remarks
-     * Probed (`probe-table-columnfill-created.ps1`). Excel looks at the LAST five body rows and no
-     * further. The column remembers the formula of its last body cell when at most one of the other
-     * four holds anything else - another formula, a constant, a blank. So `aaaaaabbbb` remembers
-     * `b`, `baaaa` and `ab` remember `a` and `b`, and `aabbb`, `aaab` and `aaa_` remember nothing.
-     * It is not a majority, and nothing above the five rows is ever asked.
-     *
-     * The sheet calls this for a table it has just made, never for one it loads: a file says which
-     * of its columns are calculated, and a column of identical formulas is not one unless it does.
-     *
-     * @internal
-     */
     _detectCalculatedColumns(): void;
     /**
      * Every calculated column's formula as it reads in `rowIndex`, by column index, or `null` when
@@ -532,13 +429,6 @@ export declare class AnchoredTable extends AbstractAnchored<State, ITable.Events
      * an insert, which the new row names as it was before the insert moved it.
      */
     private _calculatedTextsAt;
-    /**
-     * Give new body rows each calculated column's formula (probed, F4: a row added to the table is
-     * given it whatever the column's other cells hold). A column whose new cells already hold
-     * something - the write the table expanded for - keeps it.
-     *
-     * @param texts From {@link _calculatedTextsAt}, for `rowStart`.
-     */
     private _writeCalculatedRows;
     /**
      * Fill the formula in `from` down the body of its column, and have the column remember it.
@@ -802,43 +692,6 @@ export declare class AnchoredTable extends AbstractAnchored<State, ITable.Events
      * its header cell rather than by a generated one.
      */
     private _setAnchor;
-    /**
-     * Move the totals row to the row a resize ends the table on.
-     *
-     * @remarks
-     * Excel moves the row rather than rewriting it (probed, `probe-table-totals-refit.ps1`): what it
-     * passes on the way becomes body - growing over `70, 80` makes them the last two body rows, and
-     * shrinking leaves the body rows given up sitting below the totals - and nothing outside the
-     * table's columns or below the two rows involved ends up anywhere else.
-     *
-     * That is a rotation of the totals row past the rows between, done here with the sheet's own
-     * shifts - inserts and deletes of the table's columns - so that what names a cell follows it and
-     * nothing below the two rows is left anywhere else. A shift carries cells but cannot reorder
-     * them, so one side of the rotation has to be written again, and which side depends on what the
-     * totals row passes:
-     *
-     * - **Growing over blank rows**, the usual case, the blank rows are the side given up. Rows are
-     *   inserted above the totals row, which carries it down whole - its formats, its formulas and
-     *   every reference to its cells, exactly as Excel has them - and the blank rows it pushed out
-     *   below are deleted.
-     * - **Growing over content, and shrinking**, the rows between are the user's and have to travel,
-     *   so the totals row is the side written again: a blank row is opened where it is going, its
-     *   cells are written there - formula, value and the cell's own format - and the row they came
-     *   from is deleted, which closes the gap. Two divergences follow from writing rather than
-     *   moving. A reference to a totals CELL from elsewhere (`=C7`) becomes `#REF!` where Excel
-     *   re-points it; `Table[[#Totals],[Column]]` is unaffected. And, shrinking, an A1 reference
-     *   into the rows being given up is not pushed down with them (Excel: `SUM(C3:C5)` becomes
-     *   `SUM(C3:C6)`), because the engine re-images a formula for a shift once it has settled and
-     *   the text written here is from before; Excel's own result there is a circular reference,
-     *   the totals cell sitting inside that range.
-     *
-     * The table steps back above both rows first. A shift inside a table is the table's business
-     * ({@link _processContainerShift} would hide a totals row whose row is deleted); one below it is
-     * not.
-     *
-     * @param from The anchor the table has now, totals row included.
-     * @param rowEnd The row the totals row is going to.
-     */
     private _moveTotalsRow;
     /**
      * Bring the column properties in line with a new width: a column taken in is appended (or

package/types/src/text/TextFrame.d.ts

@@ -5,6 +5,7 @@ import { ITextLine } from './TextLine';
 import { ITextParagraph } from './TextParagraph';
 import { ITextFrame } from './ITextFrame';
 import { ITextBoxAlignment } from './TextBoxAlignment';
+import { LineHeightRule } from './_LineBox';
 export declare class TextFrame {
     private _private;
     private _bounds;
@@ -16,7 +17,9 @@ export declare class TextFrame {
     private _lastLayoutFonts;
     private _defaultFont;
     private _alignment;
-    constructor(overrides: Partial<ITextFrame>, defaultFont: IFontStyle, alignment: ITextBoxAlignment, lines?: ITextLine[] | null, bounds?: Bounds | null, textBounds?: Bounds | null);
+    /** How tall each line is when laid out; the font's own line when `null`. */
+    private _lineHeight;
+    constructor(overrides: Partial<ITextFrame>, defaultFont: IFontStyle, alignment: ITextBoxAlignment, lines?: ITextLine[] | null, bounds?: Bounds | null, textBounds?: Bounds | null, lineHeight?: LineHeightRule | null);
     visitParas(visitor: TextVisitor): void;
     visitLines(visitor: TextVisitor): void;
     layout(size?: Partial<Size> | null): ITextFrame;

package/types/src/text/TextStacked.d.ts

@@ -1,29 +1,5 @@
 import { Bounds } from '@sheetxl/utils';
 import { ITextFrame } from './ITextFrame';
-/**
- * Stacked cell-text layout — Excel's "Vertical Text" (`textRotation="255"`).
- *
- * Stacked text is not rotated. Every glyph stays upright and occupies one SLOT of the font's line
- * pitch, glyphs advancing downward in a column. Measured against Excel (hidden-COM probes, see
- * `VERTICAL-TEXT-PLAN.md`):
- *
- * 1. Columns come from explicit line breaks — one column per line, left → right in reading order —
- *    and, when the cell wraps, from breaking a column that would exceed the content height: greedy
- *    at spaces (the space at a break is consumed), per glyph inside a word longer than the capacity.
- *    It is the horizontal wrap rule transposed. An unwrapped cell keeps one column; a line break
- *    there is a blank slot.
- * 2. Leading and trailing spaces of a column are measured but never painted (see
- *    {@link layoutColumns}); inner spaces are blank slots.
- * 3. Each column is aligned on its own by the vertical alignment (Top / Center / Bottom; Justify
- *    and Distributed behave as Top and Center — nothing is spread). The horizontal alignment places
- *    the group of columns; the caller resolves General (Excel centers it). Columns are one pitch
- *    wide and glyphs center in them.
- * 4. Nothing overflows: the footprint clips to the cell on both axes.
- *
- * All output is pure geometry, renderer-agnostic: a DOM renderer maps each column to a box of
- * `pitch` line-height with one glyph per line; a canvas renderer paints each glyph centered in
- * its slot.
- */
 /**
  * One stacked column.
  */

package/types/src/text/TextWrapper.d.ts

@@ -1,4 +1,5 @@
 import { IFontCollection } from '../font';
+import { LineHeightRule } from './_LineBox';
 /**
  * Simple Text Line Wrapper. Is not useful for Rich Text (yet). see TextLayout.
  */
@@ -18,6 +19,8 @@ export interface TextWrapperOptions {
      * This affects the width but not the height of the line.
      */
     superSub?: boolean;
+    /** How tall each line is; without one a line is as tall as the font's own metrics ask. */
+    lineHeight?: LineHeightRule | null;
     indent?: number;
 }
 export interface TextWrapperResults {
@@ -74,11 +77,6 @@ export declare class TextWrapper {
     /** Whether the next wrap runs in the Rust wrapper. */
     get isNative(): boolean;
     wrap(text: string, options?: TextWrapperOptions | null): TextWrapperResults;
-    /**
-     * The wrap through the Rust wrapper: the text crosses the boundary once and the lines come
-     * back as one flat array, {@link NATIVE_LINE_STRIDE} numbers each (DESIGN-FONTS §6.2:
-     * one call per wrap). Its offsets are UTF-8 bytes, turned into UTF-16 positions here.
-     */
     private _wrapNative;
 }
 //# sourceMappingURL=TextWrapper.d.ts.map