@fileverse-dev/dsheet 4.1.23 → 4.1.24-stabilise-package-1

package/dist/sheet-engine/core/modules/b6-ydoc-writes.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sheet-engine/core/modules/border.d.ts

@@ -1,4 +1,13 @@
 import { Context } from '../context';
 
 export declare function getBorderInfoComputeRange(ctx: Context, dataset_row_st: number, dataset_row_ed: number, dataset_col_st: number, dataset_col_ed: number, sheetId?: string): Record<string, any>;
+/**
+ * getBorderInfoComputeRange for the current sheet's canvas draw, cached (C6).
+ * The draw re-expanded every borderInfo entry on every repaint. Keyed by the
+ * identities of borderInfo, merge, rowhidden and colhidden (Immer gives each
+ * a new identity on change; merged cells' `mc` follows `merge`), the grid
+ * size and the drawn bounds, so redraws for scroll-back, selection moves,
+ * edits and remote cells reuse the result. Callers only read it.
+ */
+export declare function getBorderInfoComputeRangeCached(ctx: Context, dataset_row_st: number, dataset_row_ed: number, dataset_col_st: number, dataset_col_ed: number): Record<string, any>;
 export declare function getBorderInfoCompute(ctx: Context, sheetId?: string): any;

package/dist/sheet-engine/core/modules/cell-shift.d.ts

@@ -0,0 +1,11 @@
+import { Context } from '../context';
+
+/** A selection rectangle: `row` and `column` are [start, end]. */
+export type CellShiftRange = {
+    row: number[];
+    column: number[];
+};
+/** Delete the selected cells and shift the rest left or up. */
+export declare function deleteCellsShift(ctx: Context, direction: 'left' | 'up', range: CellShiftRange): void;
+/** Insert empty cells at the selection and shift the rest right or down. */
+export declare function insertCellsShift(ctx: Context, direction: 'right' | 'down', range: CellShiftRange): void;

package/dist/sheet-engine/core/modules/cell.commit-ydoc.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sheet-engine/core/modules/dataVerification.d.ts

@@ -2,6 +2,20 @@ import { Context, GlobalCache } from '..';
 
 export declare function dataRangeSelection(ctx: Context, cache: GlobalCache, rangT: string, type: string, value: string): void;
 export declare function getDropdownList(ctx: Context, txt: string): (string | number | boolean)[];
+type DropdownOptions = {
+    list: (string | number | boolean)[];
+    set: Set<unknown>;
+};
+/**
+ * Parsed dropdown options, cached per option text (C7). The canvas validates
+ * every visible dropdown cell on every draw, and getDropdownList re-splits
+ * and de-duplicates with list.includes, O(L^2) per cell. When the options
+ * come from a cell range, the key also includes the identity of the source
+ * sheet's data, so an edit there re-reads the range. Shared and read-only.
+ */
+export declare function getDropdownOptions(ctx: Context, txt: string): DropdownOptions;
+/** `value1.split(',')`, memoized for the canvas pill colours (C7). */
+export declare function splitDropdownOptions(value1: string): string[];
 export declare function validateIdCard(ctx: Context, idCard: string): boolean;
 export declare function validateCellData(ctx: Context, item: any, cellValue: any): any;
 export declare function checkboxChange(ctx: Context, r: number, c: number): void;
@@ -17,3 +31,4 @@ export declare function setDropdownValue(ctx: Context, value: string, arr: any,
     column: number;
 }): void;
 export declare function confirmMessage(ctx: Context, generalDialog: any, dataVerification: any): boolean;
+export {};

