@sheetxl/sdk 0.7.28-beta.4 → 0.8.0-beta.10

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

@@ -1,5 +1,5 @@
 import { IRange, Scalar, InteropScalar, IRangeStats, IRuntime } from '@sheetxl/primitives';
-import { CoordUtils, Size, Bounds } from '@sheetxl/utils';
+import { CoordUtils, Size, Bounds, Point } from '@sheetxl/utils';
 import { ITypes, ICollection, IProperties } from '../type';
 import { IWorkbook } from '../workbook';
 import { IListener } from '../listener';
@@ -7,10 +7,11 @@ import { ITransaction } from '../transaction';
 import { IResource, IResourceCollection } from '../resource';
 import { IStringCollection } from '../string';
 import { IProtection } from '../protection';
-import { IComment } from '../comment';
+import { IComment, ICommentCollection } from '../comment';
 import { IColor } from '../color';
 import { IHyperlink } from '../hyperlink';
 import { ISort } from '../sort';
+import { IAutoFill } from '../autoFill';
 import { IAnchored } from '../anchored';
 import { Anchored } from '../anchored/Anchored';
 import { IAnchoredMap } from '../anchored/IAnchoredMap';
@@ -18,38 +19,54 @@ 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';
+import { AbstractMovableContent } from '../movable/AbstractMovableContent';
+import { IChartCollection } from '../chart';
 import { IPicture } from '../picture';
+import { InsertableCollection } from '../movable/_InsertableCollection';
+import { IPivotTable, IPivotTableCollection } from '../pivot';
 import { ICell } from '../cell';
 import { ICellRange, ICellRegions, ICellRanges } from '../cellRange';
-import { IStyle, IStyleCollection } from '../style';
+import { ICellStyle, IStyleCollection } from '../style';
 import { IRangeSelection } from '../selection';
 import { IConditionalFormat, IConditionalFormatCollection } from '../conditionalFormat';
 import { IProtectedRange, IProtectedRangeCollection } from '../protectedRange';
-import { Tuple, ISortedMap, ISparseGrid, ISpatialMap, ISpatialQuery } from '../collections';
+import { Tuple, ISpatialMap, ISpatialQuery } from '../collections';
 import { ListenerEmitter } from '../listener/ListenerEmitter';
-import { RangeStats } from '../primitives';
 import { ICondition } from '../condition';
 import { ConditionalFormat } from '../conditionalFormat/ConditionalFormat';
 import { IDataValidationCollection, IDataValidation } from '../dataValidation';
 import { DataValidation } from '../dataValidation/DataValidation';
 import { ProtectedRange } from '../protectedRange/ProtectedRange';
+import { Comment } from '../comment/Comment';
+import { NoteMovable } from '../comment/NoteMovable';
+import { NoteLayout } from '../comment/_NoteBox';
 import { ISheetProtection } from '../sheetProtection';
+import { IOutline } from '../outline';
 import { ISheetHeader } from '../sheetHeader';
 import { ISheetView } from '../sheetView';
 import { ISheet } from './ISheet';
+import { ScalarListFactory } from './_ScalarListFactory';
+import { ListenerAnchor } from './_ListenerAnchor';
+import { WatchAnchor } from './_WatchAnchor';
+import { EventCategory, SheetEvents } from './_SheetEvents';
 import { SheetHeader } from '../sheetHeader/SheetHeader';
 import { SheetDirectStyle } from './style/SheetDirectStyle';
 import { IUsedRangeSpatialMap } from './style/UsedRangeSpatialMap';
-import { RangeState, CellState, State, MovableEntry, ICellRangeListenerEntry, ICellRangesListenerEntry, BeforeAfterRange, InternalTupleUpdate } from './_SheetStateTypes';
+import { RangeState, CellState, State, MovableEntry, MovableIndex, InternalTupleUpdate } from './_SheetStateTypes';
+import { CellBuffer } from './_CellBuffer';
 import { SheetReadContext, GetTypedRangeOptions, OverFlowsAndStops } from './_SheetStateReader';
-import { AutoFillProjection, AutoFillPreviewCache } from './_SheetMutations';
+import { AutoFillProjection, AutoFillPreviewCache } from './_SheetAutoFillUtils';
 import { ProtectionCheck } from './_SheetCoords';
-import { RangesListener, RangesListenerEntry } from './listener';
 import { SheetProtection } from '../sheetProtection/SheetProtection';
+import { Outline } from '../outline/Outline';
 import { SheetCellOptions } from './SheetCell';
 import { ICalculation } from '../calculation';
 import { ICalcGrid } from '../calculation/grid';
+import * as _SheetFilterUtils from './_SheetFilterUtils';
 /**
  * Implementation of {@link ISheet}.
  */
@@ -73,6 +90,28 @@ export type SheetMutationContext = ReturnType<Sheet['_buildMutationCtx']>;
  * @internal
  */
 export type SheetCoordContext = ReturnType<Sheet['_buildCoordCtx']>;
