@fileverse-dev/dsheet 2.1.5 → 3.0.1-formula-1

package/dist/sheet-engine/core/api/cell.d.ts

@@ -6,26 +6,6 @@ export declare function getCellValue(ctx: Context, row: number, column: number,
     type?: keyof Cell;
 }): any;
 export declare function setCellValue(ctx: Context, row: number, column: number, value: any, cellInput: HTMLDivElement | null, options?: CommonOptions, callAfterUpdate?: boolean): void;
-/**
- * Apply a cell value coming from a remote RTC peer, verbatim.
- *
- * This differs from `setCellValue` in two important ways and must be used for
- * every Yjs-driven remote apply:
- *
- * 1. It NEVER runs the formula engine and NEVER fires the local-edit hooks
- *    (`onLocalCellEdit` / `afterUpdateCell`). The peer already computed the
- *    value, so we use the synced `v`/`m`/`f` as-is. This avoids both
- *    recomputation divergence and an update loop back into Yjs.
- *
- * 2. It PRESERVES the formula calc list. The regular `setCellValue` object
- *    branch calls `delFunctionGroup`, which removes the cell from `calcChain`
- *    and strips its dependency edges. Because `execFunctionGroup` walks
- *    `calcChain` to decide what to recompute, dropping a formula cell there
- *    permanently breaks its reactivity on that client (even after RTC stops).
- *    Here we instead keep formula cells registered via
- *    `insertUpdateFunctionGroup`, so they stay reactive to future local edits
- *    on both owner and peer.
- */
 export declare function applyRemoteCellValue(ctx: Context, row: number, column: number, value: any, options?: CommonOptions): void;
 export declare function clearCell(ctx: Context, row: number, column: number, options?: CommonOptions): void;
 export declare function setCellFormat(ctx: Context, row: number, column: number, attr: keyof Cell, value: any, options?: CommonOptions): void;

package/dist/sheet-engine/core/api/common.d.ts

@@ -1,12 +1,13 @@
 import { Context } from '../context';
 import { CellMatrix, CellWithRowAndCol, Sheet } from '../types';
+import { CellFormatRange } from '../utils/range-format';
 
 export type CommonOptions = {
     index?: number;
     id?: string;
 };
 export declare const dataToCelldata: (data: CellMatrix | undefined) => CellWithRowAndCol[];