package/dist/sheet-engine/core/modules/engine-hot-spots.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sheet-engine/core/modules/formula-arrow-mode.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Pure (DOM-free, ctx-free) logic that decides what an arrow key does while a
+ * formula is being edited.
+ *
+ * GRID             - not editing: arrows move the grid selection
+ * TEXT_EDIT        - arrows move the text caret
+ * REFERENCE_READY  - next arrow inserts a new cell reference at the caret
+ * REFERENCE_ACTIVE - arrows move/extend the reference that was just inserted
+ */
+export type FormulaArrowMode = 'GRID' | 'TEXT_EDIT' | 'REFERENCE_READY' | 'REFERENCE_ACTIVE';
+/** Sticky, user-controlled (F2). `null` = automatic behavior. */
+export type FormulaArrowOverride = null | 'TEXT_EDIT' | 'REFERENCE';
+export type TokenKind = 'EQ' | 'SPACE' | 'STRING' | 'REF' | 'NAME' | 'NUMBER' | 'FUNC_NAME' | 'LPAREN' | 'RPAREN' | 'COMMA' | 'OPERATOR' | 'POSTFIX' | 'UNKNOWN';
+export type Token = {
+    kind: TokenKind;
+    start: number;
+    end: number;
+    text: string;
+    /** STRING / quoted sheet name: closing quote present. */
+    terminated?: boolean;
+    /** REF that is not (yet) a complete reference, e.g. `A1:A`, `A1:`. */
+    partial?: boolean;
+};
+/** Never throws. Offsets index into `text` as given. */
+export declare function tokenizeFormula(text: string): Token[];
+export type CaretContext = {
+    inString: boolean;
+    /** Caret strictly inside a non-string token (e.g. `A|1`, `SU|M(`). */
+    insideToken: Token | null;
+    /** REF token the caret is inside or right after (start < caret <= end). */
+    touchingRef: Token | null;
+    prevSig: Token | null;
+    nextSig: Token | null;
+};
+export declare function getCaretContext(tokens: Token[], caret: number): CaretContext;
+/**
+ * True when a new operand (cell reference) can be entered at the caret:
+ * the previous significant token wants an operand, the caret is not inside a
+ * string or token, and no operand sits immediately to the right.
+ */
+export declare function isOperandSlot(ctx: CaretContext): boolean;
+export type ArrowModeInput = {
+    editing: boolean;
+    /** Full editor text (offsets of `caretOffset` index into it). */
+    text: string;
+    /** null when the caret is not inside the editor. */
+    caretOffset: number | null;
+    override: FormulaArrowOverride;
+    /** false for sessions opened on an existing formula (F2 / dblclick / bar). */
+    autoAllowed: boolean;
+    /**
+     * The engine is driving a reference right now (mouse drag, or a reference the
+     * keyboard just inserted and the caret is still on).
+     */
+    refActive: boolean;
+};
+/** Decision priority from the product spec, evaluated in this exact order. */
+export declare function resolveArrowMode(input: ArrowModeInput): FormulaArrowMode;
+/**
+ * F2 while editing a formula: flip between caret and reference selection.
+ *
+ * Toggles the stored override once one exists, so a second press always undoes
+ * the first, even at a caret where the derived mode cannot change (e.g. after
+ * `)`). With no stored override, flips from the mode the user is looking at.
+ */
+export declare function overrideAfterF2(mode: FormulaArrowMode, current?: FormulaArrowOverride): FormulaArrowOverride;
+/**
+ * Rule 4: keys typed while a reference is active end the arrow-driven
+ * reference. The next mode is then derived from the caret position
+ * (operator or `,` -> READY, `)` or anything else -> TEXT_EDIT).
+ * keyCode based because it is called from keyup/keydown handlers.
+ */
+export declare function isTextChangingKeyCode(kcode: number): boolean;
+/**
+ * Keys that edit characters *inside* a reference token (letters, digits incl.
+ * numpad digits, Backspace/Delete). Typing them over an arrow-inserted
+ * reference makes it a hand-edited token, so its highlight must be dropped.
+ * Operators, commas and spaces are not here: they end the reference but leave
+ * its highlight alone (see `isTextChangingKeyCode`).
+ */
+export declare function isReferenceDirtyingKeyCode(kcode: number): boolean;

package/dist/sheet-engine/core/modules/formula-arrow-mode.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sheet-engine/core/modules/formula-async-eval.d.ts

