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

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

@@ -23,11 +23,6 @@ export class MetricsTable {
      * 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.
      */
@@ -36,10 +31,6 @@ export class MetricsTable {
      * 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
@@ -51,48 +42,35 @@ export class MetricsTable {
      */
     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`).
+     * Wraps `text` in lines `line_height` px tall, the font's box centered in each; `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;
+    wrap(text: string, px: number, line_height: 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 metricstable_wrap: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: 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;

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

@@ -94,6 +94,14 @@ export declare function stringToCoordsArray(str: string, defaultRange: Readonly<
 export declare function coordsArrayToStringArray(coords: readonly (Partial<IRange.Coords | IRange.CellCoords> | string)[], defaultRange?: Readonly<IRange.Coords>, toStringRange?: RangeToString, //fixableRangeToString,
 toStringCell?: CellToString, r1c1?: boolean): string[] | null;
 export declare function coordsArrayToString(coords: readonly (Partial<IRange.Coords | IRange.CellCoords> | string)[], defaultRange?: Readonly<IRange.Coords>, toStringRange?: RangeToString, toStringCell?: CellToString, r1c1?: boolean): string;
+/**
+ * Reads the arguments of `getRange(rowStart, colStart, rowEnd, colEnd)`: zero-based, ends inclusive.
+ *
+ * @remarks
+ * Left out of the declarations on purpose. There is one documented way to say this, the coords
+ * object; this is for scripts that guess, which should get the range they meant, or an error.
+ */
+export declare function indexesToCoords(args: ArrayLike<unknown>): IRange.Coords;
 export declare function rangesAddressToRangesCoords<R extends IRange.Coords = IRange.Coords, C extends IRange.CellCoords = IRange.CellCoords>(address: ICellRanges.Address | ICell.Address, defaultRange: Readonly<R>, toRange?: StringToRange, onNoParse?: (coord: Partial<C | R> | string) => readonly R[], allowR1C1?: boolean): R[];
 /** `Fast` just scans through each character. */
 export declare function fastStringToCell(address: string, reuse?: IRange.CellCoords): IRange.CellCoords | undefined;

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

@@ -0,0 +1,3 @@
+/** Whether Excel quotes a sheet name for containing this UTF-16 code unit. Only meaningful above U+007F. */
+export declare function isQuotedSheetNameChar(code: number): boolean;
+//# sourceMappingURL=_SheetNameQuoteChars.d.ts.map

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

@@ -1,9 +1,3 @@
-/**
- * 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>>;

package/types/src/calculation/Calculation.d.ts

@@ -1,4 +1,4 @@
-import { IRange, IFunction, IRuntime, Scalar } from '@sheetxl/primitives';
+import { IRange, IFormulaContext, IFunction, IRuntime, Scalar } from '@sheetxl/primitives';
 import { IListener } from '../listener';
 import { FunctionProvider } from '@sheetxl/scripting';
 import { AbstractModel, IModel } from '../model';
@@ -27,7 +27,6 @@ import { INamedFormulasCollection } from './INamedFormulasCollection';
 export declare class Calculation extends AbstractModel<AbstractModel.State, ICalculation.JSON, ICalculation.IListeners> implements ICalculation {
     protected _backend: CalcBackend | null;
     protected _startReplica: CalcBackend.Replica | null;
-    /** The symbols formulas bind through (DESIGN-CALC-SERVICE §8): the model's, handed to the backend. */
     protected _symbols: ISymbolRegistry;
     protected _status: ICalculation.Status;
     protected _statusTransition: Promise<void> | null;
@@ -51,7 +50,6 @@ export declare class Calculation extends AbstractModel<AbstractModel.State, ICal
     /** The current handle of every formula host's grid, by grid id. */
     protected _formulaHosts: Map<string, FormulaHost>;
     protected _modelStore: ITransaction.IStore | null;
-    /** The model-side grids, by grid id (DESIGN-CALC-SERVICE §13.23): what a copy lands on, what a start seeds from. */
     protected readonly _fronts: Map<string, CalcGrid>;
     /** What each model grid is, for the `create` a start sends for it (its size is read then). */
     protected readonly _gridSpecs: Map<string, CalcGridSpec>;
@@ -82,6 +80,12 @@ export declare class Calculation extends AbstractModel<AbstractModel.State, ICal
     /** `ready()` calls waiting for work in flight to end: woken on every check. */
     protected _calculationStateWaiters: (() => void)[] | null;
     protected _bootFull: boolean;
+    /** The full boot pass is the load's own, not one a caller asked for: see {@link _calculateForLoad}. */
+    protected _bootFullForLoad: boolean;
+    /** Something was edited ahead of the boot pass, so what a cell was saved with may be out of date. */
+    protected _bootEdited: boolean;
+    /** The next pass is the one a load owes: see `CalcExecutor.ExecuteOptions.load`. */
+    protected _passForLoad: boolean;
     /** Consumer work not yet settled: see {@link waitUntil}. */
     protected _consumerWork: number;
     protected _bootExplicit: boolean;
@@ -213,11 +217,6 @@ export declare class Calculation extends AbstractModel<AbstractModel.State, ICal
      * only inside a calculation. The drain is a safe point, not a synchronization point.
      */
     _whenSafe(action: () => Promise<unknown>, priority?: boolean): void;
-    /**
-     * Sends a grid request through the channel (DESIGN-CALC-SERVICE §4): applied now on a `Running`
-     * engine, held in send order while `Starting`, and neither recorded nor sent on an `Off` one -
-     * the caller's own view is the truth there, and a start is seeded from it.
-     */
     protected _sendRequest(gridId: string, landingId: string | undefined, request: CalcRequest): Promise<ICalcGrid.Results>;
     protected _sendRequestNow(gridId: string, landingId: string | undefined, request: CalcRequest): Promise<CalcResponse>;
     /** Re-judges every held request: `dead` is what `isDead` answers for it now. */
@@ -243,41 +242,7 @@ export declare class Calculation extends AbstractModel<AbstractModel.State, ICal
      * batch is the engine's answer to what the model already holds.
      */
     protected _underOneModelOperation<R>(batch: () => R): R;
-    /**
-     * @internal
-     * Resolves once the engine can compile: at once when `Running`; when the batch has applied the
-     * seeds, ahead of the boot pass, while `Starting`; and, when `Off`, once something else starts
-     * it. It never starts the engine itself.
-     *
-     * @remarks
-     * What an owner that registers a formula asynchronously waits on (a condition formula's
-     * evaluation). Waiting on {@link ready} instead resolves after the boot pass, and the
-     * registration then costs a pass of its own (design §6.5: a boot owes one).
-     *
-     * An `Off` engine stays off (DESIGN-CALC-ON-LOAD: under `calcOnLoad: 'none'` a read starts
-     * nothing, and a conditional format or data validation evaluating on load is a read). Starting it
-     * here ran the boot pass, and the pass moved cached values — every volatile, every iterating
-     * cycle — in a workbook that was only being opened and saved. The waiter is released by the
-     * start the first mutation (or an explicit calculation) makes, and by {@link close}.
-     */
     _whenCanCompile(): Promise<void>;
-    /**
-     * The start batch (DESIGN-CALC-SERVICE §6.3), in the order the service owns: service-level
-     * content first (the names, wired from the priority queue), then the channel in send order
-     * (every seed and every request made while the engine was coming up), then the owners that
-     * hold a formula of their own (a host whose grid lost its body writes it again; a watch held for
-     * the engine registers inside `onReady`), then the one pass the boot owes.
-     *
-     * @remarks
-     * `isLoading()` holds for the whole batch, so a grid seeded here owes its pass rather than
-     * running one against siblings not yet seeded. The pass itself runs on a task of its own
-     * ({@link _runBoot}): a consumer whose registration chains through promises resolved here (a
-     * data validation's, a conditional format's) lands ahead of it, and N of them cost one pass.
-     *
-     * A held request lands under the engine's current commit: the snapshot it named has been
-     * mirrored already, so its writes belong to the tip, and the maps are versioned under that key.
-     * One whose snapshot the model has undone since is skipped.
-     */
     protected _boot(): Promise<void>;
     /**
      * Posts the boot pass on a task of its own, and answers the promise `start()`, `ready()` and a
@@ -286,6 +251,13 @@ export declare class Calculation extends AbstractModel<AbstractModel.State, ICal
     protected _scheduleBoot(): Promise<void>;
     /** The boot pass: what the batch, and the consumers that registered since, owe - once. */
     protected _runBoot(): Promise<void>;
+    /**
+     * The full pass a load owes: a file that asks for one, or one whose `calcId` says it needs one.
+     * It evaluates what the file holds without reaching for anything outside the workbook, where a
+     * full calculation a caller asks for does.
+     * @internal
+     */
+    _calculateForLoad(): Promise<ICalculation.Status>;
     /**
      * Posts a microtask drain, if one is not already coming.
      *
@@ -385,10 +357,6 @@ export declare class Calculation extends AbstractModel<AbstractModel.State, ICal
     protected _calculate(options?: ICalculation.CalculateOptions, gridId?: string, settle?: boolean): Promise<ICalculation.Status>;
     /** A pass, counted while it runs: what the calculation state reads as a pass in flight. */
     protected _calculateNow(options?: ICalculation.CalculateOptions, gridId?: string, settle?: boolean): Promise<ICalculation.Status>;
-    /**
-     * @param settle The settle pass (DESIGN-ASYNC §4.5): seeded from what a settle marked only;
-     * volatiles and the dirty set are left for the pass that owes them.
-     */
     protected _runCalculation(options?: ICalculation.CalculateOptions, gridId?: string, settle?: boolean): Promise<ICalculation.Status>;
     /**
      * The model commit the last pass recalculated for, `null` before the first: what a sheet
@@ -448,14 +416,6 @@ export declare class Calculation extends AbstractModel<AbstractModel.State, ICal
      * @internal
      */
     protected _evaluateOver(options: Calculation.EvaluateOverOptions): Promise<IRange>;
-    /**
-     * A grid for a model to hold (DESIGN-CALC-SERVICE §13.23): the synchronous half, versioned in
-     * the model's store, forwarding every verb as a request. The engine's grid is made by the
-     * grid's first request, `create`, which an `Off` engine drops: a start makes it then, from this
-     * one. What the engine pushes reaches the owner through the grid's events. It opens empty: the
-     * owner attaches its listeners, then seeds it.
-     * @internal
-     */
     _createCalcGrid(options: Calculation.CalcGridOptions): CalcGrid;
     /** What a `create` for a model grid carries: its description. */
     protected _specOf(front: CalcGrid): CalcGridSpec;
@@ -494,20 +454,6 @@ export declare class Calculation extends AbstractModel<AbstractModel.State, ICal
     protected _heldSheets(): Calculation.SheetList['sheets'];
     /** One sheet of {@link _heldSheets} by its grid id, or `undefined` for a grid that is no sheet. */
     protected _heldSheetAt(id: string): Calculation.SheetList['sheets'][number] | undefined;
-    /**
-     * The owner's sheet list as it is now: every sheet's grid id and name, in tab order, hidden ones
-     * included (DESIGN-CALC-SERVICE §8). The owner calls this whenever its list changes - a sheet
-     * added, deleted, moved, copied or renamed - and before any grid that names a sheet in it
-     * seeds. Not on a restore: this record is restored with the owner's own, and the engine's
-     * replica with the engine's store.
-     *
-     * @remarks
-     * Held in the caller's operation (folded into the current commit when none is open) and sent
-     * to the engine as one `sheets` message: applied at once on a `Running` engine, held in order
-     * while `Starting`. An `Off` engine is told nothing; its next start seeds the replica from this
-     * record, and owes a full pass only when a sheet already listed was renamed, moved or removed.
-     * @internal
-     */
     _setSheets(sheets: readonly (readonly [id: string, name: string | null, gridless?: boolean])[]): void;
     /**
      * Compiles every loaded name whose text mentions the sheet, ahead of a change a compiled body
@@ -579,18 +525,7 @@ export declare class Calculation extends AbstractModel<AbstractModel.State, ICal
     _replicaNameId(name: string, scope: string | null | undefined): string | undefined;
     /** See {@link _modelSymbols}. */
     protected _modelSymbolRegistry: ISymbolRegistry;
-    /**
-     * The model's symbol map (DESIGN-CALC-SERVICE §8): what the facade images the engine's records
-     * against. Sheets answer from the model's live list; the rest from the engine's providers.
-     * @internal
-     */
     _modelSymbols(): ISymbolRegistry;
-    /**
-     * What images a grid's records for the model (DESIGN-CALC-SERVICE §8): the model's symbol map,
-     * the grid as home scope, its bounds and the reader's locale, both read live so a rename or a
-     * locale switch shows without a recompile.
-     * @internal
-     */
     _imagerFor(gridId: string): FormulaImager;
     /** Every sheet's grid id in tab order, from the replica. */
     protected _sheetIds(): readonly string[];
@@ -860,17 +795,6 @@ export declare namespace Calculation {
         names?: INamed.JSON[];
         getRanges?: (address: ICellRanges.Address, options?: ICellRange.GetRangeOptions) => ICellRanges;
         getRange?: (address: ICellRange.Address, options?: ICellRange.GetRangeOptions) => ICellRange;
-        /**
-         * Builds ONE `ICellRanges` graph answer out of cell coords plus defined-name nodes.
-         *
-         * @internal
-         *
-         * @remarks
-         * The seam that keeps the layers apart: the calculation layer knows WHICH names belong in a
-         * precedents/dependents answer, the range layer knows how a name rides in one (an anchored
-         * `INamedRange` — see DESIGN-NAMED-FORMULAS.md §4). Structural like `getRange`/`getRanges`,
-         * and like them supplied by the workbook. Without it, graph answers fall back to cells only.
-         */
         createGraphRanges?: (cells: readonly IRange.Coords[], names: readonly NamedNodeInfo[]) => ICellRanges | null;
         getSheetIndex?: (sheetName?: string) => number;
         getSheetCount?: () => number;
@@ -880,10 +804,15 @@ export declare namespace Calculation {
          */
         resources?: IResourceCollection;
         /**
-         * The workbook's fetch, for async functions (`IFormulaContext.IBatchContext.fetch`). Omitted,
+         * The workbook's fetch, for async functions (`IFormulaContext.IDeferContext.fetch`). Omitted,
          * the global `fetch`.
          */
         fetch?: (input: string, init?: RequestInit) => Promise<Response>;
+        /**
+         * How async functions read delimited text (`IFormulaContext.IDeferContext.parseText`), as the
+         * workbook reads typed entry. Omitted, it rejects.
+         */
+        parseText?: (text: string, options?: IFormulaContext.IDeferContext.ParseTextOptions) => Promise<Scalar[][]>;
         /**
          * Whether to perform iterative calculations when there are circular dependencies.
          *
@@ -907,10 +836,6 @@ export declare namespace Calculation {
 /**
  * Transaction State for Calculation
  */
-/**
- * A grid request the channel holds while the engine is `Starting` (DESIGN-CALC-SERVICE §4): the
- * request as data, the snapshot it names, and the caller's continuation.
- */
 interface HeldRequest {
     gridId: string;
     request: CalcRequest;

package/types/src/calculation/ExternalBookBindings.d.ts

@@ -19,32 +19,6 @@ export interface ExternalNamedItem {
     /** The cached body as written; replaced in place when a refresh changes it. */
     refersTo: string;
 }
-/**
- * What an external book's cache is to the engine: one read-only grid per sheet, and one virtual
- * grid per cached defined name — reconciled against the collection on every change.
- *
- * @remarks
- * DESIGN-EXTERNAL-LINKS §5 steps 15 and 16. The measured rule (§6 items 1 and 2) is that an
- * external cell the cache does not hold is a BLANK CELL, so a sheet's grid is simply the sparse
- * cache loaded at its real coordinates with the ordinary sheet extent: every cell it does not hold
- * is already empty, and a whole-column citation walks the cache's used cells like any sheet's.
- * A sheet with no cache at all gets an empty grid for the same reason — Excel answers blank there
- * too, and the alternative (`#REF!`) is the value damage this phase exists to remove.
- *
- * Grids are keyed by the `ext:` stable id the sheet symbol binds to, so `container.getGrid(scope)`
- * finds them with no change to the executor. A book's removal unregisters its grids WITHOUT the
- * `delete()` a dropped sheet gets: a citation keeps the slot's id and computes `#REF!`, and an undo,
- * which restores the slot with its id, rebuilds the grids and heals it (see
- * `IExternalBook.delete`).
- *
- * A cached name's body is compiled INSIDE the book (`SheetCtx.book`), so `'Alpha'!$A$1` names the
- * book's sheet; a bare reference anchors to the scoping sheet, else the book's first. A name is
- * found under exactly the scope it was cached with — Excel flattens a sheet-scoped source name
- * into the book's namespace on caching and then answers `#NAME?` to the sheet-qualified citation
- * of it (measured 2026-09-11, `externalLinksNames.xlsx` + `probe-external-names-recalc.ps1`:
- * `'Data Sheet'!Local` is cached with no `sheetId`, and `'[1]Data Sheet'!Local` rebuilds to
- * `#NAME?` with the source absent), so there is no sheet-to-book fallback here.
- */
 export declare class ExternalBookBindings {
     private readonly _options;
     /** Every registered name, by the provider's key: `<scopeId>::<lowercase name>`. */

package/types/src/calculation/NamedFormulaCollection.d.ts

@@ -630,8 +630,10 @@ declare class NamedFormula extends Formula implements ICalculation.INamedFormula
      * @remarks
      * Called by the collection once the item is IN the collection, so the notification the answer
      * brings describes a set that already contains it. `getRanges()` answers once the engine has.
+     *
+     * @param loaded The body is the one the file holds: see `ICalcGrid.BodyOptions.recompile`.
      */
-    _wireNow(): void;
+    _wireNow(loaded?: boolean): void;
     /**
      * A loaded name that answers from its text: no host, or one whose grid a restore has left
      * without state (see `CalcGrid._revive`), so no compiled body.
@@ -651,8 +653,10 @@ declare class NamedFormula extends Formula implements ICalculation.INamedFormula
      * past the edit whose reader compiled the name leaves the item without a body in its grid - the
      * unmaterialized state again, with the host object still held - and the next use writes the body
      * once more rather than assuming it is there.
+     *
+     * @param loaded `false` when the text is a new definition rather than the one loaded.
      */
-    _materialize(): void;
+    _materialize(loaded?: boolean): void;
     /**
      * {@link _materialize} at the next safe point: for a caller inside the engine's own work (the
      * compile of a formula that mentions this name), where a body cannot be written.

package/types/src/calculation/TokenType.d.ts

@@ -30,16 +30,6 @@ export declare const TokenType: {
      * A function call, e.g. `SUM(...)`. `value` is the function name.
      */
     readonly Function: "function";
-    /**
-     * Function application where the callee is an EXPRESSION rather than a name — an immediately
-     * invoked lambda, `LAMBDA(a,b,a+b)(1,2)`.
-     *
-     * `inputs[0]` is the callee; `inputs[1..]` are the arguments. `value` is `null` — unlike
-     * {@link Function} there is no name to carry.
-     *
-     * A `(` binds as a call ONLY when it touches the callee's last token: `LAMBDA(x,x+1) (3)` with a
-     * space is an implicit intersection, and Excel refuses it. See DESIGN-FORMULA-APPLICATION.md.
-     */
     readonly Call: "call";
     /**
      * An error literal, e.g. `#DIV/0!` or `#REF!`.

package/types/src/calculation/_CloneBoundary.d.ts

@@ -1,27 +1,3 @@
-/**
- * The clone boundary: a test mode that treats the model/engine crossing as if it were a wire
- * (DESIGN-CALC-SERVICE §11, goal G1).
- *
- * @remarks
- * Every request into a grid and every {@link ICalcGrid.Results} out of one passes through here.
- * With the mode `off` - always, outside a test - it is an identity call and costs nothing.
- *
- * Two things it finds, and they are different:
- *
- * - What a walk can see: a function, a class instance, a value `structuredClone` refuses or
- *   silently downgrades. Each is recorded as a {@link Violation} with the PATH it sat at, which
- *   is the point: a payload that degrades silently fails somewhere else entirely, and the path
- *   is what names the field to convert.
- * - What only running can see: a reference the two sides SHARE. A walk cannot tell a run array
- *   the sheet also holds from one minted for the message; a clone does, because the sides stop
- *   agreeing. That is what `clone` mode is for, and why `audit` alone is not the exit criterion.
- *
- * Not a boundary for READS. `getValues`, `getFormulas`, `getSnapshot` and the graph walks answer
- * synchronously out of engine objects; making them push or await is §11's list, not this one.
- * This covers what is already message-shaped.
- *
- * @internal Test-mode only. Deliberately not exported from the barrel.
- */
 export declare namespace CloneBoundary {
     /**
      * `off` is the default and the only mode outside a test.

package/types/src/calculation/_FormulaToolkit.d.ts

@@ -1,9 +1,4 @@
 /** The formula toolkit's code (`./toolkit`). */
 export type FormulaToolkitModule = typeof import('./toolkit');
-/**
- * The one loader of the formula toolkit, shared by `FormulaText`, `parseFormulaLiteral` and
- * `FunctionDeclarations`: each answers from {@link FormulaToolkit.peek} and gives the answer it
- * gives for text it cannot read until the toolkit is loaded (DESIGN-CALC-SERVICE §13.25).
- */
 export declare const FormulaToolkit: import('@sheetxl/utils').LazyModule<typeof import("./toolkit")>;
 //# sourceMappingURL=_FormulaToolkit.d.ts.map

package/types/src/calculation/compiler/ASTTypes.d.ts

@@ -43,20 +43,7 @@ export interface ASTNode<T extends TokenType = TokenType, V = any> {
      * @see {@link ICalculation.FormulaToken.evalIndex}
      */
     evalIndex?: number;
-    /**
-     * Compile-time: the implicit-intersection MODE this call is evaluated in — `true` VALUE mode
-     * (a multi-cell reference at a single-value slot intersects with the formula cell), `false`
-     * ARRAY mode (it reads its first cell). Set on `Function` and `Call` nodes by
-     * `CompilerUtils.annotateImplicitIntersect` (DESIGN-IMPLICIT-INTERSECTION §2).
-     */
     implicitIntersect?: boolean;
-    /**
-     * Compile-time: under a first-cell DEMAND (a block whose every cell is its own 1x1 array-entered
-     * extent — a conditional-format body), only element `[0,0]` of this node's result is ever read,
-     * so a lift or an operator here builds that one element. Set on every node reachable from the
-     * root through elementwise positions by `CompilerUtils.annotateFirstCell`
-     * (DESIGN-LIFT-AND-DEMAND §2); inert unless the block evaluating the formula demands it.
-     */
     firstCell?: boolean;
     /**
      * Compile-time: this `+`/`-` is the root of a formula body — the formula's own root or a