+/**
+ * What an operation hands {@link Sheet._commitWithDirectives} beyond its selection and options.
+ * @internal
+ */
+export interface CommitDirectives {
+    /** Where an undo lands, when it is not the selection. See `Sheet._recordSelection`. */
+    undo?: Partial<IRangeSelection.Coords> | null;
+    /** The axis the selection is scrolled along. */
+    axis?: IRange.Axis;
+    /** Handed to the commit. */
+    commit?: ITransaction.StoreOperationOptions;
+}
+/** The sheet's legacy drawing as it holds it: {@link ISheet.LegacyDrawingJSON} with each image resolved to its {@link IResource}, so paste and `.sxl` keep working. */
+interface LegacyDrawing {
+    xml: string;
+    images?: LegacyDrawingImage[];
+}
+interface LegacyDrawingImage {
+    /** The id {@link LegacyDrawing.xml} references this image by. */
+    id: string;
+    resource: IResource;
+}
 export declare class Sheet implements ISheet {
     protected _options: ISheet.ConstructorOptions;
     protected _id: string;
@@ -81,19 +120,50 @@ export declare class Sheet implements ISheet {
     protected _transactions: ITransaction.IStore;
     protected _ownTransactions: boolean;
     protected _transactionsRemoveListener: IListener.Remove;
-    protected _lastTransactionUUID: string | null;
+    protected _transactionsCloseRemoveListener: IListener.Remove;
+    /** The view's selection when the open root began. See {@link _onRootTransactionClose}. */
+    protected _selectionAtCommitStart: IRangeSelection.Coords | null;
+    /**
+     * The movables each closed root selects once it lands, by id. Kept per commit: other roots can
+     * close before an earlier one lands. See {@link _onRootTransactionClose}.
+     */
+    protected _movableSelectionAtCommitEnd: Map<ITransaction.ICommit, readonly string[]>;
     protected _emitter: ListenerEmitter<ISheet, ISheet.IListeners>;
     protected _initializing: boolean;
     protected _starting: Promise<void> | null;
     protected _strings: IStringCollection;
+    /** Makes the lists cell values are stored as, over `_strings`. */
+    protected _lists: ScalarListFactory;
     protected _ownStrings: boolean;
     protected _styles: IStyleCollection;
     protected _ownStyles: boolean;
     protected _stylesRemoveListener: IListener.Remove;
+    protected _languageRemoveListener?: IListener.Remove;
+    protected _regionalRemoveListener?: IListener.Remove;
     protected _stylesListener: IStyleCollection.IListeners;
-    protected _normalStyleRanged: IProperties.ICellRanged<IStyle.Properties>;
+    protected _normalStyleRanged: IProperties.ICellRanged<ICellStyle.Properties>;
     protected _resources: IResourceCollection;
     protected _ownResources: boolean;
+    /**
+     * The sheet's own legacy drawing and the header/footer's, held as read until the shapes in them
+     * have models of their own. Not sheet state: nothing edits them, so they neither transact nor
+     * notify.
+     */
+    protected _legacyDrawing: LegacyDrawing | null;
+    protected _legacyDrawingHF: LegacyDrawing | null;
+    /** The sheet's pivot tables, held as read for the same reason. */
+    protected _pivotTableCollection: IPivotTableCollection;
+    /**
+     * Anchored items whose delete this sheet announced itself.
+     *
+     * @remarks
+     * An item's `onDelete` reaches the sheet after the operation lands, and the sheet re-announces
+     * it as the collection's change — that is how a delete driven by a row or column removal is
+     * announced at all. An item deleted through its own `delete()` comes back to the sheet's
+     * `deleteFromContainer`, which announces inside the operation; it records the item here so the
+     * later `onDelete` is not a second announcement of the same delete.
+     */
+    protected _announcedDeletes: WeakSet<IAnchored>;
     protected _names: INamedCollection;
     /** Lazy sheet-anchored view over {@link _names} — see {@link getNames}. */
     protected _namesScoped: INamedCollection | null;
@@ -106,16 +176,22 @@ export declare class Sheet implements ISheet {
     protected _calculationScoped: ICalculation;
     protected _workbook: IWorkbook | null;
     protected _cacheTableColumnHeaders: TableColumnHeaders;
-    protected _rangeStats: RangeStats;
     protected _tables: ITableCollection;
     protected _conditionals: IConditionalFormatCollection;
     protected _dataValidations: IDataValidationCollection;
     protected _protectedRanges: IProtectedRangeCollection;
+    protected _comments: ICommentCollection;
     protected _movables: IMovableCollection;
+    protected _charts: IChartCollection;
     protected _emitterMovables: ListenerEmitter<IMovableCollection, ICollection.IListeners>;
-    protected _rangesListenerSorted: ISortedMap<number, RangesListener> | null;
-    protected _rangeListenerSpatial: ISpatialMap<ICellRangeListenerEntry>;
-    protected _rangesListenerMap: Map<number, ICellRangesListenerEntry>;
+    /**
+     * The callbacks for the reference nodes in `State.listeners`, keyed by node id.
+     *
+     * @remarks
+     * On the instance, never in state: a listener is an observer, not part of the document. An entry
+     * in the map with no callback here belongs to a snapshot this sheet no longer serves and is inert.
+     */
+    protected _listenerNodes: Map<number, ListenerNodeEntry>;
     protected _lastCellDecoded: {
         address: ICell.Address | null;
         coords: IRange.CellCoords | null;
@@ -156,6 +232,18 @@ export declare class Sheet implements ISheet {
     protected _protectionListener: IProtection.IListeners;
     protected _protectionRemoveListener: IListener.Remove;
     protected _tabColor: IColor | null;
+    /** VBA binding identity; carried from the file, never minted. See {@link ISheet.getCodeName}. */
+    protected _codeName: string | null;
+    protected _outline: Outline;
+    protected _conditionalFormatCalculation: boolean;
+    /**
+     * Modules this sheet owns — see {@link getModules}.
+     *
+     * Built with the sheet rather than on first ask, because building one opens a transaction and
+     * `getModules()` is a READ: a lazy build would fold an initialization commit into whatever
+     * unrelated commit happened to be the tip, every time a report walked the sheets.
+     */
+    protected _modules: ModuleCollection;
     protected _runtime: IRuntime;
     protected _isDate1904: boolean;
     protected _colHeaders: SheetHeader;
@@ -169,9 +257,19 @@ export declare class Sheet implements ISheet {
     protected _rowHeadersRemoveListener: IListener.Remove | null;
     protected _rowHeadersHiddenRemoveListener: IListener.Remove | null;
     protected _isAdjustHeaders: boolean;
+    /** Built by the movables moved in the shift under way, and taken by it when it writes. */
+    protected _shiftedMovableModels: Map<IMovable, ISpatialMap.Entry<MovableEntry>> | null;
+    /** The same for the note boxes, which shift as their own index. */
+    protected _shiftedNoteModels: Map<IMovable, ISpatialMap.Entry<MovableEntry>> | null;
+    /** The placed movables' index and the note boxes' index, as the entry builder addresses them. */
+    protected _placedIndex: MovableIndex;
+    protected _noteIndex: MovableIndex;
+    /** What every comment on this sheet places its note's box through. */
+    protected _noteBoxes: Comment.Boxes;
     protected _emptyCell: ICell;
     protected _cellOptions: SheetCellOptions;
     protected _closed: boolean;
+    protected _cellBuffer: CellBuffer | null;
     protected _defaultColWidthCache: number | null;
     protected _defaultRowHeightCache: number | null;
     protected _defaultFontBoundsCache: Readonly<Size> | null;
@@ -189,9 +287,10 @@ export declare class Sheet implements ISheet {
     _getInternal(): {
         getSheet: () => ISheet;
         getState: () => Readonly<State>;
+        getCalcGrid: () => ICalcGrid;
         isDataColumn: () => boolean;
         createRange: (coords: Readonly<IRange.FixableCoords> | string, getOptions?: ICellRange.GetRangeOptions, readOnly?: string | null) => ICellRange;
-        isContentful: (ranges: readonly IRange.Coords[], ignoreHidden?: boolean | IRange.Axis) => boolean;
+        isContentful: (ranges: readonly IRange.Coords[], ignoreHidden?: boolean | IRange.Axis, ignoreSpilled?: boolean) => boolean;
         cellToCoords: (address: ICell.Address) => IRange.CellCoords;
         rangeToCoords: (address: ICellRange.Address, protectionCheck?: ProtectionCheck | null, lookupNames?: boolean) => IRange.Coords;
         rangesToCoords: (address: ICellRanges.Address, protectionCheck?: ProtectionCheck | null | undefined, lookupNames?: boolean, requireSameSheet?: boolean, allowOutOfBounds?: boolean) => IRange.Coords[];
@@ -201,36 +300,47 @@ export declare class Sheet implements ISheet {
         cellIterator: (options: CellState.IteratorOptions) => IterableIterator<ICellRange.Entry, ICellRange.Entry, IRange.CellCoords>;
         getVisible: (coords: readonly IRange.Coords[], options?: ICellRange.GetVisibleOptions) => readonly IRange.Coords[];
         getUsedCoords: (options?: ICellRange.GetRangeOptions) => IRange.Coords | null;
-        updateTuples: (boundedTuples: Tuple.BoundedTuples<ICell.Update> | null, options?: ICellRange.UpdateCellsOptions, coordValidator?: CoordUtils.CoordValidator | null | undefined, internalOptions?: InternalTupleUpdate | null) => void;
+        updateTuples: (boundedTuples: Tuple.Region<ICell.Update> | null, options?: ICellRange.UpdateCellsOptions, coordValidator?: CoordUtils.CoordValidator | null | undefined, internalOptions?: InternalTupleUpdate | null) => void;
         merge: (ranges: readonly IRange.Coords[], options?: IRange.AxisSelection | ICellRange.MergeOptions | null) => void;
         unmerge: (ranges: readonly IRange.Coords[], options?: ITransaction.OperationOptions) => void;
         getMerges: (ranges: readonly IRange.Coords[], ignoreHidden?: boolean | IRange.Axis) => IRange.Coords[];
         insertFrom: (ranges: readonly IRange.Coords[], source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.InsertFromOptions) => Promise<IRange.Coords>;
+        canInsertFrom: (ranges: readonly IRange.Coords[], source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.InsertFromOptions) => boolean;
         insertCells: (ranges: readonly IRange.Coords[], options?: IRange.Axis | ICellRange.InsertOptions, coordValidator?: CoordUtils.CoordValidator) => void;
         deleteCells: (ranges: readonly IRange.Coords[], options?: IRange.Axis | ICellRange.DeleteOptions) => void;
-        getStyle: (ranges: IRange.Coords[], anchor?: IRangeSelection.Coords, updateStyles?: (update: IStyle.Update, options?: IStyle.UpdateOptions) => void) => IStyle;
-        updateStyles: (ranges: readonly ISpatialMap.Entry<IStyle.Update>[], defaultUpdate?: IStyle.Update, options?: IStyle.UpdateOptions, calcedNumberFormat?: boolean) => void;
+        getStyle: (ranges: IRange.Coords[], anchor?: IRangeSelection.Coords, updateStyles?: (update: ICellStyle.Update, options?: ICellStyle.UpdateOptions) => void) => ICellStyle;
+        updateStyles: (ranges: readonly ISpatialMap.Entry<ICellStyle.Update>[], defaultUpdate?: ICellStyle.Update, options?: ICellStyle.UpdateOptions, calcedNumberFormat?: boolean) => void;
         getSnapshot: (coordsFrom: readonly IRange.Coords[], optionsMark?: ICellRange.CopyOptions, getTransactionId?: () => string) => ICellRange.ISnapshot;
         getRangeStats: (coords: readonly IRange.Coords[], iteratorOptions?: ICellRange.GetStatsOptions) => IRangeStats;
         getDefaultShiftAxis: (coords?: IRange.Coords) => IRange.Axis;
         getDefaultSortCriteria: (rangeCoords: IRange.Coords, axis?: IRange.Axis, cell?: ICell.Address) => ISort.DefaultSortCriteria;
+        getDefaultAutoFillCriteria: (rangeCoords: IRange.Coords, direction?: IRange.Direction, destination?: IRange.Coords) => IAutoFill.DefaultCriteria | null;
         find: (ranges: readonly IRange.Coords[], options: string | ICellRange.FindOptions) => Iterator<ICell>;
         copyFrom: (destination: IRange.Coords, source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.CopyOptions) => Promise<IRange.Coords>;
-        contentCounts: (ranges: readonly IRange.Coords[], types: ICell.Content[] | undefined, ignoreHidden?: boolean | IRange.Axis) => Partial<Record<ICell.Content, number>>;
-        featureCounts: (ranges: readonly IRange.Coords[], features?: ICellRange.Feature | readonly ICellRange.Feature[], ignoreHidden?: boolean | IRange.Axis) => ICellRange.Counts;
+        contentCounts: (ranges: readonly IRange.Coords[], types: ICell.Content[] | undefined, ignoreHidden?: boolean | IRange.Axis, ignoreSpilled?: boolean) => Partial<Record<ICell.Content, number>>;
+        featureCounts: (ranges: readonly IRange.Coords[], features?: ICellRange.Feature | readonly ICellRange.Feature[], ignoreHidden?: boolean | IRange.Axis, ignoreSpilled?: boolean) => ICellRange.Counts;
         featureRegions: (bounds: IRange.Coords, requested: readonly ICellRange.Feature[], options?: ICellRange.GetRegionsOptions) => IRange.Coords[];
-        dependencyRanges: (coords: IRange.Coords, kind: "precedents" | "dependents", direct: boolean) => ICellRanges | null;
-        clear: (ranges: readonly IRange.Coords[], applyTo?: ICell.Content | null, options?: ITransaction.OperationOptions, excludeSorts?: boolean, isCut?: boolean) => void;
+        dependencyRanges: (coords: IRange.Coords, kind: "precedents" | "dependents", direct: boolean) => Promise<ICellRanges | null>;
+        clear: (ranges: readonly IRange.Coords[], applyTo?: ICell.Content | null, options?: ITransaction.OperationOptions, excludeSorts?: boolean, cutFrom?: IRange.Coords | null) => void;
         calculate: (ranges: ICellRanges.Coords, options?: ICalculation.CalculateOptions) => void;
         autoSelect: (options?: boolean | ICellRange.SelectOptions, selectionOverride?: Partial<IRangeSelection.Coords> | null, axis?: IRange.Axis) => Promise<IRange.Coords[]>;
+        beginCommit: (options?: ITransaction.StoreOperationOptions | string) => ITransaction;
+        recordSelection: (trans: ITransaction, selection: Partial<IRangeSelection.Coords>, options?: Pick<ICellRange.OperationOptions, "autoSelect" | "autoSelectRestore"> | null, undo?: Partial<IRangeSelection.Coords> | null, axis?: IRange.Axis) => void;
+        commitWithDirectives: (trans: ITransaction, selection: Partial<IRangeSelection.Coords> | null, options?: ICellRange.OperationOptions, directives?: CommitDirectives) => void;
         autoFit: (ranges: readonly IRange.Coords[], options?: ICellRange.AutoFitOptions) => void;
-        addRangesListeners: (ranges: readonly IRange.Coords[], listener: ICellRange.Listener, options?: ICellRange.ListenerOptions) => IListener.Remove;
-        addRangesListeners2: (ranges: readonly IRange.Coords[], listener: ICellRange.Listener, options: ICellRange.ListenerOptions | undefined, isRanges: boolean) => IListener.Remove;
+        getBestFit: (range: IRange.Coords, options?: ICellRange.BestFitOptions) => Size;
+        invalidateRendering: () => void;
+        addListenerNode: (ranges: readonly IRange.Coords[], listener: ICellRange.Listener, options?: ICellRange.ListenerOptions) => IListener.Remove;
+        addWatch: (coords: IRange.Coords, formula: ICalculation.IFormula | string, handlers: WatchAnchor.Handlers, origin?: IRange.CellCoords, options?: ICellRange.WatchOptions) => IListener.Remove;
         surroundingRegion: (range: IRange.Coords, options?: ICellRange.GetSurroundingOptions) => IRange.Coords;
+        getTraverseRegion: (cell: IRange.CellCoords, axis: IRange.Axis, reverse: boolean) => IRange.Coords | null;
         sort: (coords: Readonly<IRange.Coords>, options?: boolean | ISort.Options[] | (ISort.RangeOptions & ITransaction.OperationOptions)) => IRange.Coords;
         filter: (coords: Readonly<IRange.Coords>, condition: ICondition.Input | ICondition.RangeOptions, options?: ITransaction.OperationOptions) => Promise<IRange.Coords>;
+        evalFilter: (coords: Readonly<IRange.Coords>, condition: ICondition.Input | ICondition.RangeOptions | null | undefined) => Promise<_SheetFilterUtils.FilterRuns>;
+        applyFilterRuns: (runs: _SheetFilterUtils.FilterRuns, options?: ITransaction.OperationOptions) => void;
+        filteredTables: () => ITable[];
         setHyperlinks: (ranges: readonly ISpatialMap.Entry<IHyperlink.Update>[], defaultUpdate?: IHyperlink.Update, options?: ITransaction.OperationOptions) => void;
-        setComments: (ranges: readonly ISpatialMap.Entry<IComment.Properties>[], comments?: IComment.JSON | null, options?: ITransaction.OperationOptions) => void;
+        setComments: (ranges: readonly ISpatialMap.Entry<IComment.Update>[], comments?: IComment.Update | IComment.JSON, options?: ITransaction.OperationOptions) => void;
         getBoundsAtCoords: (coords: IRange.Coords) => Bounds;
         extendRange: (direction: IRange.Direction, cell: IRange.CellCoords) => Readonly<IRange.Coords>;
         createTupleBuilder: <T>(transpose?: boolean) => Tuple.IBuilder<T>;
@@ -247,30 +357,22 @@ export declare class Sheet implements ISheet {
      * @internal
      */
     protected _getReadCtx(): SheetReadContext;
-    /** @internal Reconciled error-VALUE view; see {@link _getErrorSpatialReconciled}. */
-    protected _errorReconciled: {
-        grid: ISparseGrid<Scalar> | null;
-        epoch: number;
-        spatial: ISpatialMap<boolean>;
-    } | null;
-    /**
-     * @internal Bumped whenever `cellValuesGrid` is mutated IN PLACE (calc realize, re-load) —
-     * grid identity alone catches every other mutation (they clone).
-     */
-    protected _errorEpoch: number;
     /**
-     * The reconciled error-VALUE spatial backing `RangeState.Type.Error` — merge-on-READ.
+     * 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
-     * `state.errorSpatial` is write-path only and stale for formula cells after a recalc, so the
-     * truth is the current values: built here by one scan of `cellValuesGrid`, cached against
-     * (grid identity, in-place epoch). The calc path pays nothing; the scan runs at agent cadence
-     * (first error-aware read after a change) and multi-altitude reads share the cache. When the
-     * calc executor emits error deltas, `state.errorSpatial` becomes fully fresh and this method
-     * reduces to returning it.
+     * 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 _getErrorSpatialReconciled(): ISpatialMap<boolean>;
+    protected _calcGrid: ICalcGrid;
+    /** `false` for a snapshot sheet, which holds its source's grid and must not close it. */
+    protected _ownsCalcGrid: boolean;
     /** @internal Cached mutation-engine context. See {@link SheetMutationContext}. */
     protected _mutationCtx: ReturnType<Sheet['_buildMutationCtx']> | null;
     /** @internal Access the mutation context (cached). See {@link SheetMutationContext}. */
@@ -288,21 +390,23 @@ export declare class Sheet implements ISheet {
         readonly columnHeadersShiftCallback: SheetHeader.ShiftCallback | null;
         getEntireCoords: () => IRange.Coords;
         getView: () => ISheetView;
-        beginCommit: (options?: ITransaction.StoreOperationOptions<CommitView> | string) => ITransaction;
+        beginCommit: (options?: ITransaction.StoreOperationOptions | string) => ITransaction;
         updateState: (updateState?: Partial<State>, options?: ITransaction.OperationOptions | string) => State;
         getState: () => Readonly<State>;
         stateFor: (trans: ITransaction) => State;
+        readonly calcGrid: ICalcGrid;
         /** Invalidate the cached used-range read (a mutation may change the used bounds). */
         invalidateUsedCoords: () => void;
         validateCoords: (coords: IRange.Coords, oobMessage?: string, allowOutOfBounds?: boolean) => void;
         protectionCheck: (check?: ProtectionCheck | null, coords?: Readonly<IRange.Coords> | readonly IRange.Coords[] | null, action?: string | null) => void;
         getDefaultShiftAxis: (coords?: IRange.Coords) => IRange.Axis;
-        processListenerShift: (rangesListenerMap: Map<number, ICellRangesListenerEntry>, beforeAfterMap: Map<number, BeforeAfterRange>, beforeStates: Map<number, ICellRangesListenerEntry>, options: ISpatialMap.ShiftDetails<ICellRangeListenerEntry>) => ISpatialMap.Entry<ICellRangeListenerEntry>[] | void;
         processLayoutChange: () => void;
+        /** The movables' by-model index as a shift left it, or `null` if the shift moved none. */
+        takeShiftedMovableModels: () => Map<IMovable, ISpatialMap.Entry<MovableEntry>> | null;
+        /** The same for the note boxes' index. */
+        takeShiftedNoteModels: () => Map<IMovable, ISpatialMap.Entry<MovableEntry>> | null;
         markColumnHeaderTableNames: () => void;
-        commitAndAutoSelect: (trans: ITransaction, selection: Partial<IRangeSelection.Coords> | null, selectOptions?: boolean | ICellRange.SelectOptions, commitOptions?: ITransaction.StoreOperationOptions<CommitView>, axis?: IRange.Axis) => Promise<IRange.Coords[]>;
-        /** Read-clone-write the `_rangeStats` cache against a new values grid. */
-        cloneRangeStats: (grid: ISparseGrid<Scalar>) => void;
+        commitWithDirectives: (trans: ITransaction, selection: Partial<IRangeSelection.Coords> | null, options?: ICellRange.OperationOptions, directives?: CommitDirectives) => void;
         readonly styles: IStyleCollection;
         getRangedEntries: <T, E = T>(spatial: ISpatialQuery, ranges: readonly IRange.Coords[], options?: GetTypedRangeOptions<T, E>, spatialSort?: boolean) => T[];
         createSparseBuilder: (options?: ICellRange.SparseBuilderOptions, sheetRange?: ICellRange | null, internal?: InternalTupleUpdate) => ICellRange.SparseBuilder;
@@ -312,27 +416,37 @@ export declare class Sheet implements ISheet {
             content: IUsedRangeSpatialMap<SheetDirectStyle>;
         }) => IUsedRangeSpatialMap<SheetDirectStyle>;
         autoFit: (ranges: readonly IRange.Coords[], options?: ICellRange.AutoFitOptions) => void;
+        recordAutoFormat: (trans: ITransaction) => void;
+        recordSkipProtectionCheck: (trans: ITransaction) => void;
+        recordFreezePanes: (trans: ITransaction, before: IRange.CellCoords, after: IRange.CellCoords) => void;
+        recordSelection: (trans: ITransaction, selection: Partial<IRangeSelection.Coords>, options?: Pick<ICellRange.OperationOptions, "autoSelect" | "autoSelectRestore"> | null, undo?: Partial<IRangeSelection.Coords> | null, axis?: IRange.Axis) => void;
         notify: (key: keyof ISheet.IListeners) => void | Promise<any>;
         getRange: (address?: ICellRange.Address, options?: ICellRange.GetRangeOptions) => ICellRange;
         getSelection: () => IRangeSelection;
         getMerges: (ranges: readonly IRange.Coords[], ignoreHidden?: boolean | IRange.Axis) => IRange.Coords[];
         indexMerges: (mergeInserts: IRange.Coords[] | null, mergeRemoves?: IRange.Coords[] | null) => void;
-        validateOrRemoveOverlaps: (rangeCoords: IRange.Coords, type: string, table?: ITable | null, removeIfContains?: boolean) => void;
+        validateOrRemoveOverlaps: (rangeCoords: IRange.Coords, type: string, table?: ITable | null, removeIfContains?: boolean, absorbAutoTable?: boolean) => void;
         autoSelect: (options?: boolean | ICellRange.SelectOptions, selectionOverride?: Partial<IRangeSelection.Coords> | null, axis?: IRange.Axis) => Promise<IRange.Coords[]>;
         readonly isDataColumn: boolean;
         readonly strings: IStringCollection;
+        readonly lists: ScalarListFactory;
         readonly cellOptions: SheetCellOptions;
         readonly runtime: IRuntime;
         getProtection: () => ISheetProtection;
         hasRangedEntries: (key: keyof State, range: IRange.Coords) => boolean;
         rangeStateIterator: (options: RangeState.IteratorOptions) => RangeState.Iterator;
-        addEvent: (type: keyof CommitEvents, value: any) => void;
+        recordChange: (trans: ITransaction, category: EventCategory, ranges: readonly IRange.Coords[] | null | undefined) => void;
+        loadComments: (map: IAnchoredMap<IComment, IComment.JSON>, refs: IRange.JSONReference<IComment.JSON>[]) => IAnchoredMap<IComment, IComment.JSON>;
+        newCommentJSON: (modifiers: IComment.Modifiers) => IComment.JSON;
+        notifyCommentsChange: () => void;
+        recordFormulasEntered: (trans: ITransaction, ranges: readonly IRange.Coords[] | null | undefined) => void;
         getTables: () => ITableCollection;
         getAutoTable: () => ITable | null;
         cellIterator: (options: CellState.IteratorOptions) => IterableIterator<ICellRange.Entry, ICellRange.Entry, IRange.CellCoords>;
+        cellStateIterator: (options?: CellState.IteratorOptions) => CellState.Iterator;
         rangeToCoords: (address: ICellRange.Address, protectionCheck?: ProtectionCheck | null, lookupNames?: boolean) => IRange.Coords;
         getCell: (address?: ICell.Address) => ICell;
-        createCell: (update: ICell.Update, coords?: IRange.CellCoords | null) => ICell;
+        createCell: (update: ICell.Update, coords?: IRange.CellCoords | null, options?: ICell.CreateCellOptions) => ICell;
         getAutoFillPreviewCache: () => AutoFillPreviewCache | null;
         setAutoFillPreviewCache: (cache: AutoFillPreviewCache) => void;
     };
@@ -351,9 +465,10 @@ export declare class Sheet implements ISheet {
         readonly internal: {
             getSheet: () => ISheet;
             getState: () => Readonly<State>;
+            getCalcGrid: () => ICalcGrid;
             isDataColumn: () => boolean;
             createRange: (coords: Readonly<IRange.FixableCoords> | string, getOptions?: ICellRange.GetRangeOptions, readOnly?: string | null) => ICellRange;
-            isContentful: (ranges: readonly IRange.Coords[], ignoreHidden?: boolean | IRange.Axis) => boolean;
+            isContentful: (ranges: readonly IRange.Coords[], ignoreHidden?: boolean | IRange.Axis, ignoreSpilled?: boolean) => boolean;
             cellToCoords: (address: ICell.Address) => IRange.CellCoords;
             rangeToCoords: (address: ICellRange.Address, protectionCheck?: ProtectionCheck | null, lookupNames?: boolean) => IRange.Coords;
             rangesToCoords: (address: ICellRanges.Address, protectionCheck?: ProtectionCheck | null | undefined, lookupNames?: boolean, requireSameSheet?: boolean, allowOutOfBounds?: boolean) => IRange.Coords[];
@@ -363,36 +478,47 @@ export declare class Sheet implements ISheet {
             cellIterator: (options: CellState.IteratorOptions) => IterableIterator<ICellRange.Entry, ICellRange.Entry, IRange.CellCoords>;
             getVisible: (coords: readonly IRange.Coords[], options?: ICellRange.GetVisibleOptions) => readonly IRange.Coords[];
             getUsedCoords: (options?: ICellRange.GetRangeOptions) => IRange.Coords | null;
-            updateTuples: (boundedTuples: Tuple.BoundedTuples<ICell.Update> | null, options?: ICellRange.UpdateCellsOptions, coordValidator?: CoordUtils.CoordValidator | null | undefined, internalOptions?: InternalTupleUpdate | null) => void;
+            updateTuples: (boundedTuples: Tuple.Region<ICell.Update> | null, options?: ICellRange.UpdateCellsOptions, coordValidator?: CoordUtils.CoordValidator | null | undefined, internalOptions?: InternalTupleUpdate | null) => void;
             merge: (ranges: readonly IRange.Coords[], options?: IRange.AxisSelection | ICellRange.MergeOptions | null) => void;
             unmerge: (ranges: readonly IRange.Coords[], options?: ITransaction.OperationOptions) => void;
             getMerges: (ranges: readonly IRange.Coords[], ignoreHidden?: boolean | IRange.Axis) => IRange.Coords[];
             insertFrom: (ranges: readonly IRange.Coords[], source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.InsertFromOptions) => Promise<IRange.Coords>;
+            canInsertFrom: (ranges: readonly IRange.Coords[], source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.InsertFromOptions) => boolean;
             insertCells: (ranges: readonly IRange.Coords[], options?: IRange.Axis | ICellRange.InsertOptions, coordValidator?: CoordUtils.CoordValidator) => void;
             deleteCells: (ranges: readonly IRange.Coords[], options?: IRange.Axis | ICellRange.DeleteOptions) => void;
-            getStyle: (ranges: IRange.Coords[], anchor?: IRangeSelection.Coords, updateStyles?: (update: IStyle.Update, options?: IStyle.UpdateOptions) => void) => IStyle;
-            updateStyles: (ranges: readonly ISpatialMap.Entry<IStyle.Update>[], defaultUpdate?: IStyle.Update, options?: IStyle.UpdateOptions, calcedNumberFormat?: boolean) => void;
+            getStyle: (ranges: IRange.Coords[], anchor?: IRangeSelection.Coords, updateStyles?: (update: ICellStyle.Update, options?: ICellStyle.UpdateOptions) => void) => ICellStyle;
+            updateStyles: (ranges: readonly ISpatialMap.Entry<ICellStyle.Update>[], defaultUpdate?: ICellStyle.Update, options?: ICellStyle.UpdateOptions, calcedNumberFormat?: boolean) => void;
             getSnapshot: (coordsFrom: readonly IRange.Coords[], optionsMark?: ICellRange.CopyOptions, getTransactionId?: () => string) => ICellRange.ISnapshot;
             getRangeStats: (coords: readonly IRange.Coords[], iteratorOptions?: ICellRange.GetStatsOptions) => IRangeStats;
             getDefaultShiftAxis: (coords?: IRange.Coords) => IRange.Axis;
             getDefaultSortCriteria: (rangeCoords: IRange.Coords, axis?: IRange.Axis, cell?: ICell.Address) => ISort.DefaultSortCriteria;
+            getDefaultAutoFillCriteria: (rangeCoords: IRange.Coords, direction?: IRange.Direction, destination?: IRange.Coords) => IAutoFill.DefaultCriteria | null;
             find: (ranges: readonly IRange.Coords[], options: string | ICellRange.FindOptions) => Iterator<ICell>;
             copyFrom: (destination: IRange.Coords, source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.CopyOptions) => Promise<IRange.Coords>;
-            contentCounts: (ranges: readonly IRange.Coords[], types: ICell.Content[] | undefined, ignoreHidden?: boolean | IRange.Axis) => Partial<Record<ICell.Content, number>>;
-            featureCounts: (ranges: readonly IRange.Coords[], features?: ICellRange.Feature | readonly ICellRange.Feature[], ignoreHidden?: boolean | IRange.Axis) => ICellRange.Counts;
+            contentCounts: (ranges: readonly IRange.Coords[], types: ICell.Content[] | undefined, ignoreHidden?: boolean | IRange.Axis, ignoreSpilled?: boolean) => Partial<Record<ICell.Content, number>>;
+            featureCounts: (ranges: readonly IRange.Coords[], features?: ICellRange.Feature | readonly ICellRange.Feature[], ignoreHidden?: boolean | IRange.Axis, ignoreSpilled?: boolean) => ICellRange.Counts;
             featureRegions: (bounds: IRange.Coords, requested: readonly ICellRange.Feature[], options?: ICellRange.GetRegionsOptions) => IRange.Coords[];
-            dependencyRanges: (coords: IRange.Coords, kind: "precedents" | "dependents", direct: boolean) => ICellRanges | null;
-            clear: (ranges: readonly IRange.Coords[], applyTo?: ICell.Content | null, options?: ITransaction.OperationOptions, excludeSorts?: boolean, isCut?: boolean) => void;
+            dependencyRanges: (coords: IRange.Coords, kind: "precedents" | "dependents", direct: boolean) => Promise<ICellRanges | null>;
+            clear: (ranges: readonly IRange.Coords[], applyTo?: ICell.Content | null, options?: ITransaction.OperationOptions, excludeSorts?: boolean, cutFrom?: IRange.Coords | null) => void;
             calculate: (ranges: ICellRanges.Coords, options?: ICalculation.CalculateOptions) => void;
             autoSelect: (options?: boolean | ICellRange.SelectOptions, selectionOverride?: Partial<IRangeSelection.Coords> | null, axis?: IRange.Axis) => Promise<IRange.Coords[]>;
+            beginCommit: (options?: ITransaction.StoreOperationOptions | string) => ITransaction;
+            recordSelection: (trans: ITransaction, selection: Partial<IRangeSelection.Coords>, options?: Pick<ICellRange.OperationOptions, "autoSelect" | "autoSelectRestore"> | null, undo?: Partial<IRangeSelection.Coords> | null, axis?: IRange.Axis) => void;
+            commitWithDirectives: (trans: ITransaction, selection: Partial<IRangeSelection.Coords> | null, options?: ICellRange.OperationOptions, directives?: CommitDirectives) => void;
             autoFit: (ranges: readonly IRange.Coords[], options?: ICellRange.AutoFitOptions) => void;
-            addRangesListeners: (ranges: readonly IRange.Coords[], listener: ICellRange.Listener, options?: ICellRange.ListenerOptions) => IListener.Remove;
-            addRangesListeners2: (ranges: readonly IRange.Coords[], listener: ICellRange.Listener, options: ICellRange.ListenerOptions | undefined, isRanges: boolean) => IListener.Remove;
+            getBestFit: (range: IRange.Coords, options?: ICellRange.BestFitOptions) => Size;
+            invalidateRendering: () => void;
+            addListenerNode: (ranges: readonly IRange.Coords[], listener: ICellRange.Listener, options?: ICellRange.ListenerOptions) => IListener.Remove;
+            addWatch: (coords: IRange.Coords, formula: ICalculation.IFormula | string, handlers: WatchAnchor.Handlers, origin?: IRange.CellCoords, options?: ICellRange.WatchOptions) => IListener.Remove;
             surroundingRegion: (range: IRange.Coords, options?: ICellRange.GetSurroundingOptions) => IRange.Coords;
+            getTraverseRegion: (cell: IRange.CellCoords, axis: IRange.Axis, reverse: boolean) => IRange.Coords | null;
             sort: (coords: Readonly<IRange.Coords>, options?: boolean | ISort.Options[] | (ISort.RangeOptions & ITransaction.OperationOptions)) => IRange.Coords;
             filter: (coords: Readonly<IRange.Coords>, condition: ICondition.Input | ICondition.RangeOptions, options?: ITransaction.OperationOptions) => Promise<IRange.Coords>;
+            evalFilter: (coords: Readonly<IRange.Coords>, condition: ICondition.Input | ICondition.RangeOptions | null | undefined) => Promise<_SheetFilterUtils.FilterRuns>;
+            applyFilterRuns: (runs: _SheetFilterUtils.FilterRuns, options?: ITransaction.OperationOptions) => void;
+            filteredTables: () => ITable[];
             setHyperlinks: (ranges: readonly ISpatialMap.Entry<IHyperlink.Update>[], defaultUpdate?: IHyperlink.Update, options?: ITransaction.OperationOptions) => void;
-            setComments: (ranges: readonly ISpatialMap.Entry<IComment.Properties>[], comments?: IComment.JSON | null, options?: ITransaction.OperationOptions) => void;
+            setComments: (ranges: readonly ISpatialMap.Entry<IComment.Update>[], comments?: IComment.Update | IComment.JSON, options?: ITransaction.OperationOptions) => void;
             getBoundsAtCoords: (coords: IRange.Coords) => Bounds;
             extendRange: (direction: IRange.Direction, cell: IRange.CellCoords) => Readonly<IRange.Coords>;
             createTupleBuilder: <T>(transpose?: boolean) => Tuple.IBuilder<T>;
@@ -466,7 +592,7 @@ export declare class Sheet implements ISheet {
      * @param searchTypes If value is in record it will be search, boolean flag is used for fullyEnclosed.
      * @internal
      */
-    protected _collectRanges(queryCoords: IRange.Coords, rangesByType?: ISpatialMap.Entry<RangeState.Intersection>[], searchTypes?: boolean | RangeState.SearchTypes | null, state?: State, injectReferences?: IRange.JSONReference<any>[][]): void;
+    protected _collectRanges(queryCoords: IRange.Coords, rangesByType?: ISpatialMap.Entry<RangeState.Intersection>[], searchTypes?: boolean | RangeState.SearchTypes | null, state?: State, injectReferences?: IRange.JSONReference<any>[][], transaction?: ITransaction | null): void;
     /**
      * This wraps the stateIterator with a ICell.IteratorContext.
      * // TODO - **PERFORMANCE** We are creating a new CellState on very call
@@ -513,8 +639,23 @@ export declare class Sheet implements ISheet {
         content: IUsedRangeSpatialMap<SheetDirectStyle>;
     }): IUsedRangeSpatialMap<SheetDirectStyle>;
     /** @internal Logic lives in `_SheetMutations.updateStyles`. */
-    protected _updateStyles(ranges: readonly ISpatialMap.Entry<IStyle.Update>[], defaultUpdate?: IStyle.Update, // we do this because updateTuples may update each
-    options?: IStyle.UpdateOptions, calcedNumberFormat?: boolean): void;
+    protected _updateStyles(ranges: readonly ISpatialMap.Entry<ICellStyle.Update>[], defaultUpdate?: ICellStyle.Update, // we do this because updateTuples may update each
+    options?: ICellStyle.UpdateOptions, calcedNumberFormat?: boolean): void;
+    /**
+     * Holds a style set on one cell in the buffer the cell writes of an open transaction are held in
+     * ({@link CellBuffer.holdStyle}).
+     *
+     * @returns `false` if it is to be written as it comes.
+     * @internal
+     */
+    protected _holdStyle(range: ISpatialMap.Entry<ICellStyle.Update>, defaultUpdate?: ICellStyle.Update, options?: ICellStyle.UpdateOptions): boolean;
+    /**
+     * Whether a style update written to one cell changes that cell alone; a caller's callback is not
+     * known to. (The style typed input implies is not asked: it is a number format, a quote prefix or
+     * a wrap.)
+     * @internal
+     */
+    protected _isLocalStyle(state: Readonly<State>, rowIndex: number, colIndex: number, update: ICellStyle.Update): boolean;
     /** @internal */
     protected _createSparseBuilder(options?: ICellRange.SparseBuilderOptions, sheetRange?: ICellRange | null, internal?: InternalTupleUpdate): ICellRange.SparseBuilder;
     /**
@@ -522,11 +663,20 @@ export declare class Sheet implements ISheet {
      * Logic lives in `_SheetMutations.updateTuples`.
      * @internal
      */
-    protected _updateTuples(boundedTuples: Tuple.BoundedTuples<ICell.Update> | null, options?: ICellRange.UpdateCellsOptions, coordValidator?: CoordUtils.CoordValidator | null | undefined, internalOptions?: InternalTupleUpdate | null): void;
+    protected _updateTuples(boundedTuples: Tuple.Region<ICell.Update> | null, options?: ICellRange.UpdateCellsOptions, coordValidator?: CoordUtils.CoordValidator | null | undefined, internalOptions?: InternalTupleUpdate | null): void;
+    /**
+     * The buffer single-cell writes made inside an open transaction are held in ({@link CellBuffer}).
+     * @internal
+     */
+    protected _getCellBuffer(): CellBuffer;
     /** @internal */
     protected _sort(coords: Readonly<IRange.Coords>, options?: boolean | ISort.Options[] | ISort.RangeOptions & ITransaction.OperationOptions): IRange.Coords;
     /** @internal */
     protected _filter(coords: Readonly<IRange.Coords>, condition: ICondition.Input | ICondition.RangeOptions, options?: ITransaction.OperationOptions): Promise<IRange.Coords>;
+    /** @internal The read-only half of {@link _filter}: settles the runs without writing. */
+    protected _evalFilter(coords: Readonly<IRange.Coords>, condition: ICondition.Input | ICondition.RangeOptions | null | undefined): Promise<_SheetFilterUtils.FilterRuns>;
+    /** @internal The write half of {@link _filter}: inside the caller's open transaction. */
+    protected _applyFilterRuns(runs: _SheetFilterUtils.FilterRuns, options?: ITransaction.OperationOptions): void;
     /** @internal Logic lives in `_SheetMutations.autoFill`. */
     protected _autoFill(template: IRange.Coords, destination: IRange.Coords, options?: ICellRange.AutoFillOptions): boolean | AutoFillProjection;
     /** @internal Logic lives in `_SheetMutations.autoFillRange`. */
@@ -536,8 +686,67 @@ export declare class Sheet implements ISheet {
     /** @internal Logic lives in `_SheetMutations.setHyperlinks`. */
     protected _setHyperlinks(ranges: readonly ISpatialMap.Entry<IHyperlink.Update>[], defaultUpdate?: IHyperlink.Update, // we do this because updateTuples may update each
     options?: ITransaction.OperationOptions): void;
-    /** @internal */
+    /**
+     * The request options for a grid call made under `transaction`: the snapshot it names and the
+     * savepoint its maps are cloned under.
+     * @internal
+     */
+    protected _requestFor(transaction: ITransaction | null): ICalcGrid.RequestOptions;
+    /**
+     * The formats the entered cells of the blocks inherit, as of a commit.
+     *
+     * Excel's entry rule: a formula typed into a General cell takes the number format of the first
+     * cell it reads that has one - `=A1+B1` shows currency when `A1` does. Which cells, and in what
+     * order, the engine reports with the results ({@link ICalcGrid.Results.formatInserts}); which
+     * formats they carry is read from the ENTERING commit's snapshot, so a pass that comes late -
+     * after an engine start, or an F9 under manual calculation - sees the inputs as they were when
+     * the formula was entered, whatever was formatted since. Never through a name.
+     *
+     * @remarks
+     * Range-shaped, not per cell. A relative reference names a different cell from each cell of
+     * its block, so the cells a block reads through it are a rectangle the block's size offset by
+     * the reference; the styled entries found there are shifted back onto the block. A fixed axis
+     * reads one row or column for the whole block. A reference stands for its top-left cell.
+     * References are written from the last to the first, so the first reference that formats a
+     * cell is the one that stands - "the first that is not General", per cell.
+     * @internal
+     */
+    protected _resolveInheritedFormats(commitId: string, blocks: readonly EnteredBlock[], entered: readonly IRange.Coords[]): ISpatialMap.Entry<ICellStyle.Update>[];
+    /**
+     * Land a record the engine pushed - a pass's results, a seed's - in the sheet's snapshots.
+     *
+     * @remarks
+     * The record names the snapshot it answers for (`commitId`). Everything it says about cells -
+     * the formulas, the values, the spills, the errors, the pending and circular marks - has been
+     * landed in the grid's own snapshots by the time this runs, and a record naming a snapshot off
+     * the live history never reaches here at all. What is left is the sheet's: what is PROMOTED -
+     * number formats, sizes - amended into the commit that entered the formulas, and the
+     * notifications, which realize has to make by hand.
+     * @internal
+     */
     protected _realizeCalcedValues(results: ICalcGrid.Results): void;
+    /**
+     * Land the promoted half of a pass's results - number formats and sizes - in the commit that
+     * entered the formulas they belong to.
+     *
+     * @remarks
+     * Excel's rule: entering a formula formats and fits it; recalculating it does not. So the set is
+     * the formulas the target commit entered on this sheet, clipped to what this pass realized; the
+     * directives are the target's own (`autoFormat`, `autoFit`); and once resolved the sheet is
+     * marked on the target ({@link IntentCalcResolved}), so a later pass for the same commit - a
+     * dependent on another sheet, an explicit recalculation, the pass a redo triggers - leaves what
+     * is now in the snapshot alone. The mark is written with the sheet's record so that it lands
+     * even when nothing was promoted; an amend with no writes is elided. It is written only by a
+     * pass that realized the entered cells: an engine starting up runs a pass that realizes
+     * nothing before the one that carries the results.
+     *
+     * The number format is the engine's pick per cell ({@link ICalcGrid.Results.formatInserts}):
+     * the references the formula inherits one from, resolved here against the entering commit's
+     * snapshot ({@link _resolveInheritedFormats}), or else the format its functions supplied.
+     *
+     * @internal
+     */
+    protected _promoteCalcResults(target: ITransaction.ICommit, results: ICalcGrid.Results): void;
     /** {@inheritDoc ISheet.calculate} */
     calculate(full?: boolean): Promise<ICalculation.Status>;
     /** @internal */
@@ -546,10 +755,10 @@ export declare class Sheet implements ISheet {
     protected _calculateFull(): void;
     /** @internal */
     /** @internal Logic lives in `_SheetMutations.setComments`. */
-    protected _setComments(ranges: readonly ISpatialMap.Entry<IComment.Properties>[], comments?: IComment.JSON | null, // we do this because updateTuples may update each
+    protected _setComments(ranges: readonly ISpatialMap.Entry<IComment.Update>[], comments?: IComment.Update | IComment.JSON, // `undefined` = each entry carries its own (updateTuples)
     options?: ITransaction.OperationOptions): void;
     /** @internal Logic lives in `_SheetMutations.clear`. */
-    protected _clear(ranges: readonly IRange.Coords[], applyTo?: ICell.Content | null, options?: ITransaction.OperationOptions, excludeSorts?: boolean, isCut?: boolean): void;
+    protected _clear(ranges: readonly IRange.Coords[], applyTo?: ICell.Content | null, options?: ITransaction.OperationOptions, excludeSorts?: boolean, cutFrom?: IRange.Coords | null): void;
     /** @internal Logic lives in `_SheetMutations.merge`. */
     protected _merge(ranges: readonly IRange.Coords[], options?: IRange.AxisSelection | ICellRange.MergeOptions | null): void;
     /** @internal Logic lives in `_SheetMutations.unmerge`. */
@@ -572,16 +781,58 @@ export declare class Sheet implements ISheet {
     protected _snapShotFromSource(source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.CopyOptions): ICellRange.ISnapshot;
     /** @internal */
     protected _copyFrom(destination: IRange.Coords, source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.CopyOptions): Promise<IRange.Coords>;
+    /**
+     * Where a {@link _copyFrom} lands, and whether the merges there let it - Excel's rules:
+     *
+     * - A cut lands the source's own size at the destination's top-left (it can't tile).
+     * - A single cell - or one merged cell - copied onto exactly one merged cell fills that merge,
+     *   bigger or not (the snapshot pastes it values-only). A cut gets no such treatment.
+     * - A copy that would cut through a merge is refused, its own source's included.
+     * - A cut destroys the merges it lands across instead - but not its OWN merge, which it would have
+     *   to tear in two; that is refused (Excel silently loses the merge).
+     *
+     * Runs inside the copy's transaction: the merges a cut destroys roll back with it.
+     * @internal
+     */
+    protected _resolveCopyDestination(destination: IRange.Coords, snapshot: ICellRange.ISnapshot, options: ICellRange.CopyOptions | undefined, isCut: boolean): IRange.Coords;
     /** {@inheritDoc ISheet.addAutoTable} */
     addAutoTable(address?: ICellRange.Address, options?: ICellRange.AddAutoTableOptions): ITable;
     /** {@inheritDoc ISheet.getAutoTable} */
     getAutoTable(): ITable | null;
+    /**
+     * The tables on this sheet that hold a filter condition: the AutoTable, then the tables. What
+     * makes the sheet "filtered" ({@link ISheetHeader.getFilteredRanges}).
+     */
+    private _filteredTables;
+    /**
+     * Tells the grid whether this sheet is filtered now ({@link _filteredTables}), from
+     * inside the operation that may have changed it: a table's condition set or cleared, a table
+     * added or deleted. The grid writes only a different answer, so telling it more often than it
+     * changes costs a walk of the tables. A restore is not told, as {@link _tellHidden}.
+     */
+    protected _tellFiltered(): void;
     /** @internal */
     protected _getDefaultShiftAxis(coords?: IRange.Coords): IRange.Axis;
     /** @internal */
     protected _getTables(address: ICellRanges.Address, ignoreHidden?: boolean, fullyContained?: boolean): ITable[];
     /** @internal */
+    protected _getDefaultAutoFillCriteria(rangeCoords: IRange.Coords, direction?: IRange.Direction, destination?: IRange.Coords): IAutoFill.DefaultCriteria | null;
+    /** @internal */
     protected _getDefaultSortCriteria(rangeCoords: IRange.Coords, axis?: IRange.Axis, cell?: ICell.Address): ISort.DefaultSortCriteria;
+    /**
+     * The refusal an {@link ICellRange.insertFrom} would raise, as a localized message - `null` when it
+     * would go through. Asked BEFORE anything is committed, both by `_insertFrom` itself (so a refusal
+     * leaves nothing to roll back and carries the message that fits the reason) and by the public
+     * `canInsertFrom`, which is what lets a drag preview show a drop as refused before it is attempted.
+     *
+     * @internal
+     */
+    protected _getInsertFromRefusal(coordsInsert: IRange.Coords, coordsCut: IRange.Coords, axis: IRange.Axis, isCut: boolean, isSameSheet: boolean): string | null;
+    /**
+     * {@inheritDoc ICellRange.canInsertFrom}
+     * @internal
+     */
+    protected _canInsertFrom(ranges: readonly IRange.Coords[], source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.InsertFromOptions): boolean;
     /** @internal */
     protected _insertFrom(ranges: readonly IRange.Coords[], source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.InsertFromOptions): Promise<IRange.Coords>;
     /**
@@ -608,26 +859,177 @@ export declare class Sheet implements ISheet {
      * Implementation lives in `_SheetAutoFitUtils` (same pattern as `_SheetSortUtils.doSort`).
      */
     protected _autoFit(ranges: readonly IRange.Coords[], options?: ICellRange.AutoFitOptions): void;
+    /**
+     * The size a range's content needs, without writing it. See {@link ICellRange.getBestFit}.
+     *
+     * @internal
+     */
+    protected _getBestFit(range: IRange.Coords, options?: ICellRange.BestFitOptions): Size;
     /** @internal */
     protected _createRangeEvent(coords: (readonly IRange.FixableCoords[]) | IRange.FixableCoords, options: NotifierOptions, coordsFrom?: (readonly IRange.FixableCoords[]) | IRange.FixableCoords): ICellRange.Event;
     /**
-     * Notifies listeners with a range.
+     * Register a reference node for a range listener.
+     *
+     * @remarks
+     * The node is written into the anchored map by an AMEND on the current commit, so registering
+     * never becomes an undo step, and every snapshot from this commit forward carries the node at
+     * whatever coords it has then. That one write is where the whole contract comes from: undo to a
+     * snapshot at or after registration and the node is there, at the coords of that moment; undo to
+     * one from BEFORE it and the map simply has no entry, which is what `#N/A` is.
+     *
+     * The callback never enters state - it is held on the instance, keyed by node id.
+     *
      * @internal
      */
-    protected _notifyAddressListeners(listenerMapAll: Map<string, RangesListener>, listenerMapEvent: Map<string, RangesListener | null>, // address-only events store null values
-    visited: Set<string>, options: NotifierOptions): void;
+    protected _addListenerNode(ranges: readonly IRange.Coords[], listener: ICellRange.Listener, options?: ICellRange.ListenerOptions): IListener.Remove;
     /**
-     * Notifies listeners with a range.
+     * {@link _addListenerNode}, also handing back the node, for a caller that reads its coords.
      * @internal
      */
-    protected _notifyDataListeners(spatialMap: ISpatialMap<RangesListenerEntry>, listenerMap: Map<string, RangesListener>, ranges: (readonly IRange.FixableCoords[] | null) | undefined, visited: Set<string>, options: NotifierOptions): void;
+    protected _registerListenerNode(ranges: readonly IRange.Coords[], listener: ICellRange.Listener, options?: ICellRange.ListenerOptions, createNode?: (options: ListenerAnchor.ConstructorOptions) => ListenerAnchor): {
+        node: ListenerAnchor;
+        remove: IListener.Remove;
+    };
     /**
-     * Notifies listeners with a range.
+     * Register a watch: an expression kept evaluated over a range.
+     *
+     * @remarks
+     * A watch is a range listener that fires on formula evaluation - see {@link WatchAnchor}. Its
+     * location is a node in `State.listeners`, and its body is a formula block in a grid of its own
+     * that shadows this sheet, written at the watched coords exactly as if it had been typed there.
+     * A watch is allowed to overlap other formulas, which is why the body has a grid of its own: the
+     * sheet's formula map holds one formula per cell, and a validation, a conditional format and a
+     * real formula can all sit on D1:D3 at once.
+     *
+     * Registration waits for the engine and never starts it: a watch added while calculation is off
+     * delivers nothing until calculation is started, and registers then. It lands as one amend: the node, the grid and the body join the current commit, so a
+     * watch is never an undo step. A snapshot older than the watch has neither, which is `#N/A`.
+     * The first delivery is the first pass that evaluates the body.
+     *
+     * @param coords The range the body is evaluated over.
+     * @param formula The expression, authored at `origin`, or a compiled formula anchored at
+     *                `coords`' top-left.
+     * @param handlers `onValues` receives the body's values after every pass that changed them;
+     *                 `onChange` is told that an evaluation happened, without the values.
+     * @param origin Where `formula` is authored when it is not `coords`' own top-left: the shared
+     *               origin of a multi-area watch, from which the body is filled to `coords`.
+     * @param options `arrayFirstCell`: every cell of the body is its own 1x1 array-entered formula.
      * @internal
      */
-    protected _notifyRangeListeners(spatial: ISpatialMap<ICellRangeListenerEntry>, listenerMap: Map<number, ICellRangesListenerEntry>, ranges: (readonly IRange.FixableCoords[] | null) | undefined, notificationOptions: NotifierOptions): void;
-    /** @internal */
-    protected _notifyRangeListener2(entry: ICellRangesListenerEntry, event?: ICellRange.Event | null, notificationOptions?: NotifierOptions | null): void;
+    protected _addWatch(coords: IRange.Coords, formula: ICalculation.IFormula | string, handlers: WatchAnchor.Handlers, origin?: IRange.CellCoords, options?: ICellRange.WatchOptions): IListener.Remove;
+    /**
+     * The one amend that creates a watch: its node, its grid and its body.
+     *
+     * @remarks
+     * Everything about the BODY is the node's ({@link WatchAnchor.reconcile},
+     * {@link WatchAnchor.deliver}). What is here is what every listener gets from the sheet: the
+     * node in the versioned map, the entry that holds its callbacks, and the removal.
+     * @internal
+     */
+    protected _registerWatch(coords: IRange.Coords, expression: string, authoredAt: IRange.CellCoords, handlers: WatchAnchor.Handlers, arrayFirstCell: boolean): IListener.Remove;
+    /**
+     * A watch's body is a grid the engine holds once, for every snapshot, so a watch is made and
+     * removed against the commit the store is at. Inside an amend of any other commit its node and
+     * its grid's maps would land in that snapshot alone: the engine would hold a grid the current
+     * snapshot has no record of, and removing it later would leave the engine its body.
+     */
+    protected _ensureWatchAtCurrent(action: 'added' | 'removed'): void;
+    /**
+     * The `addWatch` a content is given: holds a formula that belongs to no cell - a chart's
+     * series, a control's linked cell - in the calculation engine, and tells the content each time
+     * the engine rewrites it.
+     *
+     * @remarks
+     * One unanchored formula host per call, its body authored at `origin` (the content's anchor
+     * top-left unless given), exactly as a defined name's body is held: the engine keeps its
+     * references on the cells they name, so an insert or delete rewrites them, a cut carries them, a
+     * deleted sheet leaves `#REF!`, and undo puts all of it back. The body demands its first cell
+     * only, so holding a reference to a column costs a pass one read, not the column.
+     *
+     * The callback carries a {@link HeldFormula}, a live view over the host: every read answers the
+     * body as the store holds it now. It is delivered once the engine has compiled the body and
+     * again after every change to its text - a structural edit, a pass that rewrote it, a restore.
+     *
+     * Registration waits for the engine's next safe point and then amends the current commit, as a
+     * watch's does. An engine that is never started holds nothing, and the content reads its text as
+     * set. A formula the engine cannot compile is not held either.
+     *
+     * A {@link HeldFormula} handed back in - a content restored after a delete re-holding what it
+     * had - attaches to the grid the formula lived in when that grid came back with the restore, and
+     * is held afresh from the formula's last text otherwise.
+     *
+     * @param getAnchor The content's anchor top-left, read when the watch registers.
+     * @internal
+     */
+    _contentAddWatch(getAnchor: () => IRange.CellCoords | null): AbstractMovableContent.AddWatch;
+    /**
+     * Carry every reference a cut encloses from its source to its destination.
+     *
+     * @remarks
+     * A cut moves cells, and everything that NAMES those cells goes with them - which is what the
+     * calc graph does for a formula precedent (`movePrecedents`), and what a range listener's
+     * reference and a watch's location must do for the same reason and by the same rule: the cut
+     * carries a reference only when it fully encloses it. Cut B2 to D5 and a listener on B2 reads
+     * D5; cut a block that merely clips the reference and it stays put, pointing at cells that are
+     * now empty.
+     *
+     * Called from the cut path beside the calc grid's own move, so the two land in one commit and
+     * one undo puts both back. A watch's body follows its node from the node's own address event
+     * at commit end (see {@link WatchAnchor.reconcile}).
+     *
+     * @param from The cut's source.
+     * @param to Where the cut's source lands.
+     * @internal
+     */
+    protected _moveReferences(from: IRange.Coords, to: IRange.Coords): void;
+    /**
+     * Drop a node from the current snapshot.
+     *
+     * @remarks
+     * The same amend as registering. Older snapshots keep the entry; one whose callback is gone from
+     * the instance is inert, and is swept the next time this runs.
+     *
+     * @internal
+     */
+    protected _removeListenerNode(node: ListenerAnchor): void;
+    /**
+     * Deliver to every node whose reference intersects what changed.
+     *
+     * @remarks
+     * A transactional node is told from inside the transaction, before the commit seals, so what it
+     * writes joins that commit; every other node is told once the store has settled. The two are
+     * never told from the same place, so `transactional` selects which half this call is for.
+     *
+     * `ranges` is the commit's change set, so a batch of operations is ONE change to a node: it is
+     * told once, carrying every range of the commit that reached it.
+     *
+     * @internal
+     */
+    protected _notifyListenerNodes(state: State, ranges: readonly IRange.Coords[] | null, notificationOptions: NotifierOptions, transactional: boolean, renamed?: boolean): void;
+    /**
+     * Deliver to every live node whose reference is no longer where it was.
+     *
+     * @remarks
+     * Nothing is compared against the log, and the direction the store moved does not matter. The
+     * map either holds the node - at whatever coords it has in THIS snapshot - or it does not, and
+     * each case answers itself: a difference from the coords last delivered is an `address` change,
+     * and no entry at all is `#N/A`, a world from before the node was registered.
+     *
+     * `transactional` selects which nodes this call is for (see {@link _notifyListenerNodes}). With
+     * `notificationOptions` `null` the nodes are only re-based - their last-delivered coords are set
+     * to this snapshot's without a delivery. That is a restore seen by a transactional node: it is
+     * never told about one, but the next forward move must be measured from where the restore left
+     * the reference, not from where it was before.
+     *
+     * @internal
+     */
+    protected _notifyListenerNodeMoves(state: State, transactional: boolean, notificationOptions: NotifierOptions | null): void;
+    /**
+     * One delivery, after the option filters.
+     *
+     * @internal
+     */
+    protected _deliverToNode(entry: ListenerNodeEntry, trigger: 'data' | 'address' | 'restore', notificationOptions: NotifierOptions, from?: readonly IRange.Coords[]): void;
     /** @internal */
     protected _notifyUsedRangeChange(): void;
     /** @internal */
@@ -641,29 +1043,37 @@ export declare class Sheet implements ISheet {
      */
     protected _notifyConditionalFormatsChange(): void;
     /** {@inheritDoc Sheet._notifyConditionalFormatsChange} @internal */
+    protected _notifyTablesChange(): void;
+    /** {@inheritDoc Sheet._notifyConditionalFormatsChange} @internal */
     protected _notifyDataValidationsChange(): void;
     /** {@inheritDoc Sheet._notifyConditionalFormatsChange} @internal */
     protected _notifyProtectedRangesChange(): void;
+    /** {@inheritDoc Sheet._notifyConditionalFormatsChange} @internal */
+    protected _notifyCommentsChange(): void;
+    /**
+     * Presents one of the sheet's own events as a collection's `onCollectionChange`, and the
+     * sheet's `onInvalidated` as the collection's, with the collection as the source of both.
+     *
+     * @remarks
+     * The sheet keeps the state and fires the fine-grained event; the collection is a front over
+     * it. Forwarding, rather than a second emitter, is what keeps the two from drifting apart.
+     * @internal
+     */
+    protected _forwardCollectionListeners(key: 'onTablesChange' | 'onConditionalFormatsChange' | 'onDataValidationsChange' | 'onProtectedRangesChange' | 'onCommentsChange', collection: () => ICollection<any>): (listeners: ICollection.IListeners, options?: IListener.Options) => IListener.Remove;
     /** {@inheritDoc ISheet.addListeners} */
     addListeners(listeners: ISheet.IListeners, options?: IListener.Options): IListener.Remove;
     /** @internal */
-    protected _addRangesListeners(ranges: readonly IRange.Coords[], listener: ICellRange.Listener, options?: ICellRange.ListenerOptions): IListener.Remove;
-    /** @internal */
-    protected _addRangesListeners2(ranges: readonly IRange.Coords[], listener: ICellRange.Listener, options: ICellRange.ListenerOptions | undefined, isRanges: boolean): IListener.Remove;
-    /** @internal */
     protected _getUsedCoords(options?: ICellRange.GetRangeOptions): IRange.Coords | null;
     /** @internal */
     protected _getRangeStats(coords: readonly IRange.Coords[], iteratorOptions?: ICellRange.GetStatsOptions): IRangeStats;
     /** @internal */
-    protected _isContentful(ranges: readonly IRange.Coords[], ignoreHidden?: boolean | IRange.Axis): boolean;
-    /** @internal */
-    protected _getCount(coords: IRange.Coords[], ignoreHidden?: boolean): number;
+    protected _isContentful(ranges: readonly IRange.Coords[], ignoreHidden?: boolean | IRange.Axis, ignoreSpilled?: boolean): boolean;
     /**
-     * Legacy Content-keyed counting — internal callers only (`clear` preflight, `_getCount`).
+     * Legacy Content-keyed counting — internal callers only (`clear` preflight).
      * The public path is `_featureCounts`, keyed by `ICellRange.Feature`.
      * @internal
      */
-    protected _contentCounts(ranges: readonly IRange.Coords[], types: ICell.Content[] | undefined, ignoreHidden?: boolean | IRange.Axis): Partial<Record<ICell.Content, number>>;
+    protected _contentCounts(ranges: readonly IRange.Coords[], types: ICell.Content[] | undefined, ignoreHidden?: boolean | IRange.Axis, ignoreSpilled?: boolean): Partial<Record<ICell.Content, number>>;
     /**
      * Per-feature cell counts — the engine behind `ICellRange.getCounts`.
      *
@@ -678,7 +1088,7 @@ export declare class Sheet implements ISheet {
      * by a real, directly indexed feature (`DateFormat`).
      * @internal
      */
-    protected _featureCounts(ranges: readonly IRange.Coords[], features?: ICellRange.Feature | readonly ICellRange.Feature[], ignoreHidden?: boolean | IRange.Axis): ICellRange.Counts;
+    protected _featureCounts(ranges: readonly IRange.Coords[], features?: ICellRange.Feature | readonly ICellRange.Feature[], ignoreHidden?: boolean | IRange.Axis, ignoreSpilled?: boolean): ICellRange.Counts;
     /**
      * Calculation-graph neighbors of a range — the engine behind `ICellRange`'s and `ICell`'s
      * precedents/dependents family.
@@ -690,7 +1100,17 @@ export declare class Sheet implements ISheet {
      * removing it would answer a different question than "what does this block read".
      * @internal
      */
-    protected _dependencyRanges(coords: IRange.Coords, kind: 'precedents' | 'dependents', direct: boolean): ICellRanges | null;
+    protected _dependencyRanges(coords: IRange.Coords, kind: 'precedents' | 'dependents', direct: boolean): Promise<ICellRanges | null>;
+    /**
+     * Name ids -> the range objects that carry them in a graph answer.
+     *
+     * @remarks
+     * The id half of step 3. Liveness and "is this actually a name" were already applied by the
+     * grid; an id that no longer resolves simply drops. Each node is anchored on ITS OWN sheet
+     * (the name's defining cell), which is why the internal is re-resolved per id.
+     * @internal
+     */
+    private _namedGraphRanges;
     /**
      * Calc-currency scopes → range-currency scopes: the boundary the whole scope model rests on.
      *
@@ -728,10 +1148,8 @@ export declare class Sheet implements ISheet {
      * requested features are elided. `features` arrives already resolved (`resolveRegionFeatures`).
      *
      * Known v1 bounds, recorded in AGENT-PLAN B2: the blank/complement side of the partition is
-     * not yielded; regions for the projected style features (`NumberFormat`/`Alignment`/`Font`)
-     * are correct but may be finer than maximal (the shared content-style map splits on parts the
-     * projection ignores). Every requested feature partitions — there is no unsupported-feature
-     * throw left in this function.
+     * not yielded. Every requested feature partitions — there is no unsupported-feature throw left
+     * in this function.
      * @internal
      */
     protected _featureRegions(bounds: IRange.Coords, requested: readonly ICellRange.Feature[], options?: ICellRange.GetRegionsOptions): IRange.Coords[];
@@ -743,6 +1161,12 @@ export declare class Sheet implements ISheet {
     protected _find(ranges: readonly IRange.Coords[], options: string | ICellRange.FindOptions): Iterator<ICell>;
     /** {@inheritDoc ISheet.getRuntime} */
     getRuntime(): IRuntime;
+    /**
+     * The region a bare-cursor traverse from `cell` wraps within, or `null` for a plain move. A table
+     * under the cursor answers for itself.
+     * @internal
+     */
+    protected _getTraverseRegion(cell: IRange.CellCoords, axis: IRange.Axis, reverse: boolean): IRange.Coords | null;
     /** @internal */
     protected _surroundingRegion(range: IRange.Coords, options?: ICellRange.GetSurroundingOptions): IRange.Coords;
     /** @internal */
@@ -772,8 +1196,189 @@ export declare class Sheet implements ISheet {
     scrollTo(coords: Partial<IRange.Coords>, options?: ISheet.ScrollToOptions): Promise<boolean>;
     /** @internal */
     protected _resolveSelectOptions(selectOptions: boolean | ICellRange.SelectOptions, axis?: IRange.Axis): ICellRange.SelectOptions | null;
-    /** @internal */
-    protected _commitAndAutoSelect(trans: ITransaction, selection: Partial<IRangeSelection.Coords> | null, selectOptions?: boolean | ICellRange.SelectOptions, commitOptions?: ITransaction.StoreOperationOptions<CommitView>, axis?: IRange.Axis): Promise<IRange.Coords[]>;
+    /**
+     * Record the operation's directives over what it produced, then commit.
+     *
+     * @remarks
+     * `options` is the object the operation was handed, so what it declares through
+     * {@link ICellRange.OperationOptions} is what is honored here: `autoSelect` names where the
+     * operation leaves the user, `autoFit` fits the ranges it produced. Both are read from the one
+     * object, so an operation cannot accept a directive it then ignores.
+     *
+     * @internal
+     */
+    protected _commitWithDirectives(trans: ITransaction, selection: Partial<IRangeSelection.Coords> | null, options?: ICellRange.OperationOptions, directives?: CommitDirectives): void;
+    /**
+     * Declare where the operation leaves the user, and where an undo of it lands when that is not
+     * the same place.
+     *
+     * @param selection Where the operation leaves the user - what it acted on, or what it produced
+     * when that is somewhere else (a paste fitted to its source). Also where a redo lands.
+     * @param options The operation's own options, passed through as they were given: its `autoSelect`
+     * and `autoSelectRestore`.
+     * @param undo Where an undo lands, when it is not `selection`: a cut-drag and an insert-from
+     * undo to the SOURCE, an auto-fill to the TEMPLATE it was dragged from.
+     *
+     * @remarks
+     * A declaration, never an action: every operation declares, whatever it was asked, and whether
+     * the view moves - now, on undo or on redo - is decided once, when the commit closes
+     * ({@link resolveSelection}).
+     *
+     * @internal
+     */
+    protected _recordSelection(trans: ITransaction, selection: Partial<IRangeSelection.Coords>, options?: Pick<ICellRange.OperationOptions, 'autoSelect' | 'autoSelectRestore'> | null, undo?: Partial<IRangeSelection.Coords> | null, axis?: IRange.Axis): void;
+    /**
+     * Where an undo or a redo of a commit puts this sheet's view, or `null` when it leaves it
+     * alone. See {@link resolveSelection}.
+     *
+     * @remarks
+     * A sheet can be shown through more than one view, and a view instance is replaced on load and
+     * by {@link setView}, so the match is on {@link ISheetView.getId}.
+     *
+     * @internal
+     */
+    protected _restoredSelection(intents: Readonly<Record<string, any>> | undefined, isUndo: boolean): {
+        selection: Partial<IRangeSelection.Coords>;
+        options: boolean | ICellRange.SelectOptions;
+    } | null;
+    /**
+     * Record what this operation has to announce when it lands, under one category.
+     *
+     * @remarks
+     * Recorded as the `sheet.events` intent on the ROOT and unioned there, so a batch of operations
+     * announces all of them rather than the last. Keyed by {@link getId}, so a commit that spans
+     * sheets announces each sheet separately. The intent travels on the commit, which is what lets
+     * an undo deliver the same categories the forward commit did.
+     *
+     * Copy-on-write: an amend's accumulator is handed the value on the commit it folds into, and
+     * mutating that would announce the whole of the target commit rather than what the amend
+     * recorded - which is what makes a registration amend silent. The range list is the exception
+     * once this operation has made its own ({@link _appendOwnedRanges}): one write per cell in a
+     * batch would otherwise copy every range recorded so far on each of them.
+     *
+     * @internal
+     */
+    protected _recordChange(trans: ITransaction, category: EventCategory, ranges: readonly IRange.Coords[] | null | undefined): void;
+    /**
+     * Record the ranges a formula was entered over.
+     *
+     * @remarks
+     * A subset of the `data` category that no event fires for: it is what the calculation's amend
+     * formats and fits once the results exist ({@link _promoteCalcResults}). Unioned and written
+     * copy-on-write for the same reasons as {@link _recordChange}.
+     *
+     * @internal
+     */
+    protected _recordFormulasEntered(trans: ITransaction, ranges: readonly IRange.Coords[] | null | undefined): void;
+    /**
+     * This sheet's half of what a commit announces.
+     *
+     * @internal
+     */
+    protected _sheetEvents(intents: Readonly<Record<string, any>> | undefined): SheetEvents | null;
+    /**
+     * Every range this sheet announces from a commit, across the given categories (all of them when
+     * `categories` is omitted).
+     *
+     * @remarks
+     * The union is what a consumer asking "did anything happen in my box" wants, and taking it over
+     * every category is what keeps a category added later from silently ceasing to reach one.
+     *
+     * @internal
+     */
+    protected _changedRanges(intents: Readonly<Record<string, any>> | undefined, categories?: readonly EventCategory[]): readonly IRange.Coords[] | null;
+    /**
+     * Record ranges to fit when the operation completes.
+     *
+     * @remarks
+     * The fit is a union over the operation: entries for the same sheet and the same options
+     * accumulate ranges, so a batch measures each column once, at the end, against the finished
+     * content. Resolved by {@link _resolveAutoFit} as the operation's last write.
+     *
+     * @internal
+     */
+    protected _recordAutoFit(trans: ITransaction, ranges: readonly IRange.Coords[], autoFit: boolean | ICellRange.AutoFitOptions): void;
+    /**
+     * Record that the formulas this operation enters take the number format their results carry.
+     *
+     * @remarks
+     * Resolved by the calculation's amend into this commit rather than when the operation
+     * completes: the results do not exist yet. See {@link IntentAutoFormat}.
+     *
+     * @internal
+     */
+    protected _recordAutoFormat(trans: ITransaction): void;
+    /**
+     * Record that this operation has ruled on its own protection, so the commit-time catch-all
+     * stands down. See {@link IntentSkipProtectionCheck}.
+     *
+     * @internal
+     */
+    protected _recordSkipProtectionCheck(trans: ITransaction): void;
+    /**
+     * Record that this commit is a load of the sheet: not a user's write, so the protection check
+     * stands down, and not an edit, so nothing it wrote is announced. See {@link IntentInitial}.
+     *
+     * @internal
+     */
+    protected _recordInitial(trans: ITransaction): void;
+    /**
+     * Record where the freeze panes were and where the operation moved them. See
+     * {@link FreezePanesIntent} for how a batch merges the pair.
+     *
+     * @internal
+     */
+    protected _recordFreezePanes(trans: ITransaction, before: IRange.CellCoords, after: IRange.CellCoords): void;
+    /**
+     * The movables of this sheet with the given ids, in that order. Ids no longer on the sheet are
+     * skipped: an undo of the insert that created a movable lands on a state without it.
+     *
+     * @internal
+     */
+    protected _movablesOfIds(ids: readonly string[]): IMovable[];
+    /**
+     * Fold writes into the current commit without a log entry. See `IStore.amend`.
+     * @internal
+     */
+    protected _amendCurrent<R>(callback: () => R): R;
+    /**
+     * An amend the sheet makes for itself (a listener node, a watch, a promoted calc result) is not
+     * a user's write, so a protected sheet must not refuse it. Only an amend that opens its own
+     * root stands the check down; nested, it joins an operation that answers for itself.
+     * @internal
+     */
+    protected _amendBookkeeping<R>(commitId: string, callback: (commit: ITransaction.ICommit) => R): R;
+    /**
+     * Fit the ranges the operation asked for, as its last write.
+     *
+     * @remarks
+     * Runs while the root transaction is still open so the sizes belong to the same commit as the
+     * content they measure - one undo puts both back. The intent is left on the record: it is what
+     * a redo fits from.
+     *
+     * @internal
+     */
+    protected _resolveAutoFit(commit: ITransaction.ICommit): void;
+    /**
+     * Resolve the operation's directives once its root transaction has closed.
+     *
+     * @internal
+     */
+    protected _onRootTransactionClose(commit: ITransaction.ICommit, isRollback?: boolean, isElided?: boolean, isAmend?: boolean): void;
+    /**
+     * Keep the view's selection somewhere it can be once the sheet has changed: inside the sheet,
+     * and with its active cell on the top-left of the merge it falls in.
+     *
+     * @param isMergesChanged Whether the change merged anything, which is the only way the active
+     * cell comes to sit inside a merge.
+     *
+     * @remarks
+     * A correction of the view, not an operation's selection: it applies whoever made the change,
+     * and is not undone with it.
+     *
+     * @internal
+     */
+    protected _normalizeSelection(isMergesChanged: boolean): void;
     /** @internal */
     protected _autoSelect(options?: boolean | ICellRange.SelectOptions, selectionOverride?: Partial<IRangeSelection.Coords> | null, axis?: IRange.Axis): Promise<IRange.Coords[]>;
     /** {@inheritDoc ISheet.getSelection} */
@@ -792,10 +1397,32 @@ export declare class Sheet implements ISheet {
     getTabColor(): IColor;
     /** {@inheritDoc ISheet.setTabColor} */
     setTabColor(color: IColor | string | null): this;
+    /** {@inheritDoc ISheet.getCodeName} */
+    getCodeName(): string | null;
+    /** {@inheritDoc ISheet.getOutline} */
+    getOutline(): IOutline;
+    /** {@inheritDoc ISheet.isConditionalFormatCalculationEnabled} */
+    isConditionalFormatCalculationEnabled(): boolean;
+    /**
+     * A sheet's scripts are workbook structure, like the workbook's own.
+     * @internal
+     */
+    protected _isModulesReadOnly(): boolean;
+    /** {@inheritDoc ISheet.getModules} */
+    getModules(): IModuleCollection;
     /** {@inheritDoc ISheet.getRowHeaders} */
     getRowHeaders(): ISheetHeader;
     /** {@inheritDoc ISheet.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 ISheet.toJSON} */
     toJSON(options?: ISheet.ToJSONOptions): Promise<ISheet.JSON>;
     /** {@inheritDoc ISheet.getStyles} */
@@ -806,8 +1433,53 @@ export declare class Sheet implements ISheet {
     getTransactions(): ITransaction.IStore;
     /** {@inheritDoc ISheet.getStrings} */
     getStrings(): IStringCollection;
-    /** @internal */
+    /**
+     * The sheet's movables: those placed on it, then the boxes of its notes.
+     * @internal
+     */
     protected _searchMovables(options?: IMovableCollection.GetItemsOptions): IMovable[];
+    /**
+     * Places a note's box among the sheet's movables. See {@link Comment.Boxes.add}.
+     * @internal
+     */
+    protected _addNoteBox(comment: Comment, anchor: IMovable.AnchorOffset | null, hidden: boolean): NoteMovable;
+    /**
+     * A movable, or something in it, was placed anew as part of the open operation: every connector
+     * glued to it follows in the same operation (`translated` when it only moved). A target whose
+     * sites have not evaluated yet is followed once they have, folded into the commit then current.
+     */
+    protected _glueConnectors(movable: IMovable, translated?: boolean): void;
+    /** Whether the movable index read last holds a connector or a group; groups are not looked into. */
+    private _connectorScan;
+    /**
+     * The cells under the movables changed size, after the operation that sized them: every glued
+     * connector whose ends left their sites is put back, folded into that operation. Nothing is
+     * written when every end is in place, as on an undo or redo of that operation.
+     */
+    protected _glueStrayConnectors(): void;
+    /**
+     * The cell geometry a note's box is placed with.
+     * @internal
+     */
+    protected _noteLayout(): NoteLayout;
+    /** The farthest any movable of the index paints past its anchor, for each `drawn` version. */
+    private _movableOverhangs;
+    /**
+     * Called when a movable's content has a newer answer for what it paints: the next search reads
+     * it, and listeners are told once per batch of answers.
+     */
+    private _drawnNotifyQueued;
+    private _onMovableDrawnReady;
+    /**
+     * The farthest any of `models` paints past its anchor, in pixels.
+     * @internal
+     */
+    protected _maxMovableOverhang(models: Map<IMovable, unknown>): number;
+    /**
+     * The movables of one index that match the filter, in z-order.
+     * @internal
+     */
+    protected _searchMovableIndex(spatial: ISpatialMap<MovableEntry>, options?: IMovableCollection.GetItemsOptions): IMovable[];
     /** @internal */
     /**
      * @param description A COMPLETE undo description (callers pass a `messageKey`). It used to be a
@@ -817,12 +1489,42 @@ export declare class Sheet implements ISheet {
     protected _updateSelectedMovables(update: (movable: IMovable) => void, description?: string): void;
     /** @internal */
     protected _addMovable(options?: IMovableCollection.AddOptions): Promise<IMovable>;
+    /**
+     * Where a new movable of a known size goes when the caller left its position open: the visible
+     * window's center for `autoPlace: 'viewport'`, else the selection's top-left; then, on the axes the
+     * caller left open, down and right off any movable already in that spot, so repeated inserts
+     * cascade instead of stacking.
+     *
+     * Resolved before the insert transaction opens: the viewport request must reach the live listeners
+     * (not the transactional set) and must not `await` mid-commit (that desyncs the movable from its
+     * resizers). The grid answers `onRequestViewport` with the visible window in absolute px; headless
+     * (no responder) falls back to the selection.
+     */
+    protected _placeMovable(options: IMovableCollection.AddOptions, bounds: Size & Partial<Point>): Promise<Bounds>;
+    /** Refuses an insert this sheet cannot take. */
+    protected _checkInsertMovable(options?: IMovableCollection.AddOptions): asserts options is IMovableCollection.AddOptions;
+    /**
+     * Inserts a movable whose content kind is already loaded, without waiting: what an operation
+     * that cannot wait, such as a delete that dissolves a group, frees onto the sheet.
+     * @internal
+     */
+    protected _insertMovable(options: InsertableCollection.InsertOptions): IMovable;
+    /**
+     * Groups movables of this sheet into one (GROUPS-DESIGN §5 Phase B): the group's frame is the
+     * union of the boxes they occupy as rotated, its child space equals its frame, and each member
+     * keeps its frame, rotation and flips; the originals are deleted. One undo step, the selection
+     * recorded for undo and redo.
+     * @internal
+     */
+    protected _groupMovables(movables: readonly IMovable[], options?: IMovableCollection.GroupOptions): Promise<IMovable>;
     /** @internal */
     protected _addMovablePicture(picture: string | IResourceCollection.AddOptions | IResource, options?: IMovableCollection.AddOptions): Promise<IMovable>;
     /** {@inheritDoc ISheet.setPicture} */
     setPicture(picture: string | IResource | IResourceCollection.AddOptions | null, options?: ITransaction.OperationOptions): this;
     /** {@inheritDoc ISheet.getPicture} */
     getPicture(): IPicture | null;
+    /** {@inheritDoc ISheet.getPivotTables} */
+    getPivotTables(): IPivotTableCollection;
     /** {@inheritDoc ISheet.getTables} */
     getTables(): ITableCollection;
     /** {@inheritDoc ISheet.getDataValidations} */
@@ -831,12 +1533,30 @@ export declare class Sheet implements ISheet {
     getConditionalFormats(): IConditionalFormatCollection;
     /** {@inheritDoc ISheet.getProtectedRanges} */
     getProtectedRanges(): IProtectedRangeCollection;
+    /** {@inheritDoc ISheet.getComments} */
+    getComments(): ICommentCollection;
     /** @deprecated Use {@link ISheet.getConditionalFormats} */
     getConditionals(): IConditionalFormatCollection;
     /** {@inheritDoc ISheet.getMovables} */
     getMovables(): IMovableCollection;
+    /** {@inheritDoc ISheet.getCharts} */
+    getCharts(): IChartCollection;
     /** @internal */
-    protected _validateOrRemoveOverlaps(rangeCoords: IRange.Coords, type: string, table?: ITable | null, removeIfContains?: boolean): void;
+    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[];
+    } | null;
     /**
      * Used by the TableCollection wrapper so we resolve ICellRange.Address here
      * @internal
@@ -854,7 +1574,12 @@ export declare class Sheet implements ISheet {
         toJSON(): J | null;
     }, J extends object>(add: ICellRanges.Address | T | null | undefined, options: (IAnchored.AddOptions & J) | undefined, spec: {
         /** The sheet-state slot the collection lives in. */
-        key: 'conditionalFormats' | 'dataValidations' | 'protectedRanges';
+        key: 'conditionalFormats' | 'dataValidations' | 'protectedRanges' | 'comments';
+        /**
+         * The sheet-protection allowances the add needs. Empty when no option allows it, so the add is
+         * refused whenever the sheet is locked.
+         */
+        allowance: ISheetProtection.PropertyKeys[];
         isItem: (add: unknown) => add is T;
         description: string;
         /** Loads one ref into the map, handing the created model to `capture`. */
@@ -889,8 +1614,12 @@ export declare class Sheet implements ISheet {
      * @internal
      */
     protected _addProtectedRange(add: ICellRanges.Address | IProtectedRange, options?: IProtectedRangeCollection.AddOptions): IProtectedRange;
+    /**
+     * @internal
+     */
+    protected _addComment(address: ICellRange.Address, content: IComment.Content, options?: ICommentCollection.AddOptions): IComment;
     /** {@inheritDoc ISheet.createCell} */
-    createCell(update: ICell.Update, coords?: IRange.CellCoords | null): ICell;
+    createCell(update: ICell.Update, coords?: IRange.CellCoords | null, options?: ICell.CreateCellOptions): ICell;
     /** @internal */
     protected _getBoundsAtCoords(coords: IRange.Coords): Bounds;
     /** @internal */
@@ -916,8 +1645,6 @@ export declare class Sheet implements ISheet {
     protected _getRangedEntries<T, E = T>(spatial: ISpatialQuery, ranges: readonly IRange.Coords[], options?: GetTypedRangeOptions<T, E>, spatialSort?: boolean): T[];
     /** @internal */
     protected _processAnchorShift<T extends Anchored.Entry<any>>(options: ISpatialMap.ShiftDetails<T>): ISpatialMap.Entry<T> | null;
-    /** @internal */
-    protected _processListenerShift(rangesListenerMap: Map<number, ICellRangesListenerEntry>, beforeAfterMap: Map<number, BeforeAfterRange>, beforeStates: Map<number, ICellRangesListenerEntry>, options: ISpatialMap.ShiftDetails<ICellRangeListenerEntry>): ISpatialMap.Entry<ICellRangeListenerEntry>[] | void;
     /** {@inheritDoc ISheet.delete} */
     delete(): void;
     /** {@inheritDoc ITransaction.ITransactional.doBatch} */
@@ -938,12 +1665,10 @@ export declare class Sheet implements ISheet {
      */
     _getStateId(): string;
     /** @internal */
-    protected _beginCommit(options?: ITransaction.StoreOperationOptions<CommitView> | string): ITransaction;
+    protected _beginCommit(options?: ITransaction.StoreOperationOptions | string): ITransaction;
     /** @internal */
     protected _updateState(updateState?: Partial<State>, options?: ITransaction.OperationOptions | string): State;
     /** @internal */
-    protected _addEvent(type: keyof CommitEvents, value: any): void;
-    /** @internal */
     protected _getScalar(rowIndex: number, columnIndex: number, asJSDate?: boolean): Scalar | InteropScalar;
     /**
      *  This is mostly optimized except for scrolling. On scroll y it must requery. We could debounce this.
@@ -958,7 +1683,16 @@ export declare class Sheet implements ISheet {
      * @internal
      */
     protected _getCellAt(rowIndex: number, colIndex: number): ICell;
-    protected _queryStyle(anchorCoords: IRange.Coords, cellOptions: SheetCellOptions, extent?: IRange.Coords): IStyle;
+    /**
+     * The cell as `state` has it, or - for `held` - as the held write to it leaves it.
+     *
+     * @returns `null` if the write has to be made to know: the cell has a formula or a calculation
+     * status the write changes, or a style update that reaches past the cell (see
+     * `intersectionAfterStyleUpdate`).
+     * @internal
+     */
+    protected _getCellAtState(state: Readonly<State>, transaction: ITransaction | null, rowIndex: number, colIndex: number, held: CellBuffer.HeldCell | null): ICell | null;
+    protected _queryStyle(anchorCoords: IRange.Coords, cellOptions: SheetCellOptions, extent?: IRange.Coords): ICellStyle;
     /**
      * @param updateStyles Replaces the write half of the returned style. A style READS from the
      *   anchor cell and WRITES to every range, so a set spanning sheets needs the read to stay here
@@ -966,9 +1700,20 @@ export declare class Sheet implements ISheet {
      *   caller holding the whole set can do. See `SheetRanges.getStyle`.
      * @internal
      */
-    protected _getStyle(ranges: IRange.Coords[], anchor?: IRangeSelection.Coords, updateStyles?: (update: IStyle.Update, options?: IStyle.UpdateOptions) => void): IStyle;
+    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.
      *
@@ -983,6 +1728,19 @@ export declare class Sheet implements ISheet {
      * @internal
      */
     protected _initListenerState(): void;
+    /**
+     * Re-derive everything that is a function of how a cell *paints* rather than of what it holds:
+     * the default font metrics, the layout, and the header sizes fitted to that paint.
+     *
+     * @remarks
+     * The theme is the familiar case. A language or locale switch is the same shape — the cell
+     * paints a different word (`WAHR`, `#WERT!`, `15.03.2023`) for a value that never changed — so
+     * the columns fitted to the old word are stale, and nothing below the sheet is told otherwise.
+     * The fit only grows: a maintenance pass must never take back a width the sheet already had.
+     *
+     * @internal
+     */
+    protected _invalidateRendering(): void;
     /** @internal */
     protected _initViewState(entireCoords: IRange.Coords, json: ISheetView.JSON): void;
     protected _initCellState(): void;
@@ -994,8 +1752,22 @@ export declare class Sheet implements ISheet {
     protected _createConditionalFormats(conditionalFormats: IAnchoredMap<IConditionalFormat, IConditionalFormat.JSON>, key: keyof State, refs: IRange.JSONReference<IConditionalFormat.JSON>[], createModel: (options: ConditionalFormat.ConstructorOptions) => IConditionalFormat, addListeners?: (model: IConditionalFormat) => IListener.Remove): IAnchoredMap<IConditionalFormat, IConditionalFormat.JSON>;
     /** @internal */
     protected _createProtectedRanges(protectedRanges: IAnchoredMap<IProtectedRange, IProtectedRange.JSON>, key: keyof State, refs: IRange.JSONReference<IProtectedRange.JSON>[], createModel: (options: ProtectedRange.ConstructorOptions) => IProtectedRange, addListeners?: (model: IProtectedRange) => IListener.Remove): IAnchoredMap<IProtectedRange, IProtectedRange.JSON>;
+    /**
+     * Loads the pivot tables into their anchored map, each anchored where its part says it sits.
+     * The map moves and deletes them with structural edits; the table itself rules on the edit
+     * (`PivotTable._processContainerShift`).
+     * @internal
+     */
+    protected _createPivotTables(pivotTables: IAnchoredMap<IPivotTable, IPivotTable.JSON>, key: keyof State, refs: IRange.JSONReference<IPivotTable.JSON>[], fromResourceId?: (resourceId: number) => IResource): IAnchoredMap<IPivotTable, IPivotTable.JSON>;
+    /** @internal */
+    protected _createComments(comments: IAnchoredMap<IComment, IComment.JSON>, key: keyof State, refs: IRange.JSONReference<IComment.JSON>[], createModel: (options: Comment.ConstructorOptions) => IComment, addListeners?: (model: IComment) => IListener.Remove): IAnchoredMap<IComment, IComment.JSON>;
+    /**
+     * The JSON for a comment authored now: modifiers with an id, an author and a date minted.
+     * @internal
+     */
+    protected _newCommentJSON(modifiers: IComment.Modifiers): IComment.JSON;
     /** @internal */
-    protected _createMovableEntry(json: IMovable.JSON, zIndex: number, fromResourceId?: (resourceId: number) => IResource): ISpatialMap.Entry<MovableEntry>;
+    protected _createMovableEntry(json: IMovable.JSON, zIndex: number, fromResourceId?: (resourceId: number) => IResource, index?: MovableIndex, contentGiven?: Movable.Content): ISpatialMap.Entry<MovableEntry>;
     /** @internal */
     protected _fromJSON(json: ISheet.JSON | undefined, disableLoadAutoFit?: boolean): void;
     /** {@inheritDoc ITransaction.ITransactional.getId} */
@@ -1024,9 +1796,9 @@ export declare class Sheet implements ISheet {
     /** {@inheritDoc ISheet.getCalculation} */
     getCalculation(): ICalculation;
     /** {@inheritDoc ISheet.createFormula} */
-    createFormula(expression: string, coords?: Partial<IRange.CellCoords>): ICalculation.IFormula;
+    createFormula(expression: string, coords?: Partial<IRange.CellCoords>, options?: ICalculation.CreateFormulaOptions): ICalculation.IFormula;
     /** {@inheritDoc ISheet.evaluate} */
-    evaluate(expression: string, options?: number | ICalculation.EvaluateOptions & Partial<IRange.CellCoords>): Promise<Scalar | IRange>;
+    evaluate(expression: string, options?: number | ICalculation.EvaluateOptions & Partial<IRange.CellCoords> & ICalculation.CreateFormulaOptions): Promise<Scalar | IRange>;
     /** {@inheritDoc ISheet.whenCalculationReady} */
     whenCalculationReady(): Promise<ICalculation.Status>;
     /** {@inheritDoc ISheet.getWorkbook} */
@@ -1046,12 +1818,26 @@ export declare class Sheet implements ISheet {
  * @internal
  */
 export declare function createCellRangeCounts(counts: Readonly<Record<ICellRange.Feature, number>>): ICellRange.Counts;
+/**
+ * Used for signalling tupleUpdate was called via private apis.
+ * This allows use to 'avoid side effects' and skip validation checks.
+ * @internal
+ */
 interface NotifierOptions {
+    /**
+     * Which error an invalid source reports - `#REF!` when the cells were deleted, `#N/A` when the
+     * world predates the listener.
+     *
+     * @defaultValue `#REF!`
+     */
+    invalidError?: string;
     isDataChange?: boolean;
     getTransactionId: () => string;
     isUndo?: boolean;
     isRestoreOrRevert?: boolean;
     trigger?: string;
+    /** Spell the source with its sheet qualifier (a workbook range), as the listener registered it. */
+    qualified?: boolean;
     from?: ICellRanges;
     to?: ICellRange;
     timeStamp?: number;
@@ -1065,35 +1851,34 @@ interface TableColumnHeaders {
     lastRowIndex: number;
     lastColIndex: number;
 }
-interface CommitEvents {
-    address?: Map<string, RangesListener | null>;
-    data?: IRange.Coords[];
-    dataListeners?: Map<string, RangesListener | null>;
+/**
+ * A live range listener: its node in the versioned map, and the callback the map must never hold.
+ * @internal
+ */
+interface ListenerNodeEntry {
+    node: ListenerAnchor;
+    handler: ICellRange.Listener | null;
+    handlerW: WeakRef<ICellRange.Listener> | null;
+    options: ICellRange.ListenerOptions;
+    /** The coords last delivered, so a restore can tell whether the reference moved. */
+    lastCoords: IRange.Coords[] | null;
+    /**
+     * Whether the ranges were registered with a sheet qualifier. A qualified address names its
+     * sheet, so a rename of the sheet changes it: the node is told, and its source is spelled
+     * qualified. A bare address is the anchor's and a rename is nothing to it.
+     */
+    qualified: boolean;
+    /** Present when the node is a {@link WatchAnchor}: what the watch is told. */
+    watch?: WatchAnchor.Handlers;
 }
-interface CommitView {
-    initial?: boolean;
-    sheet?: ISheet;
-    view?: ISheetView;
-    freezePanes?: Partial<IRange.CellCoords>;
-    selection?: Partial<IRangeSelection.Coords> | null;
-    selectOptions?: boolean | ICellRange.SelectOptions | null;
-    movableSelection?: readonly IMovable[];
-    ranges?: readonly IRange.FixableCoords[];
-    events?: CommitEvents;
-    formulas?: readonly IRange.FixableCoords[];
-    spills?: readonly IRange.FixableCoords[];
-    /**
-     * Special case for range listeners that monitored a remove.
-     */
-    merges?: readonly IRange.FixableCoords[];
-    listeners?: Map<number, BeforeAfterRange>;
-    table?: ITable;
-    /** If `true` then don't do protection check. (For example load or range listeners) */
-    skipProtectionCheck?: boolean;
-    /**
-     * We update values (cache, potentially styling, as a result of calculations)
-     */
-    calculationSideEffect?: boolean;
+/**
+ * A run of formula cells with the references they inherit a number format from, relative to the
+ * run's top-left ({@link ICalcGrid.Results.formatInserts}) - what `Sheet._resolveInheritedFormats`
+ * resolves.
+ */
+interface EnteredBlock {
+    coords: IRange.Coords;
+    references: readonly IRange.FixableCoords[];
 }
 export {};
 //# sourceMappingURL=Sheet.d.ts.map