@@ -37,6 +37,11 @@ export type FormulaAsyncEvalJob = {
     impactedByCircular: string[];
     cycleNodes: string[];
     workerSnapshotKey: string;
+    /**
+     * Set on a forced full pass: the dependency-graph epoch it started at. The
+     * last chunk marks the graph complete if the epoch is unchanged (C8).
+     */
+    fullPassEpoch?: number | null;
     nextIndex: number;
     total: number;
     debug?: FormulaEvalDebug;

package/dist/sheet-engine/core/modules/formula-dep-text.d.ts

@@ -0,0 +1,23 @@
+import { Context } from '../context';
+import { WideRange } from './formula-transitive-deps';
+
+/** Same cap as `execfunction` (MAX_RANGE_DEPS in formula.ts). */
+export declare const MAX_TEXT_RANGE_DEPS = 10000;
+export type FormulaTextDeps = {
+    /** `${sheetId}:${r}:${c}` of every cell the formula reads. */
+    deps: Set<string>;
+    /** Too wide or unresolvable to list. */
+    wide: boolean;
+    /**
+     * The ranges that made it wide, as `execfunction` records them. `null` when
+     * the formula is wide but its ranges can't be read from its text (an
+     * unresolved tab, INDIRECT, OFFSET, a whole row or column of a tab with no
+     * grid): it joins every commit's walk. `[]` when it is not wide.
+     */
+    wideRanges: WideRange[] | null;
+};
+/**
+ * Collect the references of formula text `f` (with its leading `=`) written
+ * in cell (`r`, `c`) of tab `sheetId`.
+ */
+export declare function collectFormulaTextDeps(ctx: Context, f: string, sheetId: string, r: number, c: number): FormulaTextDeps;

package/dist/sheet-engine/core/modules/formula-dep-text.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sheet-engine/core/modules/formula-edge-update.d.ts

@@ -0,0 +1,13 @@
+import { Context } from '../context';
+
+/**
+ * Set the edges of the formula `f` written in (`r`, `c`) of tab `sheetId`, or
+ * drop them when `f` is null (the value is no longer a formula).
+ */
+export declare function setFormulaEdgesFromText(ctx: Context, r: number, c: number, sheetId: string, f: string | null): void;
+/**
+ * A chain entry whose cell isn't here yet (a peer's chain can arrive before
+ * its cells): it can't be read, so it runs on every commit until the cell
+ * arrives and replaces this.
+ */
+export declare function markFormulaEdgesUnknown(ctx: Context, r: number, c: number, sheetId: string): void;

package/dist/sheet-engine/core/modules/formula-narrowing.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sheet-engine/core/modules/formula-snapshot-eval.d.ts

@@ -20,6 +20,8 @@ export type SnapshotFormulaResult = {
     spe?: unknown;
     deps: string[];
     isError: boolean;
+    /** Read a sheet name that doesn't exist; the main thread keeps it on every commit's run list (C8). */
+    unresolvedSheetRef?: boolean;
 };
 export type SnapshotEvalInput = {
     sheets: SnapshotSheet[];

package/dist/sheet-engine/core/modules/formula-tab-load.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sheet-engine/core/modules/formula-transitive-deps.d.ts

@@ -1,7 +1,32 @@
 /** Cell / formula key format used in depsByCell and revDepsByCell. */
 export declare function toFormulaDepCellKey(sheetId: string, r: number, c: number): string;
+/** A range a wide formula reads (more cells than get individual edges). */
+export type WideRange = {
+    sheetId: string;
+    startRow: number;
+    endRow: number;
+    startCol: number;
+    endCol: number;
+};
+/**
+ * Wide formulas (ranges over MAX_RANGE_DEPS cells record no cell edges).
+ * `ranges` holds the ranges of those whose ranges could be read; a key in
+ * `keys` without an entry in `ranges` can't be bounded, so it joins every walk.
+ */
+export type WideFormulaIndex = {
+    keys: Iterable<string>;
+    ranges: Map<string, WideRange[]>;
+};
 /**
  * Walk revDepsByCell from a changed cell to collect every formula cell that
  * must recalculate (direct + transitive dependents).
+ *
+ * `extraFormulaSeeds` are formulas that run on every commit whatever the
+ * graph says (named ranges covering the edited cell). They join the same
+ * walk, so formulas that read their results are reached too.
+ *
+ * A wide formula joins the walk only when one of its ranges holds the edited
+ * cell or a formula cell the walk reaches; one whose ranges can't be read
+ * joins every walk. It then seeds the walk like any other formula.
  */
-export declare function collectTransitiveFormulaDependents(originCellKey: string, revDepsByCell: Map<string, Set<string>>): Set<string>;
+export declare function collectTransitiveFormulaDependents(originCellKey: string, revDepsByCell: Map<string, Set<string>>, extraFormulaSeeds?: Iterable<string>, wide?: WideFormulaIndex): Set<string>;

package/dist/sheet-engine/core/modules/formula-warmup.d.ts

@@ -0,0 +1,33 @@
+import { Context } from '../context';
+
+export declare const FORMULA_WARMUP_BUDGET_MS = 8;
+export declare const FORMULA_WARMUP_DEBOUNCE_MS = 2000;
+export declare const FORMULA_WARMUP_IDLE_TIMEOUT_MS = 1000;
+export type FormulaWarmupResult = 'complete' | 'aborted';
+export type FormulaWarmupOptions = {
+    /** Longest a slice keeps reading formulas before it yields (default 8). */
+    budgetMs: number;
+    /** Runs the next slice later (idle callback in the app). */
+    schedule: (cb: () => void) => void;
+    isCancelled?: () => boolean;
+};
+/**
+ * Walk the calc chain in slices and read every formula's references, then
+ * mark the graph complete (C8). Resolves 'aborted' if the graph is cleared
+ * while it runs or `isCancelled` says so. A tab with no grid is read from its
+ * `celldata`.
+ *
+ * Pass a getter to read the latest context in each slice (the Workbook does);
+ * a plain context is used as is.
+ */
+export declare function warmFormulaDependencyGraph(ctxOrGetter: Context | (() => Context), opts: FormulaWarmupOptions): Promise<FormulaWarmupResult>;
+/**
+ * Run the warm-up in the app: on `trigger()` (data ready after mount) and
+ * again `FORMULA_WARMUP_DEBOUNCE_MS` after each `markDepGraphIncomplete()`.
+ * Slices run in idle callbacks (setTimeout without requestIdleCallback) and
+ * only while the page is visible.
+ */
+export declare function scheduleFormulaWarmup(getCtx: () => Context): {
+    trigger(): void;
+    dispose(): void;
+};

package/dist/sheet-engine/core/modules/formula-warmup.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sheet-engine/core/modules/formula.d.ts

@@ -1,7 +1,9 @@
 import { Cell, CellMatrix, Rect, Selection } from '../types';
 import { Context } from '../context';
+import { FormulaArrowMode, FormulaArrowOverride } from './formula-arrow-mode';
 import { FormulaAsyncEvalJob } from './formula-async-eval';
 import { RangePassCacheEntry } from './formula-range-cache';
+import { WideRange } from './formula-transitive-deps';
 import { SnapshotEvalOutput } from './formula-snapshot-eval';
 
 /** True when the formula is only numeric ops on TODAY()/NOW() (incl. unary +/−); used to display serials as dates. */
@@ -28,6 +30,9 @@ export declare class FormulaCache {
     rangedrag_row_start?: boolean;
     rangeSelectionActive?: boolean | null;
     keyboardRangeSelectionLock?: boolean;
+    arrowOverride?: FormulaArrowOverride;
+    arrowAutoAllowed?: boolean;
+    arrowSessionCell?: [number, number];
     /** True after arrow/Shift+arrow moved `func_selectedrange` without updating yellow selection. */
     formulaKeyboardRefSync?: boolean;
     formulaEditorOwner?: 'cell' | 'fx' | null;
@@ -51,6 +56,32 @@ export declare class FormulaCache {
      * affect them even when no precise reverse edge exists.
      */
     formulasWithWideRangeDeps: Set<string>;
+    /**
+     * The ranges of the wide formulas whose ranges could be read, by formula
+     * key. A wide formula joins a commit's walk only when one of these holds the
+     * edited cell or a formula cell the walk reaches. A key in
+     * `formulasWithWideRangeDeps` with no entry here (an unresolved tab, an
+     * unreadable range) joins every walk.
+     */
+    wideRangesByFormula: Map<string, WideRange[]>;
+    /**
+     * True once a full pass has evaluated every formula in the chain since the
+     * indexes were last reset, so `revDepsByCell` lists every dependent of every
+     * cell (C8). While true, a commit to a cell with no dependents runs no
+     * formula pass. Cleared by `markDepGraphIncomplete`.
+     */
+    depGraphComplete: boolean;
+    /**
+     * Bumped each time the flag is cleared. A deferred full pass records it at
+     * start and sets the flag only if nothing cleared it while it ran.
+     */
+    depGraphEpoch: number;
+    /**
+     * Grid size (`rows x cols`) of each dense tab when the graph was completed.
+     * Whole-row and whole-column references were recorded at that size, so a
+     * commit to a tab that has grown since takes the full pass again.
+     */
+    depGraphSheetSizes: Map<string, string>;
     /**
      * Dependency collection state for the currently-parsed formula, set by `execfunction`.
      * When null, dependency recording is disabled.
@@ -59,6 +90,10 @@ export declare class FormulaCache {
         originKey: string;
         deps: Set<string>;
         hasWideRangeDep: boolean;
+        /** Ranges over the cap, in the order they were read. */
+        wideRanges: WideRange[];
+        /** A wide dependency whose range can't be bounded (unresolved tab). */
+        wideUnreadable: boolean;
     };
     /** Step 2: per execFunctionGroup pass cache for materialized range reads. */
     rangeValuePassCache?: Map<string, RangePassCacheEntry>;
@@ -66,6 +101,21 @@ export declare class FormulaCache {
         hits: number;
         misses: number;
     };
+    /**
+     * Drop every recorded formula dependency, back to the state a fresh mount
+     * has. Used when a sheet's formula list is replaced from outside the
+     * engine (a collaborator's calcChain change, A4).
+     */
+    resetDependencyIndexes(): void;
+    /**
+     * The graph may miss edges: formulas moved, were rewritten or entered the
+     * chain without being evaluated. Commits take the full pass again until the
+     * next full pass completes.
+     */
+    markDepGraphIncomplete(): void;
+    /** Called after each `markDepGraphIncomplete` (the C8 warm-up re-runs). */
+    depGraphIncompleteListeners: Set<() => void>;
+    onDepGraphIncomplete(listener: () => void): () => void;
     constructor();
     materializeFullRangeFragment(context: Context, sheetId: string, flowdata: CellMatrix | null | undefined, startRow: number, endRow: number, startCol: number, endCol: number): {
         fragment: any[][];
@@ -77,10 +127,46 @@ export declare class FormulaCache {
 export declare function iscelldata(txt: string): boolean;
 export declare function getcellrange(ctx: Context, txt: string, formulaId?: string): any;
 export declare function getAllFunctionGroup(ctx: Context): any[];
+/** Remove the dependency edges recorded for a cell that is no longer a formula. */
+export declare function dropDependencyEdges(ctx: Context, r: number, c: number, id: string): void;
+/**
+ * delFunctionGroup for many cells of one sheet: the chain and the dynamic
+ * array list are filtered once, not scanned and copied per cell. Same result
+ * as calling delFunctionGroup for each cell.
+ */
+export declare function delFunctionGroupBatch(ctx: Context, id: string, cells: {
+    r: number;
+    c: number;
+}[]): void;
 export declare function delFunctionGroup(ctx: Context, r: number, c: number, id?: string): void;
 export declare function insertUpdateFunctionGroup(ctx: Context, r: number, c: number, id?: string, calcChainSet?: Set<string>): void;
+/**
+ * Drop every recorded formula dependency, back to a fresh mount's state, and
+ * mark the graph incomplete (A4, C8).
+ */
+export declare function resetFormulaDependencyIndexes(ctx: Context): void;
+/**
+ * End of a full pass that started at `epoch` (C8): every formula in the chain
+ * has recorded its dependencies, unless the graph was invalidated meanwhile.
+ */
+export declare function finishFullFormulaPass(ctx: Context, epoch: number | null | undefined): void;
+/**
+ * A tab that is loaded after the graph was completed keeps the flag on (K60,
+ * PR 466): loading builds the grid from `celldata` and does not change the
+ * tab's structure, and the text index already treated a whole-row or column
+ * reference to a tab with no grid as wide. Without a recorded size the first
+ * commit on the tab would take the full pass and clear the flag.
+ */
+export declare function recordLoadedSheetSize(ctx: Context, sheetId: string | undefined, data: CellMatrix | null | undefined): void;
+/**
+ * INDIRECT and OFFSET would resolve references at run time, which the graph
+ * cannot see. Today both evaluate to an error (formulajs implements neither),
+ * but formulas using them are kept on every commit's run list regardless.
+ */
+export declare const RUNTIME_REFERENCE_RE: RegExp;
 export declare function execfunction(ctx: Context, txt: string, r: number, c: number, id?: string, calcChainSet?: Set<string>, isrefresh?: boolean, notInsertFunc?: boolean): any[];
 export declare function groupValuesRefresh(ctx: Context): void;
+export declare function mergeFormulaDeps(ctx: Context, originKey: string, deps: Iterable<string>): void;
 /** Apply worker chunk output onto the live context (main thread only). */
 export declare function applyWorkerFormulaChunkResults(ctx: Context, output: SnapshotEvalOutput, impactedByCircular: Set<string>, cycleNodes: Set<string>, calcChainKeys?: string[], data?: CellMatrix | null): void;
 /** Run up to `chunkSize` formulas from an async job. Returns true when job is complete. */
@@ -98,6 +184,14 @@ export declare function execFunctionGroup(ctx: Context, origin_r: number, origin
  * without resizing `luckysheet_select_save`.
  */
 export declare function seedFormulaFuncSelectedRangeFromLastSelection(ctx: Context): boolean;
+/**
+ * Explicit reference selection (F2) with the caret on an existing reference:
+ * seed the keyboard range from *that reference*, so the first arrow moves it
+ * from where it is (`=SUM(A1|)` + Right -> `=SUM(B1)`), not from the edited
+ * cell. Replaces any stale `func_selectedrange`. Returns false when the caret
+ * is not on a complete reference on the visible sheet.
+ */
+export declare function seedFormulaFuncSelectedRangeFromTouchedReference(ctx: Context): boolean;
 export declare function createFormulaRangeSelect(ctx: Context, select: {
     rangeIndex: number;
 } & Rect): void;
@@ -146,7 +240,7 @@ export declare function isBareCellOrRangeOnlyFormula(formulaText: string): boole
  * disable sheet-driven range selection until the caret reaches a fresh insertion slot
  * (comma, open paren, operator, etc.) or the user starts an active range drag.
  */
-export declare function suppressFormulaRangeSelectionForInitialEdit(ctx: Context): void;
+export declare function suppressFormulaRangeSelectionForInitialEdit(ctx: Context, cell?: [number, number]): void;
 export declare function isCaretAtValidFormulaRangeInsertionPoint(editor: HTMLElement | null): boolean;
 export declare function markRangeSelectionDirty(ctx: Context): void;
 /**
@@ -158,12 +252,35 @@ export declare function markRangeSelectionDirty(ctx: Context): void;
 export declare function getFormulaRangeIndexForKeyboardSync($editor: HTMLDivElement): number | null;
 export declare function handleFormulaInput(ctx: Context, $copyTo: HTMLDivElement | null | undefined, $editor: HTMLDivElement, kcode: number, preText?: string, refreshRangeSelect?: boolean): void;
 export declare function toggleFormulaAbsoluteReferenceAtCaret(ctx: Context, $copyTo: HTMLDivElement | null | undefined, $editor: HTMLDivElement | null | undefined): boolean;
+export type FormulaTabs = {
+    editedTab: string;
+    formulaTab: string;
+};
 /** True while picking a range for a formula (sheet selection drives references). */
 export declare function isLegacyFormulaRangeMode(ctx: Context): boolean;
 export declare function israngeseleciton(ctx: Context, istooltip?: boolean): boolean;
+/**
+ * Start (or end) an arrow-key session with the defaults: automatic reference
+ * selection on, no F2 override. Call when a session opens on a cell that does
+ * not hold a formula, and when one ends.
+ */
+export declare function resetFormulaArrowSession(ctx: Context): void;
+/** The F2 override / auto flag in effect for the cell being edited right now. */
+export declare function getFormulaArrowSession(ctx: Context): {
+    override: FormulaArrowOverride;
+    autoAllowed: boolean;
+};
+/** F2 pressed while editing: store the new override for this cell's session. */
+export declare function setFormulaArrowOverride(ctx: Context, override: FormulaArrowOverride): void;
+/**
+ * Single source of truth for what an arrow key does while editing.
+ * Thin ctx/DOM adapter over the pure `resolveArrowMode`.
+ */
+export declare function getFormulaArrowMode(ctx: Context): FormulaArrowMode;
+/** True while arrows should drive a cell reference (READY or ACTIVE). */
 export declare function isFormulaReferenceInputMode(ctx: Context): boolean;
 export declare function maybeRecoverDirtyRangeSelection(ctx: Context): boolean;
-export declare function functionStrChange(txt: string, type: string, rc: 'row' | 'col', orient: string | null, stindex: number, step: number): string;
+export declare function functionStrChange(txt: string, type: string, rc: 'row' | 'col', orient: string | null, stindex: number, step: number, tabs: FormulaTabs): string;
 export declare function rangeSetValue(ctx: Context, cellInput: HTMLDivElement, selected: any, fxInput?: HTMLDivElement | null): void;
 export declare function onFormulaRangeDragEnd(ctx: Context): void;
 export declare function rangeDrag(ctx: Context, e: MouseEvent, cellInput: HTMLDivElement, scrollLeft: number, scrollTop: number, container: HTMLDivElement, fxInput?: HTMLDivElement | null): void;

package/dist/sheet-engine/core/modules/formula.dep-graph.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sheet-engine/core/modules/formula.str-change.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sheet-engine/core/modules/formula.wide-seed.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sheet-engine/core/modules/history-calc-chain.d.ts

@@ -0,0 +1,39 @@
+import { Patch } from 'immer';
+import { Context } from '../context';
+
+/**
+ * Undo and redo apply Immer patches that address `calcChain` by array index.
+ * After a collaborator's formula list has replaced the sheet's chain (A4),
+ * those indexes point into a different array, so replaying them can truncate
+ * it and drop the collaborator's formulas; the calcChain hook would then
+ * delete those entries from Yjs for everyone.
+ *
+ * So history never restores `calcChain` from patches. The cells it restores
+ * are re-registered from their own `f` instead (`reregisterRestoredFormulas`).
+ */
+export type RestoredCell = {
+    sheetIndex: number;
+    r: number;
+    c: number | null;
+};
+/**
+ * `patches` without the calcChain ones, and the cells whose formulas must be
+ * re-registered afterwards. When a patch replaces a whole sheet or grid the
+ * cells can't be listed, so history is left as it was (`restored` is null).
+ */
+export declare function planHistoryPatches(patches: Patch[]): {
+    patches: Patch[];
+    restored: RestoredCell[] | null;
+};
+/**
+ * Register the restored cells that hold a formula and drop the ones that no
+ * longer do. Run on a draft after the patches were applied. The graph is left
+ * incomplete: restored formulas are not evaluated.
+ *
+ * A row-level patch lists every cell of the row, so most restored cells are
+ * unchanged. The chain is read once into a set; only a formula missing from it
+ * is added and only an entry whose cell lost its formula is removed (in one
+ * batch). Calling insertUpdateFunctionGroup / delFunctionGroup per cell
+ * scanned the chain each time: 6.8 s for 1,000 formulas on 1,000 rows.
+ */
+export declare function reregisterRestoredFormulas(ctx: Context, restored: RestoredCell[]): void;

package/dist/sheet-engine/core/modules/history-calc-chain.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sheet-engine/core/modules/history-celldata.d.ts

@@ -0,0 +1,25 @@
+/**
+ * A structural edit rewrites the cross-tab formulas of a tab that is not
+ * loaded in its `celldata`, as one replacement of the whole array (PR 466 N1).
+ * Undo and redo replay that replacement, so the engine is right; the Yjs write
+ * for it compares the two arrays here.
+ *
+ * Only formulas that name another tab (they contain `!`) are compared. Those
+ * are the cells a structural edit on another tab can rewrite; a cell a
+ * collaborator changed in between is not written back.
+ */
+type CelldataEntry = {
+    r: number;
+    c: number;
+    v?: any;
+};
+export type CelldataArrayChange = {
+    sheetId: string;
+    path: ['celldata'];
+    key: string;
+    value: CelldataEntry | null;
+    type: 'update' | 'delete';
+};
+/** The Yjs changes that turn `before` into `after` for the cross-tab formulas. */
+export declare function celldataArrayChanges(sheetId: string, before: CelldataEntry[] | undefined, after: CelldataEntry[] | undefined): CelldataArrayChange[];
+export {};

package/dist/sheet-engine/core/modules/history-grid-size.d.ts

@@ -0,0 +1,16 @@
+import { Patch } from 'immer';
+import { Context } from '../context';
+
+export type GridSizeChange = {
+    sheetId: string;
+    path: ['row'] | ['column'];
+    value: number;
+    type: 'update';
+};
+/**
+ * Undo and redo of a row/column insert or delete change a sheet's `row` /
+ * `column`. The forward edit writes them to Yjs (`emitGridSizeToYdoc`); history
+ * wrote the restored cells only, so a peer kept the grown grid until a later
+ * effect fixed it, and only for the current sheet.
+ */
+export declare function gridSizeChangesFromPatches(ctxAfter: Context, patches: Patch[]): GridSizeChange[];

package/dist/sheet-engine/core/modules/history-grid-size.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sheet-engine/core/modules/index.d.ts

@@ -4,7 +4,7 @@ export { default as clipboard } from './clipboard';
 export { moveToEnd, getRangeRectsByCharacterOffset } from './cursor';
 export { getDateBaseLocale, getCanonicalDateDisplayFormat, getCanonicalDateEditFormat, getDateEditFormatForCell, isUsDateBaseLocale, normalizeDateBaseLocale, shouldPreserveDateFormatForEdit, setDateBaseLocale, } from './date-base-locale';
 export { update, is_date, valueShowEs, isTypedCurrencyDisplayFormat, isCurrencyLikeNumberFormat, buildFiatCurrencyFormat, quoteSsfLiteral, } from './format';
-export { FormulaCache, groupValuesRefresh, setCaretPosition, getrangeseleciton, getFormulaEditorOwner, rangeHightlightselected, handleFormulaInput, israngeseleciton, createRangeHightlight, createFormulaRangeSelect, maybeRecoverDirtyRangeSelection, delFunctionGroup, functionHTMLGenerate, onFormulaRangeDragEnd, rangeDrag, rangeSetValue, remapFormulaReferencesByMap, getFormulaRangeIndexAtCaret, isCaretAtValidFormulaRangeInsertionPoint, isLegacyFormulaRangeMode, markRangeSelectionDirty, getFormulaRangeIndexForKeyboardSync, isFormulaReferenceInputMode, seedFormulaFuncSelectedRangeFromLastSelection, functionStrChange, setFormulaEditorOwner, getAllFunctionGroup, suppressFormulaRangeSelectionForInitialEdit, ensureFormulaRangeToSheet, shouldPreserveFormulaEditOnSheetSwitch, activateSheetForNavigation, returnToFormulaOriginSheet, } from './formula';
+export { FormulaCache, groupValuesRefresh, setCaretPosition, getrangeseleciton, getFormulaEditorOwner, rangeHightlightselected, handleFormulaInput, israngeseleciton, createRangeHightlight, createFormulaRangeSelect, maybeRecoverDirtyRangeSelection, delFunctionGroup, functionHTMLGenerate, onFormulaRangeDragEnd, rangeDrag, rangeSetValue, remapFormulaReferencesByMap, getFormulaRangeIndexAtCaret, isCaretAtValidFormulaRangeInsertionPoint, isLegacyFormulaRangeMode, markRangeSelectionDirty, getFormulaRangeIndexForKeyboardSync, isFormulaReferenceInputMode, seedFormulaFuncSelectedRangeFromLastSelection, functionStrChange, setFormulaEditorOwner, getAllFunctionGroup, suppressFormulaRangeSelectionForInitialEdit, resetFormulaArrowSession, ensureFormulaRangeToSheet, shouldPreserveFormulaEditOnSheetSwitch, activateSheetForNavigation, returnToFormulaOriginSheet, } from './formula';
 export { FORMULA_ASYNC_CHUNK_SIZE, FORMULA_ASYNC_EVAL_THRESHOLD, FORMULA_WORKER_CHUNK_SIZE, FORMULA_WORKER_THRESHOLD, isFormulaEvalPending, } from './formula-async-eval';
 export type { FormulaAsyncEvalJob } from './formula-async-eval';
 export { initFreeze } from './freeze';
@@ -33,16 +33,17 @@ export { cfSplitRange } from './conditionalFormat';
 export { CFSplitRange } from './ConditionFormat';
 export { updateMoreCell, getRegStr, getDataArr } from './splitColumn';
 export { applyLocation, getOptionValue, getSelectRange, } from './locationCondition';
-export { getDropdownList, setDropdownValue, confirmMessage, cellFocus, validateCellData, } from './dataVerification';
+export { getDropdownList, setDropdownValue, confirmMessage, cellFocus, validateCellData, splitDropdownOptions, getDropdownOptions, } from './dataVerification';
 export { setConditionRules, CF_DATE_DEFAULT_FORMAT, parseCfDateConditionForUi, formatCfDatePresetSnapshot, parseDdMmYyyyToSerial, } from './ConditionFormat';
 export { handleOverlayTouchStart, handleOverlayTouchEnd } from './mobile';
 export { MAX_ZOOM_RATIO, MIN_ZOOM_RATIO } from './zoom';
 export { jfrefreshgrid } from './refresh';
+export { deleteCellsShift, insertCellsShift } from './cell-shift';
 export { sanitizeDuneUrl, insertDuneChart, onIframeMoveStart, onIframeResizeStart, onIframeMove, onIframeMoveEnd, onIframeResize, onIframeResizeEnd, } from './iframe';
 export { setCellError, clearCellError, overShowError, } from './error-state-helpers';
 export { checkCellIsLocked } from './protection';
 export { detectDateFormat, isdatatypemulti, diff, isdatetime, isRealNull, isRealNum, isNumericCellType, } from './validation';
-export { iscelldata, getcellrange, execfunction, execFunctionGroup, refreshFormulasUsingDefinedNames, runFormulaEvalChunk, applyWorkerFormulaChunkResults, insertUpdateFunctionGroup, functionCopy, } from './formula';
+export { iscelldata, getcellrange, execfunction, execFunctionGroup, refreshFormulasUsingDefinedNames, runFormulaEvalChunk, applyWorkerFormulaChunkResults, finishFullFormulaPass, resetFormulaDependencyIndexes, insertUpdateFunctionGroup, functionCopy, } from './formula';
 export { checkCF, getComputeMap } from './ConditionFormat';
 export { isValidDefinedNameIdentifier, getDefinedNameDisplayRange, findDefinedNameForSelection, findDefinedNameByName, resolveDefinedNameForFormula, addDefinedName, updateDefinedName, deleteDefinedName, selectDefinedName, openNamedRangesSidebar, scheduleDefinedNamesSync, shiftDefinedNamesOnInsert, shiftDefinedNamesOnDelete, removeDefinedNamesForSheet, } from './namedRanges';
 export { getdatabyselection, getQKBorder } from './cell';

package/dist/sheet-engine/core/modules/rowcol-refused-edit.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sheet-engine/core/modules/rowcol-unloaded-history.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sheet-engine/core/modules/rowcol.d.ts

@@ -1,5 +1,13 @@
 import { Context } from '../context';
+import { Sheet } from '../types';
 
+/**
+ * True when the edit would change a cross-tab formula in the tab's celldata.
+ * It is the test the rewrite below applies, so the tabs loaded before an edit
+ * are the ones it would rewrite (PR 466 N1: `=C1-A!B5` names tab A, but the
+ * sheet-name regex reads `C1-A`).
+ */
+export declare const celldataFormulaWouldChange: (sheet: Sheet, mode: "add" | "del", rc: "row" | "col", orient: "lefttop" | "rightbottom" | null, stindex: number, step: number, editedTab: string) => boolean;
 /**
  * 增加行列
  * @param {string} type 行或列 ['row', 'column'] 之一