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

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/_SheetMutations.d.ts

@@ -50,7 +50,9 @@ export declare function setErrorIgnored(ctx: SheetMutationContext, ranges: reado
  * @internal
  */
 export declare function setHyperlinks(ctx: SheetMutationContext, ranges: readonly ISpatialMap.Entry<IHyperlink.Update>[], defaultUpdate?: IHyperlink.Update, // we do this because updateTuples may update each
-options?: ITransaction.OperationOptions): void;
+options?: ITransaction.OperationOptions, 
+/** The caller has ruled on protection for these ranges (a content clear on a locked sheet). */
+isRuled?: boolean): void;
 export declare function updateStyles(ctx: SheetMutationContext, ranges: readonly ISpatialMap.Entry<ICellStyle.Update>[], defaultUpdate?: ICellStyle.Update, // we do this because updateTuples may update each
 options?: ICellStyle.UpdateOptions, calcedNumberFormat?: boolean, // this is a bit of a hack. This is prevent number formats from functions to override user defined formats.
 isStep?: boolean): void;
@@ -162,6 +164,7 @@ export interface TupleScan {
     readonly allowFormatCells: boolean;
     readonly hasUnlockRanges: boolean;
     readonly runtime: SheetMutationContext['runtime'];
+    readonly richData: SheetMutationContext['richData'];
     /**
      * A scan that stays open holds only cells whose write cannot fail once scanned, and whose held
      * style changes that cell alone: a cell that carries a hyperlink or comments, or a style that

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

@@ -13,8 +13,8 @@ import { SpillEntry, ContentfulSpatialValue, CircularEntry } from '../calculatio
 import { IConditionalFormat } from '../conditionalFormat';
 import { IDataValidation } from '../dataValidation';
 import { IProtectedRange } from '../protectedRange';
+import { ICellControl } from '../cellControl';
 import { IPivotTable } from '../pivot';
-import { IDataTable } from '../dataTable';
 import { ICell } from '../cell';
 import { IgnoredErrors } from './_IgnoredErrors';
 import { CellKind } from './_Kinds';
@@ -153,6 +153,14 @@ export declare namespace RangeState {
          * Overlaps are allowed
          */
         conditionals?: IConditionalFormat | IConditionalFormat[];
+        /**
+         * The cell's control, such as a checkbox.
+         *
+         * @remarks
+         * A cell has at most one; an array arises only from a file whose controls overlap, and the
+         * first wins (`ICell.getControl`).
+         */
+        cellControls?: ICellControl | ICellControl[];
         /**
          * The per-feature direct styles for a collection of cells (SHEET-STYLE-SPLIT). These are the
          * user-authored style, kept DISCRETE — `borderStyle` carries `borders`, `fillStyle` carries `fill`,
@@ -234,10 +242,8 @@ export declare namespace RangeState {
          * The date format as a string
          */
         dateFormat?: string;
-        /**
-         * Pending calcs.
-         */
-        pending?: boolean;
+        /** Why the cell is waiting on a calculation: its own function's result, or a precedent's. */
+        calcStatus?: ICalcGrid.CalcStatus;
         /**
          * Errors during calculation.
          */
@@ -283,16 +289,14 @@ export declare namespace RangeState {
         readonly Unlock: "unlock";
         readonly Contentful: "contentful";
         readonly Conditionals: "conditionals";
+        readonly CellControls: "cellControls";
         /**
          * Has a formula
          */
         readonly Formula: "formula";
         readonly Spills: "spills";
-        readonly Pending: "pending";
+        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
@@ -339,8 +343,8 @@ export declare namespace RangeState {
  *   spatial map (`dateFormatSpatial`, no longer internal-only), `Error` off the reconciled error
  *   view. Neither needs the value-scan special-casing the old derived `Date` feature did.
  *
- * Internal-only members of `RangeState.Type` (`Pending`, `Continuous`, the legacy `Validation`
- * alias) deliberately have no public feature.
+ * Internal-only members of `RangeState.Type` (`Continuous`, the legacy `Validation` alias)
+ * deliberately have no public feature.
  */
 export declare const FeatureToRangeState: Readonly<Record<ICellRange.Feature, RangeState.Type | null>>;
 /**
@@ -358,7 +362,7 @@ export declare function featuresToSearchTypes(features?: ICellRange.Feature | re
  *   would put an intersection on every valued cell (the null-check optimization dies).
  * - `Continuous` rides along with any content-style projection (it is the continuous-alignment
  *   fast path — internal, so no public feature can name it).
- * - `Pending` rides along with `Formula`/`CalcError` (calc status accompanies calc state).
+ * - `CalcStatus` rides along with `Formula`/`CalcError` (calc status accompanies calc state).
  */
 export declare function cellFeaturesToSearchTypes(features?: ICellRange.Feature | readonly ICellRange.Feature[]): boolean | RangeState.SearchTypes;
 /**
@@ -463,6 +467,13 @@ export interface State {
      * Read through `RangeState.Type.Comments` — see {@link RangeState.Intersection.comments}.
      */
     comments: IAnchoredMap<IComment, IComment.JSON>;
+    /**
+     * The cell controls, such as checkboxes.
+     *
+     * @remarks
+     * Read through `RangeState.Type.CellControls` — see {@link RangeState.Intersection.cellControls}.
+     */
+    cellControls: IAnchoredMap<ICellControl, ICellControl.JSON>;
     /**
      * The reference each range listener watches.
      *
@@ -476,8 +487,6 @@ export interface State {
     listeners: IAnchoredMap<ListenerAnchor, never>;
     /** The pivot tables laid out on the sheet, anchored at their locations as tables are. */
     pivotTables: IAnchoredMap<IPivotTable, IPivotTable.JSON>;
-    /** The data tables on the sheet, anchored at their result cells. */
-    dataTables: IAnchoredMap<IDataTable, IDataTable.JSON>;
     /**
      * The grid's inputs this record pairs with, as the grid named them when the model last wrote
      * this sheet's cells (`ICalcGrid.Events.onInputsWritten`); `null` before any write.

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

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

@@ -0,0 +1,24 @@
+import { IFont } from '../font/IFont';
+/** A line of text at a size, in whole px. */
+export interface LineBox {
+    /** What a line advances by. */
+    readonly lineHeight: number;
+    /** The leading around the font's box: `lineHeight` less ascent and descent. */
+    readonly lineGap: number;
+    /** The baseline's offset from the top of the line: half the leading above, then the ascent. */
+    readonly baseline: number;
+}
+/**
+ * How tall a line of text is in a face at `px` pixels per em, in whole px: the layout's choice of
+ * leading. Without one a line is as tall as the font's own metrics ask.
+ */
+export type LineHeightRule = (table: IFont.AdvanceTable, px: number) => number;
+/**
+ * A line `lineHeight` tall around a font's box: the leading split above and below, the half above
+ * floored (as a browser lays out a CSS line box). A line shorter than the box leaves the baseline
+ * at the ascent. `LineBox::around` in `sheetxl-text` is the same rule.
+ */
+export declare function lineBoxAround(metrics: Pick<IFont.Metrics, 'ascent' | 'descent'>, lineHeight: number): LineBox;
+/** The line `rule` gives text in `table`'s face at `px`, or the font's own without one. */
+export declare function lineBox(table: IFont.AdvanceTable, px: number, rule?: LineHeightRule | null): LineBox;
+//# sourceMappingURL=_LineBox.d.ts.map

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

@@ -3,15 +3,17 @@ import { IFontCollection } from '../font';
 import { ITextFrame } from './ITextFrame';
 import { ITextBoxAlignment } from './TextBoxAlignment';
 import { IFontStyle } from '../font/IFontStyle';
+import { LineHeightRule } from './_LineBox';
 /**
  * This 'places' text which means that using all of the formatting rules it assign's locations and bounds to
  * all of the characters. It does not however actually render them. See @renderTextFrame for rendering.
  *
  * @param textFrame
  * @param dimensions
+ * @param lineHeight How tall each line is; the font's own line without one.
  * @param fonts Where fonts are measured from; the shared collection by default.
  */
-export declare function layoutTextFrame(textFrame: ITextFrame, defaultFont: IFontStyle, alignment: ITextBoxAlignment, dimensions?: Partial<Size> | null, fonts?: IFontCollection): ITextFrame;
+export declare function layoutTextFrame(textFrame: ITextFrame, defaultFont: IFontStyle, alignment: ITextBoxAlignment, dimensions?: Partial<Size> | null, lineHeight?: LineHeightRule | null, fonts?: IFontCollection): ITextFrame;
 /**
  * Checks whether a string is entirely uppercase, lowercase, or mixed case.
  *
@@ -84,7 +86,8 @@ export declare function convertCase(str: string, caseArray: readonly number[]):
  * Create a simple text frame.
  * TODO - Later we will make take frame take the style (and theme?) and have more operations on it.
  * TODO - abstract CellStyle
+ * @param lineHeight How tall each line is when laid out; the font's own line without one.
  * @internal
  */
-export declare function createTextFrameFromText(text: string, defaultFont: IFontStyle, alignment: ITextBoxAlignment, allowWrap: boolean, disableCustomFormatting?: boolean): ITextFrame;
+export declare function createTextFrameFromText(text: string, defaultFont: IFontStyle, alignment: ITextBoxAlignment, allowWrap: boolean, disableCustomFormatting?: boolean, lineHeight?: LineHeightRule | null): ITextFrame;
 //# sourceMappingURL=_TextUtils.d.ts.map

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

@@ -25,7 +25,8 @@ export declare class TextWrapperFallback {
     private _maxHeight;
     /** One character's advance in px, by character, for the current wrap. */
     private _advances;
-    private _metrics;
+    /** The line every wrapped line takes. */
+    private _line;
     /** The current line from its start to {@link _charactersRead}. */
     private _lineTally;
     /**

package/types/src/wasm/sdkWasm.d.ts

@@ -14,7 +14,7 @@ export type { SdkWasmExports } from './_sdkWasm';
  * @example
  * ```ts
  * const wasm = await SdkWasm.load();
- * wasm.line_pitch(12, 3); // 17
+ * wasm.char_count('abc'); // 3
  * ```
  */
 export declare const SdkWasm: {