-export declare const celldataToData: (celldata: CellWithRowAndCol[], rowCount?: number, colCount?: number) => CellMatrix | null;
+export declare const celldataToData: (celldata: CellWithRowAndCol[], rowCount?: number, colCount?: number, cellFormatRanges?: CellFormatRange[]) => CellMatrix | null;
 export declare function getSheet(ctx: Context, options?: CommonOptions): Sheet;
 export declare function getSheetWithLatestCelldata(ctx: Context, options?: CommonOptions): {
     celldata: CellWithRowAndCol[];

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

@@ -7,5 +7,6 @@ export * from './rowcol';
 export * from './range';
 export * from './merge';
 export * from './sheet';
+export * from './sheet-flowdata-lifecycle';
 export * from './workbook';
 export * from '../modules/error-state-helpers';

package/dist/sheet-engine/core/api/sheet-flowdata-lifecycle.d.ts

@@ -0,0 +1,17 @@
+import { Context } from '../context';
+
+/** Drop cached dense-sheet set (e.g. after structural workbook changes). */
+export declare function invalidateSheetsRequiredDenseCache(): void;
+/**
+ * Sheets that must keep dense `data` while `activeSheetId` is active:
+ * the active tab, tabs its formulas read, and tabs with formulas that read it.
+ */
+export declare function getSheetsRequiredDense(ctx: Context, activeSheetId: string): Set<string>;
+/** Sheets the formula worker needs dense — active refs plus any tab with formulas. */
+export declare function getSheetsNeededForWorkerSnapshot(ctx: Context): Set<string>;
+export declare function demoteSheetToCelldata(ctx: Context, sheetId: string): void;
+/**
+ * On tab switch: persist outgoing config, demote tabs not needed dense,
+ * hydrate active tab + cross-sheet references.
+ */
+export declare function syncAndDemoteInactiveFlowdata(ctx: Context, activeSheetId: string, previousSheetId: string | null): Set<string>;

package/dist/sheet-engine/core/api/sheet.d.ts

@@ -5,6 +5,11 @@ import { CellMatrix, Sheet } from '../types';
 export declare function getAllSheets(ctx: Context): Sheet[];
 export { getSheet };
 export declare function initSheetData(draftCtx: Context, index: number, newData: Sheet): CellMatrix | null;
+/** Build dense `data` from sparse `celldata` when a sheet is activated or referenced. */
+export declare function ensureSheetFlowdata(ctx: Context, options?: {
+    index?: number;
+    id?: string;
+}): CellMatrix | null;
 export declare function hideSheet(ctx: Context, sheetId: string): void;
 export declare function showSheet(ctx: Context, sheetId: string): void;
 export declare function copySheet(ctx: Context, sheetId: string): void;

package/dist/sheet-engine/core/context.d.ts

@@ -1,5 +1,6 @@
-import { SheetConfig, Sheet, Selection, Cell, CommentBox, Rect, Image, Presence, LinkCardProps, FilterOptions, RangeDialogProps, DataRegulationProps, ConditionRulesProps, GlobalCache, CellError } from './types';
+import { SheetConfig, Sheet, Selection, Cell, CommentBox, Rect, Image, Presence, LinkCardProps, FilterOptions, RangeDialogProps, DataRegulationProps, ConditionRulesProps, GlobalCache, CellError, DefinedName } from './types';
 import { FormulaCache } from './modules';
+import { FormulaAsyncEvalJob } from './modules/formula-async-eval';
 import { DateBaseLocale, Hooks } from './settings';
 
 interface MutableRefObject<T> {
@@ -115,6 +116,8 @@ export type Context = {
     currentSheetId: string;
     calculateSheetId: string;
     config: SheetConfig;
+    /** Workbook-level named ranges (synced via Yjs `${dsheetId}:definedNames`). */
+    definedNames: DefinedName[];
     visibledatarow: number[];
     visibledatacolumn: number[];
     ch_width: number;
@@ -239,6 +242,10 @@ export type Context = {
     luckysheetPaintSingle: boolean;
     defaultCell: Cell;
     groupValuesRefreshData: any[];
+    /** Chunked async formula recalc queue (Step 1 perf). Cleared when job completes. */
+    formulaAsyncEval?: FormulaAsyncEvalJob | null;
+    /** True while `formulaAsyncEval` is draining on the main thread in chunks. */
+    isFormulaCalculating?: boolean;
     /**
      * Incremented when formula `func_selectedrange` moves via keyboard (`rangeOfFormula`)
      * so React re-renders — `FormulaCache` is a class and Immer does not track it.

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

@@ -7,11 +7,11 @@ export { defaultSettings } from './settings';
 export type { Settings, Hooks, DateBaseLocale } from './settings';
 export { handleCopy, handleGlobalKeyDown, handlePaste, handlePasteByClick, fixPositionOnFrozenCells, handleCellAreaMouseDown, handleCellAreaDoubleClick, handleContextMenu, mouseRender, handleOverlayMouseMove, handleOverlayMouseUp, handleRowHeaderMouseDown, handleColumnHeaderMouseDown, handleColSizeHandleMouseDown, handleColSizeHandleDoubleClick, handleRowSizeHandleMouseDown, handleColFreezeHandleMouseDown, handleRowFreezeHandleMouseDown, describeMatchedShortcut, isBrowserZoomShortcut, isOpenShortcutsModalShortcut, isFormulaListShortcut, } from './events';
 export * from './locale';
-export { getBorderInfoComputeRange, getBorderInfoCompute, normalizedCellAttr, normalizedAttr, getCellValue, setCellValue, getRealCellValue, mergeBorder, cancelNormalSelected, updateCell, getRangetxt, getRangeByTxt, isValidRangeText, getInlineStringHTML, applyLinkToSelection, getHyperlinksFromInlineSegments, getUniformLinkFromWindowSelectionInEditor, getHyperlinkAtCaretInContentEditable, getStyleByCell, clearSelectedCellFormat, clearRowsCellsFormat, clearColumnsCellsFormat, clipboard, moveToEnd, getRangeRectsByCharacterOffset, getDateBaseLocale, getCanonicalDateEditFormat, getDateEditFormatForCell, isUsDateBaseLocale, normalizeDateBaseLocale, shouldPreserveDateFormatForEdit, setDateBaseLocale, update, is_date, valueShowEs, isTypedCurrencyDisplayFormat, isCurrencyLikeNumberFormat, buildFiatCurrencyFormat, quoteSsfLiteral, FormulaCache, groupValuesRefresh, execFunctionGroup, setCaretPosition, getrangeseleciton, getFormulaEditorOwner, rangeHightlightselected, handleFormulaInput, israngeseleciton, createRangeHightlight, maybeRecoverDirtyRangeSelection, getFormulaRangeIndexAtCaret, isCaretAtValidFormulaRangeInsertionPoint, isLegacyFormulaRangeMode, markRangeSelectionDirty, setFormulaEditorOwner, functionHTMLGenerate, suppressFormulaRangeSelectionForInitialEdit, rangeSetValue, getFormulaRangeIndexForKeyboardSync, createFormulaRangeSelect, isFormulaReferenceInputMode, seedFormulaFuncSelectedRangeFromLastSelection, initFreeze, isInlineStringCell, getInlineStringNoStyle, rowLocation, rowLocationByIndex, colLocation, colLocationByIndex, insertRowCol, deleteRowCol, hideSelected, showSelected, isShowHidenCR, getFilterHiddenRowsUnionFromFilterMap, getFilterHiddenRowsUnion, ensureManualHiddenInitialized, rebuildRowHiddenUnion, scrollToHighlightCell, selectTitlesMap, selectTitlesRange, defaultLuckysheetSelectRanges, normalizeSelection, syncPrimaryCellActiveFromSelection, selectionIsExactlyOneMergeBlock, setPrimaryCellActive, advancePrimaryCellInLastMultiSelection, snapSheetSelectionFocusToCellPreserveMultiRange, moveHighlightCell, deleteSelectedCellText, selectAll, fixRowStyleOverflowInFreeze, fixColumnStyleOverflowInFreeze, calcSelectionInfo, addSheet, deleteSheet, editSheetName, changeSheet, updateFormat, autoSelectionFormula, handleBold, handleItalic, handleStrikeThrough, handleUnderline, handleHorizontalAlign, handleVerticalAlign, handleTextColor, handleTextBackground, handleBorder, handleMerge, mergeSelectionHasValues, handleSort, getRemoveDuplicatesPreview, removeDuplicates, getRemoveDuplicatesErrorMessage, handleFreeze, handleTextSize, handleSum, handleLink, captureLinkEditorOpenSnapshot, isHyperlinkCreationBlocked, toolbarItemClickHandler, toolbarItemSelectedFunc, handleScreenShot, insertImage, showImgChooser, drawArrow, setEditingComment, removeEditingComment, removeOverShowComment, newComment, editComment, deleteComment, showComments, showHideComment, showHideAllComments, onCommentBoxMoveStart, removeActiveImage, cancelActiveImgItem, onImageMoveStart, onImageResizeStart, createDropCellRange, sortSelection, sortSheetBySelectedColumn, searchAll, searchNext, replace, replaceAll, replaceAllScoped, getSearchIndexArr, getSearchIndexArrAsync, getFindRangeOnCurrentSheet, getQuickSearchIndexArr, getQuickSearchHiddenConfig, getCellHyperlinks, getHyperlinkDisplayTextInCell, getInlineLinkPlainRange, getUniformLinkCoveringPlainRange, getUniformLinkAtPlainOffset, removeHyperlinkForLink, updateHyperlinkForLink, syncLinkCardAfterHyperlinkChange, expandCellRectForMerge, shouldQuickSearchUseAsync, runQuickSearchIndexArrAsync, QUICK_SEARCH_ASYNC_ROW_THRESHOLD, parseRangeText, getCellRowColumn, getCellHyperlink, saveHyperlink, removeHyperlink, showLinkCard, goToLink, isLinkValid, createFilterOptions, clearFilter, clearFilterForColumn, toggleViewerFilter, createFilter, applySheetFilterState, getFilterColumnValues, getFilterColumnColors, orderbydatafiler, saveFilter, onCellsMoveStart, cfSplitRange, updateMoreCell, getRegStr, getDataArr, applyLocation, getOptionValue, getSelectRange, getDropdownList, setDropdownValue, confirmMessage, setConditionRules, CF_DATE_DEFAULT_FORMAT, parseCfDateConditionForUi, formatCfDatePresetSnapshot, parseDdMmYyyyToSerial, handleOverlayTouchStart, handleOverlayTouchEnd, MAX_ZOOM_RATIO, MIN_ZOOM_RATIO, jfrefreshgrid, sanitizeDuneUrl, insertDuneChart, onIframeMoveStart, onIframeResizeStart, onIframeMove, onIframeMoveEnd, onIframeResize, onIframeResizeEnd, setCellError, clearCellError, detectDateFormat, isdatatypemulti, diff, isdatetime, isRealNull, isRealNum, isNumericCellType, iscelldata, getcellrange, cancelFunctionrangeSelected, seletedHighlistByindex, spillSortResult, execfunction, insertUpdateFunctionGroup, remapFormulaReferencesByMap, checkCF, getComputeMap, cancelPaintModel, hideCRCount, getdatabyselection, } from './modules';
+export { getBorderInfoComputeRange, getBorderInfoCompute, normalizedCellAttr, normalizedAttr, getCellValue, setCellValue, getRealCellValue, mergeBorder, cancelNormalSelected, updateCell, getRangetxt, getRangeByTxt, isValidRangeText, getInlineStringHTML, applyLinkToSelection, getHyperlinksFromInlineSegments, getUniformLinkFromWindowSelectionInEditor, getHyperlinkAtCaretInContentEditable, getStyleByCell, clearSelectedCellFormat, clearRowsCellsFormat, clearColumnsCellsFormat, clipboard, moveToEnd, getRangeRectsByCharacterOffset, getDateBaseLocale, getCanonicalDateEditFormat, getDateEditFormatForCell, isUsDateBaseLocale, normalizeDateBaseLocale, shouldPreserveDateFormatForEdit, setDateBaseLocale, update, is_date, valueShowEs, isTypedCurrencyDisplayFormat, isCurrencyLikeNumberFormat, buildFiatCurrencyFormat, quoteSsfLiteral, FormulaCache, groupValuesRefresh, execFunctionGroup, runFormulaEvalChunk, applyWorkerFormulaChunkResults, isFormulaEvalPending, FORMULA_ASYNC_CHUNK_SIZE, FORMULA_ASYNC_EVAL_THRESHOLD, FORMULA_WORKER_CHUNK_SIZE, FORMULA_WORKER_THRESHOLD, setCaretPosition, getrangeseleciton, getFormulaEditorOwner, rangeHightlightselected, handleFormulaInput, israngeseleciton, createRangeHightlight, maybeRecoverDirtyRangeSelection, getFormulaRangeIndexAtCaret, isCaretAtValidFormulaRangeInsertionPoint, isLegacyFormulaRangeMode, markRangeSelectionDirty, setFormulaEditorOwner, functionHTMLGenerate, suppressFormulaRangeSelectionForInitialEdit, ensureFormulaRangeToSheet, shouldPreserveFormulaEditOnSheetSwitch, activateSheetForNavigation, returnToFormulaOriginSheet, rangeSetValue, getFormulaRangeIndexForKeyboardSync, createFormulaRangeSelect, isFormulaReferenceInputMode, seedFormulaFuncSelectedRangeFromLastSelection, initFreeze, isInlineStringCell, getInlineStringNoStyle, rowLocation, rowLocationByIndex, colLocation, colLocationByIndex, insertRowCol, deleteRowCol, hideSelected, showSelected, isShowHidenCR, getFilterHiddenRowsUnionFromFilterMap, getFilterHiddenRowsUnion, ensureManualHiddenInitialized, rebuildRowHiddenUnion, scrollToHighlightCell, selectTitlesMap, selectTitlesRange, defaultLuckysheetSelectRanges, normalizeSelection, syncPrimaryCellActiveFromSelection, selectionIsExactlyOneMergeBlock, setPrimaryCellActive, advancePrimaryCellInLastMultiSelection, snapSheetSelectionFocusToCellPreserveMultiRange, moveHighlightCell, deleteSelectedCellText, selectAll, fixRowStyleOverflowInFreeze, fixColumnStyleOverflowInFreeze, calcSelectionInfo, addSheet, deleteSheet, editSheetName, changeSheet, updateFormat, autoSelectionFormula, handleBold, handleItalic, handleStrikeThrough, handleUnderline, handleHorizontalAlign, handleVerticalAlign, handleTextColor, handleTextBackground, handleBorder, handleMerge, mergeSelectionHasValues, handleSort, getRemoveDuplicatesPreview, removeDuplicates, getRemoveDuplicatesErrorMessage, handleFreeze, handleTextSize, handleSum, handleLink, captureLinkEditorOpenSnapshot, isHyperlinkCreationBlocked, toolbarItemClickHandler, toolbarItemSelectedFunc, handleScreenShot, insertImage, showImgChooser, drawArrow, setEditingComment, removeEditingComment, removeOverShowComment, newComment, editComment, deleteComment, showComments, showHideComment, showHideAllComments, onCommentBoxMoveStart, removeActiveImage, cancelActiveImgItem, onImageMoveStart, onImageResizeStart, createDropCellRange, sortSelection, sortSheetBySelectedColumn, searchAll, searchNext, replace, replaceAll, replaceAllScoped, getSearchIndexArr, getSearchIndexArrAsync, getFindRangeOnCurrentSheet, getQuickSearchIndexArr, getQuickSearchHiddenConfig, getCellHyperlinks, getHyperlinkDisplayTextInCell, getInlineLinkPlainRange, getUniformLinkCoveringPlainRange, getUniformLinkAtPlainOffset, removeHyperlinkForLink, updateHyperlinkForLink, syncLinkCardAfterHyperlinkChange, expandCellRectForMerge, shouldQuickSearchUseAsync, runQuickSearchIndexArrAsync, QUICK_SEARCH_ASYNC_ROW_THRESHOLD, parseRangeText, getCellRowColumn, getCellHyperlink, saveHyperlink, removeHyperlink, showLinkCard, goToLink, isLinkValid, createFilterOptions, clearFilter, clearFilterForColumn, toggleViewerFilter, createFilter, applySheetFilterState, getFilterColumnValues, getFilterColumnColors, orderbydatafiler, saveFilter, onCellsMoveStart, cfSplitRange, updateMoreCell, getRegStr, getDataArr, applyLocation, getOptionValue, getSelectRange, getDropdownList, setDropdownValue, confirmMessage, setConditionRules, CF_DATE_DEFAULT_FORMAT, parseCfDateConditionForUi, formatCfDatePresetSnapshot, parseDdMmYyyyToSerial, handleOverlayTouchStart, handleOverlayTouchEnd, MAX_ZOOM_RATIO, MIN_ZOOM_RATIO, jfrefreshgrid, sanitizeDuneUrl, insertDuneChart, onIframeMoveStart, onIframeResizeStart, onIframeMove, onIframeMoveEnd, onIframeResize, onIframeResizeEnd, setCellError, clearCellError, detectDateFormat, isdatatypemulti, diff, isdatetime, isRealNull, isRealNum, isNumericCellType, iscelldata, getcellrange, cancelFunctionrangeSelected, seletedHighlistByindex, spillSortResult, execfunction, insertUpdateFunctionGroup, remapFormulaReferencesByMap, refreshFormulasUsingDefinedNames, checkCF, getComputeMap, isValidDefinedNameIdentifier, getDefinedNameDisplayRange, findDefinedNameForSelection, findDefinedNameByName, resolveDefinedNameForFormula, addDefinedName, updateDefinedName, deleteDefinedName, selectDefinedName, openNamedRangesSidebar, scheduleDefinedNamesSync, shiftDefinedNamesOnInsert, shiftDefinedNamesOnDelete, removeDefinedNamesForSheet, cancelPaintModel, hideCRCount, getdatabyselection, } from './modules';
 export type { FilterDate, FilterValue, FilterColor } from './modules';
 export { getFreezeState, toggleFreeze, indexToColumnChar, escapeScriptTag, escapeHTMLTag, getSheetIndex, replaceHtml, isAllowEdit, isAllowEditReadOnly, filterPatch, patchToOp, opToPatch, inverseRowColOptions, } from './utils';
 export type { PatchOptions, ChangedSheet } from './utils';
-export type { Op, Cell, CellWithRowAndCol, CellMatrix, HyperlinkEntry, Selection, Presence, Sheet, GlobalCache, SingleRange, Range, SearchResult, LinkCardProps, LiveQueryData, Freezen, } from './types';
+export type { Op, Cell, CellWithRowAndCol, CellMatrix, HyperlinkEntry, Selection, Presence, Sheet, GlobalCache, SingleRange, Range, SearchResult, LinkCardProps, LiveQueryData, Freezen, DefinedName, } from './types';
 export type { RemoveDuplicatesColumnOption, RemoveDuplicatesError, RemoveDuplicatesOptions, RemoveDuplicatesPreview, RemoveDuplicatesResult, } from './modules';
 export type { CheckModes, HyperlinkMap, FindSearchScope, ReplaceScope, SearchHiddenConfig, SearchNextResult, ReplaceAllResult, } from './modules/searchReplace';
 export { cellFadeAnimator, markCellChanged } from './animate';

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

@@ -0,0 +1,53 @@
+/** Minimum formula count before deferring eval to chunked async (Step 1). */
+export declare const FORMULA_ASYNC_EVAL_THRESHOLD = 15;
+/** Formulas evaluated per animation frame during async recalc. */
+export declare const FORMULA_ASYNC_CHUNK_SIZE = 50;
+/** Use a Web Worker when the async job has at least this many formulas. */
+export declare const FORMULA_WORKER_THRESHOLD = 100;
+/** Formulas evaluated per worker message (larger — runs off main thread). */
+export declare const FORMULA_WORKER_CHUNK_SIZE = 300;
+/** Maximum time to wait for a worker chunk before falling back to the real engine. */
+export declare const FORMULA_WORKER_CHUNK_TIMEOUT_MS = 30000;
+/** localStorage key for the optional formula execution debug panel. */
+export declare const FORMULA_EXEC_DEBUG_STORAGE_KEY = "fortune-formula-execution-debug";
+export declare function isFormulaExecutionDebugEnabled(): boolean;
+export type FormulaEvalDebugMode = 'worker' | 'main-thread' | 'fallback';
+export type FormulaEvalDebug = {
+    mode: FormulaEvalDebugMode;
+    lastChunkMs: number;
+    lastChunkSize: number;
+    completedChunks: number;
+    fallbackChunks: number;
+    workerAvailable: boolean;
+    unsafeFormulaCount: number;
+    workerFormulaCount: number;
+    totalWorkerFormulas: number;
+    totalMainThreadFormulas: number;
+    lastError: string | null;
+};
+export type FormulaAsyncEvalJob = {
+    formulaRunList: Array<{
+        r: number;
+        c: number;
+        id: string;
+        calc_funcStr: string;
+        level?: number;
+    }>;
+    calcChainKeys: string[];
+    impactedByCircular: string[];
+    cycleNodes: string[];
+    workerSnapshotKey: string;
+    nextIndex: number;
+    total: number;
+    debug?: FormulaEvalDebug;
+};
+export declare function isFormulaEvalPending(ctx: {
+    isFormulaCalculating?: boolean;
+    formulaAsyncEval?: FormulaAsyncEvalJob | null;
+}): boolean;
+/**
+ * The worker snapshot evaluator intentionally handles only scalar formulas that
+ * mirror the main engine well. Dynamic/spill/range-indirection formulas stay on
+ * the main thread so `spillSortResult` and special range logic remain authoritative.
+ */
+export declare function isFormulaWorkerUnsafe(calcFuncStr: string): boolean;

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

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

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

@@ -0,0 +1,20 @@
+export type RangePassCacheEntry = {
+    fragment: any[][];
+    cryptoDenomination: string;
+    cryptoDecimal: number;
+    globalDataKeysFingerprint: string;
+};
+export declare function makeRangePassCacheKey(sheetId: string, startRow: number, endRow: number, startCol: number, endCol: number): string;
+export declare function collectGlobalDataKeysInRange(execFunctionGlobalData: Record<string, unknown>, sheetId: string, startRow: number, endRow: number, startCol: number, endCol: number): string;
+/** Remove the formula origin cell from a full rectangular range fragment. */
+export declare function sliceRangeFragmentForOrigin(full: any[][], startRow: number, startCol: number, originRow: number | null | undefined, originCol: number | null | undefined): any[][];
+type RangeCacheHost = {
+    rangeValuePassCache?: Map<string, RangePassCacheEntry>;
+    rangeValuePassCacheStats?: {
+        hits: number;
+        misses: number;
+    };
+};
+export declare function beginRangeValuePassCache(cache: RangeCacheHost): void;
+export declare function clearRangeValuePassCache(cache: RangeCacheHost): void;
+export {};

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

@@ -0,0 +1,51 @@
+import { CellMatrix } from '../types';
+
+export type SnapshotSheet = {
+    id: string;
+    name: string;
+    data: CellMatrix | null | undefined;
+};
+export type SnapshotFormulaCell = {
+    r: number;
+    c: number;
+    id: string;
+    calc_funcStr: string;
+};
+export type SnapshotFormulaResult = {
+    r: number;
+    c: number;
+    id: string;
+    v: unknown;
+    f: string;
+    spe?: unknown;
+    deps: string[];
+    isError: boolean;
+};
+export type SnapshotEvalInput = {
+    sheets: SnapshotSheet[];
+    execFunctionGlobalData: Record<string, {
+        v: unknown;
+        f: unknown;
+    }>;
+    formulas: SnapshotFormulaCell[];
+    /** Workbook-level named ranges for VARIABLE resolution. */
+    definedNames?: Array<{
+        name: string;
+        sheetId: string;
+        range: {
+            row: [number, number];
+            column: [number, number];
+        };
+        scope?: 'workbook' | 'sheet';
+        localSheetId?: string;
+    }>;
+};
+export type SnapshotEvalOutput = {
+    execFunctionGlobalData: Record<string, {
+        v: unknown;
+        f: unknown;
+    }>;
+    results: SnapshotFormulaResult[];
+};
+/** Worker-safe formula evaluation against plain sheet snapshots (no React/immer). */
+export declare function evalFormulasInSnapshot(input: SnapshotEvalInput): SnapshotEvalOutput;

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

@@ -0,0 +1,7 @@
+/** Cell / formula key format used in depsByCell and revDepsByCell. */
+export declare function toFormulaDepCellKey(sheetId: string, r: number, c: number): string;
+/**
+ * Walk revDepsByCell from a changed cell to collect every formula cell that
+ * must recalculate (direct + transitive dependents).
+ */
+export declare function collectTransitiveFormulaDependents(originCellKey: string, revDepsByCell: Map<string, Set<string>>): Set<string>;

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

@@ -0,0 +1,17 @@
+import { Context } from '../context';
+import { SnapshotEvalInput, SnapshotEvalOutput, SnapshotFormulaCell, evalFormulasInSnapshot } from './formula-snapshot-eval';
+import { FORMULA_WORKER_CHUNK_SIZE } from './formula-async-eval';
+
+export declare function invalidateFormulaWorkerSnapshot(): void;
+export declare function buildSnapshotEvalInput(ctx: Context, formulas: SnapshotFormulaCell[]): SnapshotEvalInput;
+export declare function buildWorkerEvalInput(ctx: Context, formulas: SnapshotFormulaCell[]): Omit<SnapshotEvalInput, 'sheets'>;
+export declare function initFormulaWorkerSnapshot(ctx: Context, snapshotKey: string): boolean;
+/**
+ * Evaluate a formula chunk off the critical UI path when possible.
+ * Uses an inline Web Worker. Callers should fall back to the real engine on
+ * rejection so the worker cannot silently leave a recalculation job hanging.
+ */
+export declare function evalFormulasInBackground(snapshotKey: string, input: Omit<SnapshotEvalInput, 'sheets'>): Promise<SnapshotEvalOutput>;
+/** @deprecated Use evalFormulasInBackground */
+export declare const evalFormulasInWorker: typeof evalFormulasInBackground;
+export { FORMULA_WORKER_CHUNK_SIZE, evalFormulasInSnapshot };

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

@@ -0,0 +1,24 @@
+import { SnapshotEvalInput, SnapshotEvalOutput, SnapshotSheet } from './formula-snapshot-eval';
+
+export type WorkerInitSnapshotRequest = {
+    type: 'init-snapshot';
+    snapshotKey: string;
+    sheets: SnapshotSheet[];
+};
+export type WorkerEvalRequest = {
+    type: 'eval';
+    requestId: number;
+    snapshotKey: string;
+    input: Omit<SnapshotEvalInput, 'sheets'>;
+};
+export type WorkerRequest = WorkerInitSnapshotRequest | WorkerEvalRequest;
+export type WorkerEvalResponse = {
+    type: 'eval-result';
+    requestId: number;
+    output: SnapshotEvalOutput;
+};
+export type WorkerEvalError = {
+    type: 'eval-error';
+    requestId: number;
+    message: string;
+};

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

@@ -1,5 +1,8 @@
-import { Cell, Rect, Selection } from '../types';
+import { Cell, CellMatrix, Rect, Selection } from '../types';
 import { Context } from '../context';
+import { FormulaAsyncEvalJob } from './formula-async-eval';
+import { RangePassCacheEntry } from './formula-range-cache';
+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. */
 export declare function isTodayNowPureArithmeticDateResult(formula: string, value: number): boolean;
@@ -28,6 +31,11 @@ export declare class FormulaCache {
     /** True after arrow/Shift+arrow moved `func_selectedrange` without updating yellow selection. */
     formulaKeyboardRefSync?: boolean;
     formulaEditorOwner?: 'cell' | 'fx' | null;
+    /**
+     * Set when switching sheets while a formula edit stays open so InputBox/Fx
+     * can restore focus/caret for continued keyboard ref picking.
+     */
+    refocusFormulaEditorAfterSheetSwitch?: boolean;
     functionRangeIndex?: number[];
     functionRangeGlobalOffset?: number | null;
     functionlistMap: any;
@@ -37,6 +45,12 @@ export declare class FormulaCache {
     depsByCell: Map<string, Set<string>>;
     /** Reverse dependency graph: referenced cell -> dependent formula cells. */
     revDepsByCell: Map<string, Set<string>>;
+    /**
+     * Formulas that referenced a range too large to fully expand into `revDepsByCell`.
+     * These must be included on incremental recalcs because a single-cell edit may
+     * affect them even when no precise reverse edge exists.
+     */
+    formulasWithWideRangeDeps: Set<string>;
     /**
      * Dependency collection state for the currently-parsed formula, set by `execfunction`.
      * When null, dependency recording is disabled.
@@ -44,8 +58,20 @@ export declare class FormulaCache {
     activeDepCollection: null | {
         originKey: string;
         deps: Set<string>;
+        hasWideRangeDep: boolean;
+    };
+    /** Step 2: per execFunctionGroup pass cache for materialized range reads. */
+    rangeValuePassCache?: Map<string, RangePassCacheEntry>;
+    rangeValuePassCacheStats?: {
+        hits: number;
+        misses: number;
     };
     constructor();
+    materializeFullRangeFragment(context: Context, sheetId: string, flowdata: CellMatrix | null | undefined, startRow: number, endRow: number, startCol: number, endCol: number): {
+        fragment: any[][];
+        cryptoDenomination: string;
+        cryptoDecimal: number;
+    };
     tryGetCellAsNumber(cell: Cell): string | number | boolean | undefined;
 }
 export declare function iscelldata(txt: string): boolean;
@@ -55,6 +81,15 @@ export declare function delFunctionGroup(ctx: Context, r: number, c: number, id?
 export declare function insertUpdateFunctionGroup(ctx: Context, r: number, c: number, id?: string, calcChainSet?: Set<string>): void;
 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;
+/** 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. */
+export declare function runFormulaEvalChunk(ctx: Context, job: FormulaAsyncEvalJob, chunkSize?: number): boolean;
+/**
+ * Re-evaluate formula cells that reference the given defined names
+ * (e.g. after a named range was edited, shifted, or deleted).
+ */
+export declare function refreshFormulasUsingDefinedNames(ctx: Context, names: string[]): void;
 export declare function execFunctionGroup(ctx: Context, origin_r: number, origin_c: number, value: any, id?: string, data?: any, isForce?: boolean): void;
 /**
  * Before the first `moveHighlightCell/Range(..., "rangeOfFormula")` while editing
@@ -77,6 +112,23 @@ export declare function getLastFormulaRangeIndex($editor: HTMLDivElement): numbe
 export declare function getFormulaRangeIndexAtCaret($editor: HTMLDivElement): number | null;
 export declare function setFormulaEditorOwner(ctx: Context, owner: 'cell' | 'fx' | null): void;
 export declare function getFormulaEditorOwner(ctx: Context): 'cell' | 'fx' | null;
+/**
+ * Record the sheet where the formula edit started so cross-sheet picks can emit
+ * `SheetName!A1` via `rangeSetValue` / `getRangetxt`.
+ */
+export declare function ensureFormulaRangeToSheet(ctx: Context): void;
+/** True while an in-cell / fx formula edit should survive sheet-tab switches. */
+export declare function shouldPreserveFormulaEditOnSheetSwitch(ctx: Context): boolean;
+/**
+ * Activate another sheet from tab click or Alt/Option+Arrow navigation.
+ * Returns whether the sheet changed and whether formula edit was preserved.
+ */
+export declare function activateSheetForNavigation(ctx: Context, targetSheetId: string): 'preserved-formula' | 'cancel-edit' | false;
+/**
+ * Switch back to the formula's origin sheet (and restore its scroll/selection)
+ * before commit or cancel. Returns true when a switch happened.
+ */
+export declare function returnToFormulaOriginSheet(ctx: Context): boolean;
 /**
  * True when the formula text looks like a truncated A1-style range: LHS has a row
  * number but RHS after ":" is only column letters (e.g. =A1:A after deleting the

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

@@ -4,7 +4,9 @@ export { default as clipboard } from './clipboard';
 export { moveToEnd, getRangeRectsByCharacterOffset } from './cursor';
 export { getDateBaseLocale, 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, } 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, 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';
 export { isInlineStringCell, getInlineStringNoStyle, applyLinkToSelection, getHyperlinksFromInlineSegments, getUniformLinkFromWindowSelectionInEditor, getHyperlinkAtCaretInContentEditable, } from './inline-string';
 export { rowLocation, rowLocationByIndex, colLocation, colLocationByIndex, } from './location';
@@ -40,6 +42,7 @@ export { sanitizeDuneUrl, insertDuneChart, onIframeMoveStart, onIframeResizeStar
 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, insertUpdateFunctionGroup, functionCopy, } from './formula';
+export { iscelldata, getcellrange, execfunction, execFunctionGroup, refreshFormulasUsingDefinedNames, runFormulaEvalChunk, applyWorkerFormulaChunkResults, 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/namedRanges.d.ts

@@ -0,0 +1,53 @@
+import { Context } from '../context';
+import { DefinedName, SingleRange } from '../types';
+
+/** Excel/Google: names must start with letter/underscore; no spaces; not a cell ref. */
+export declare function isValidDefinedNameIdentifier(name: string): boolean;
+export declare function getDefinedNameDisplayRange(ctx: Context, dn: DefinedName): string;
+export declare function findDefinedNameForSelection(ctx: Context): DefinedName | null;
+export declare function findDefinedNameByName(ctx: Context, name: string, excludeId?: string): DefinedName | null;
+/**
+ * Resolve a formula VARIABLE (e.g. `=SUM(Custom)`) to a defined name.
+ * Prefers sheet-scoped names matching `formulaSheetId`, then workbook-scoped.
+ */
+export declare function resolveDefinedNameForFormula(definedNames: DefinedName[] | undefined | null, name: string, formulaSheetId?: string): DefinedName | null;
+export declare function addDefinedName(ctx: Context, input: {
+    name: string;
+    sheetId: string;
+    range: SingleRange;
+    scope?: DefinedName['scope'];
+    localSheetId?: string;
+}): {
+    ok: true;
+    namedRange: DefinedName;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function updateDefinedName(ctx: Context, id: string, patch: {
+    name?: string;
+    sheetId?: string;
+    range?: SingleRange;
+}): {
+    ok: true;
+    namedRange: DefinedName;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function deleteDefinedName(ctx: Context, id: string): boolean;
+/** Jump to a named range (switch sheet if needed) and select its cells. */
+export declare function selectDefinedName(ctx: Context, id: string): boolean;
+export declare function openNamedRangesSidebar(): void;
+/**
+ * Defer Yjs sync until after Immer applies the draft (same pattern as
+ * sheet-metadata-hooks). Capture the hook fn — not `ctx.hooks` — so the
+ * draft proxy is not read after revoke.
+ */
+export declare function scheduleDefinedNamesSync(ctx: Context): void;
+/** Shift named ranges on the given sheet after row/col insert. Returns affected names. */
+export declare function shiftDefinedNamesOnInsert(ctx: Context, sheetId: string, type: 'row' | 'column', index: number, count: number, direction: 'lefttop' | 'rightbottom'): string[];
+/** Shift/remove named ranges on the given sheet after row/col delete. */
+export declare function shiftDefinedNamesOnDelete(ctx: Context, sheetId: string, type: 'row' | 'column', start: number, end: number): string[];
+/** Drop named ranges that pointed at a deleted sheet. */
+export declare function removeDefinedNamesForSheet(ctx: Context, deletedSheetId: string): string[];

package/dist/sheet-engine/core/modules/sheet-metadata-hooks.d.ts

@@ -3,5 +3,9 @@ import { Context } from '../context';
 /**
  * Defer sheet-level metadata hooks until after React applies Immer updates, so
  * getSheet() / Yjs diff see dataVerification, CF rules, and hyperlinks from paste/cut.
+ *
+ * Capture the hook fns themselves (not `ctx.hooks`): paste runs inside produce,
+ * and reading a draft `hooks` proxy after it is revoked throws
+ * "Cannot perform 'get' on a proxy that has been revoked".
  */
 export declare function scheduleSheetMetadataSyncHooks(ctx: Context): void;

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

@@ -1,7 +1,23 @@
 import { Context } from '../context';
 import { Settings } from '../settings';
-import { CellMatrix, Sheet } from '../types';
+import { CellMatrix, Sheet, SheetConfig } from '../types';
+import { CellFormatRange } from '../utils/range-format';
 
+/**
+ * Persist active ctx.config onto ONE sheet file only.
+ * If Immer wrote keys (e.g. cellFormatRanges) on file.config but not ctx.config,
+ * keep those instead of wiping them with a blind replace.
+ * Never touches other sheets.
+ */
+export declare function assignActiveConfigToSheetFile(file: Sheet, activeConfig: SheetConfig | undefined): void;
+/**
+ * Promote format-only cells in a rectangle into cellFormatRanges.
+ * Scans only [r1..r2]×[c1..c2]. Returns new ranges if anything changed.
+ *
+ * Writes through luckysheetfile[i].config (same as toolbar) so Immer undo
+ * history tracks the change and peers get the reverse via afterConfigChanges.
+ */
+export declare function syncFormatOnlyRectIntoRanges(ctx: Context, cfg: SheetConfig | undefined, data: CellMatrix | null | undefined, r1: number, r2: number, c1: number, c2: number): CellFormatRange[] | null;
 export declare function storeSheetParamALL(ctx: Context): void;
 export declare function changeSheet(ctx: Context, id: string, isPivotInitial?: boolean, isNewSheet?: boolean, isCopySheet?: boolean): void;
 export declare function addSheet(ctx: Context, settings?: Required<Settings>, newSheetID?: string | undefined, // if action is from websocket, there will be a new sheetID

package/dist/sheet-engine/core/paste/paste-border-utils.d.ts

@@ -0,0 +1,23 @@
+export declare function isTransparentBorderColor(color: string): boolean;
+export declare function isMeaningfulBorderSide(side: {
+    style?: number;
+    color?: string;
+} | undefined): boolean;
+export declare function filterMeaningfulBorderSides(sides: {
+    l?: {
+        style?: number;
+        color?: string;
+    };
+    r?: {
+        style?: number;
+        color?: string;
+    };
+    t?: {
+        style?: number;
+        color?: string;
+    };
+    b?: {
+        style?: number;
+        color?: string;
+    };
+}): typeof sides;

package/dist/sheet-engine/core/settings.d.ts

@@ -22,8 +22,10 @@ export type Hooks = {
     filterChange?: () => void;
     cellDataChange?: () => void;
     hyperlinkChange?: () => void;
+    /** Workbook-level named ranges (definedNames) changed — sync to Yjs. */
+    definedNamesChange?: () => void;
     updateCellYdoc?: (changes: SheetChangePath[]) => void;
-    updateAllCell?: (sheetId: string) => void;
+    updateAllCell?: (sheetId: string, caller?: string) => void;
     beforeUpdateCell?: (r: number, c: number, value: any) => boolean;
     /** Clears RTC remote-apply lock so local edits can run data-block formulas. */
     onLocalCellEdit?: () => void;