@fileverse-dev/dsheet 4.1.22 → 4.1.23-stabilise-package-3

package/dist/sheet-engine/core/locale/zh_tw.d.ts

@@ -738,6 +738,7 @@ declare const _default: {
         cancelText: string;
         chooseText: string;
         focus: string;
+        copyLink: string;
         tipNameRepeat: string;
         noMoreSheet: string;
         confirmDelete: string;

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-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-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-transitive-deps.d.ts

@@ -3,5 +3,9 @@ export declare function toFormulaDepCellKey(sheetId: string, r: number, c: numbe
 /**
  * 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 (very large ranges, named ranges covering the edited cell). They
+ * join the same walk, so formulas that read their results are reached too.
  */
-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>): Set<string>;

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

@@ -0,0 +1,37 @@
+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 evaluating before it yields (default 8). */
+    budgetMs: number;
+    /** Runs the next slice later (idle callback in the app). */
+    schedule: (cb: () => void) => void;
+    isCancelled?: () => boolean;
+};
+/**
+ * Formula functions that are `async` (they fetch over the network, e.g.
+ * ETHERSCAN, EOA). The warm-up records their arguments but never calls them.
+ */
+export declare function isAsyncFormulaFunction(name: string): boolean;
+/**
+ * Walk the calc chain in slices and record every formula's dependencies, then
+ * mark the graph complete (C8). Resolves 'aborted' if the graph is cleared
+ * while it runs, a tab holding formulas is sparse, or `isCancelled` says so.
+ *
+ * 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

@@ -51,6 +51,24 @@ export declare class FormulaCache {
      * affect them even when no precise reverse edge exists.
      */
     formulasWithWideRangeDeps: Set<string>;
+    /**
+     * 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.
@@ -66,6 +84,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,8 +110,27 @@ 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[];
+/**
+ * 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;
 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). */
@@ -158,12 +210,16 @@ 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;
 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-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

@@ -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/paste/paste-dep-graph.test.d.ts

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

package/dist/sheet-engine/core/paste-helpers/calculate-range-cell-size.d.ts

@@ -1,5 +1,18 @@
 import { Context } from '../context';
 
+type Measure2d = {
+    measureText(t: string): {
+        width: number;
+    };
+    font: string;
+};
+/** Drop cached widths, e.g. after web fonts load and change the metrics. */
+export declare function clearSingleLineCache(): void;
+/**
+ * Width of one line of text in `font`, from canvas measureText, cached by
+ * (font, text). No DOM layout is involved.
+ */
+export declare function measureSingleLine(font: string, text: string, ctx2d: Measure2d): number;
 export declare function calculateRangeCellSize(ctx: Context, sheetId: string, startRow: number, endRow: number, startCol: number, endCol: number, maxColumnWidth?: number): {
     rowMax: Record<number, number>;
     colMax: Record<number, number>;
@@ -9,3 +22,4 @@ export declare const updateSheetCellSizes: (ctx: Context, sheetIndex: number, me
     rowMax: Record<number, number>;
     colMax: Record<number, number>;
 }, maxColumnWidth?: number) => void;
+export {};

package/dist/sheet-engine/core/paste-helpers/calculate-range-cell-size.test.d.ts

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

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

@@ -29,7 +29,17 @@ export type Hooks = {
     beforeUpdateCell?: (r: number, c: number, value: any) => boolean;
     /** Clears RTC remote-apply lock so local edits can run data-block formulas. */
     onLocalCellEdit?: () => void;
-    afterUpdateCell?: (row: number, column: number, oldValue: any, newValue: any) => void;
+    afterUpdateCell?: (row: number, column: number, oldValue: any, newValue: any, 
+    /** Sheet that held the cell when it was committed (updateCell only). */
+    sheetId?: string, 
+    /**
+     * `skipPersist`: the caller writes this cell to Yjs in its own batch (paste
+     * and fill), after the cell is final. Persisting here too wrote the
+     * pre-format value first, so every formula was written twice.
+     */
+    options?: {
+        skipPersist?: boolean;
+    }) => void;
     afterSelectionChange?: (sheetId: string, selection: Selection) => void;
     beforeRenderRowHeaderCell?: (rowNumber: string, rowIndex: number, top: number, width: number, height: number, ctx: CanvasRenderingContext2D) => boolean;
     afterRenderRowHeaderCell?: (rowNumber: string, rowIndex: number, top: number, width: number, height: number, ctx: CanvasRenderingContext2D) => void;
@@ -83,6 +93,10 @@ export type Hooks = {
     afterDeleteSheet?: (id: string) => void;
     beforeUpdateSheetName?: (id: string, oldName: string, newName: string) => boolean;
     afterUpdateSheetName?: (id: string, oldName: string, newName: string) => void;
+    onCopySheetLink?: (args: {
+        sheetId: string;
+        sheetName: string;
+    }) => void;
     afterImagesChange?: () => void;
     afterIframesChange?: () => void;
     afterFrozenChange?: () => void;

package/dist/sheet-engine/core/utils/ydoc-celldata-changes.d.ts

@@ -1,6 +1,17 @@
 import { Context } from '../context';
 import { Cell, CellWithRowAndCol } from '../types';
 
+/** Receives changes instead of the updateCellYdoc hook (see createYdocBatch). */
+export type YdocChangeSink = (changes: any[]) => void;
+/**
+ * Collect the Yjs changes of one structural edit and send them in a single
+ * updateCellYdoc call, so the edit is one transaction and one update for peers
+ * (an insert used to send four and a delete five).
+ */
+export declare function createYdocBatch(ctx: Context): {
+    sink: YdocChangeSink;
+    flush: () => void;
+};
 export type CelldataYdocChange = {
     sheetId: string;
     path: string[];
@@ -17,13 +28,29 @@ export declare function cellsEqualForYdocPersist(before: unknown, after: unknown
 export declare function snapshotPersistedCelldataInRange(data: unknown[][] | null | undefined, r1: number, r2: number, c1: number, c2: number, celldata?: CellWithRowAndCol[] | null): Map<string, Cell | string | number | boolean>;
 export declare function appendCelldataDiffChange(changes: CelldataYdocChange[], sheetId: string, r: number, c: number, cell: unknown, beforePersisted?: Map<string, Cell | string | number | boolean>): void;
 export declare function buildCelldataChangesForRange(sheetId: string, data: unknown[][], r1: number, r2: number, c1: number, c2: number, beforePersisted?: Map<string, Cell | string | number | boolean>): CelldataYdocChange[];
-export declare function emitCelldataRangeDiffToYdoc(ctx: Context, sheetId: string, data: unknown[][], r1: number, r2: number, c1: number, c2: number, beforePersisted?: Map<string, Cell | string | number | boolean>): void;
+export declare function emitCelldataRangeDiffToYdoc(ctx: Context, sheetId: string, data: unknown[][], r1: number, r2: number, c1: number, c2: number, beforePersisted?: Map<string, Cell | string | number | boolean>, sink?: YdocChangeSink): void;
+/** Formula text per tab and cell key, taken before a structural edit rewrites it. */
+export type FormulaTextSnapshot = Map<string, Map<string, string>>;
+/**
+ * Snapshot formula text on every hydrated tab. A row/column insert or delete
+ * rewrites formulas on all tabs, but only the edited tab's shifted range is
+ * diffed to Yjs, so the rest has to be found by comparing against this.
+ */
+export declare function snapshotFormulaTexts(ctx: Context): FormulaTextSnapshot;
+/**
+ * Emit cells whose formula text changed since `before`, so peers see the
+ * rewrite. On the edited tab, cells at or past (`editedFromR`, `editedFromC`)
+ * are skipped: the range diff already writes them. `before` keys are
+ * pre-edit coordinates, which equal post-edit ones for every cell outside
+ * that range.
+ */
+export declare function emitRewrittenFormulasToYdoc(ctx: Context, before: FormulaTextSnapshot, editedSheetId: string, editedFromR: number, editedFromC: number, sink?: YdocChangeSink): void;
 /**
  * After delete row/col, emit deletes for persisted keys that now sit past the
  * shrunken grid. Range diffs only visit coordinates still inside `data`, so
  * tail keys would otherwise resurrect on peers/reload.
  */
-export declare function emitCelldataDeletesBeyondGrid(ctx: Context, sheetId: string, beforePersisted: Map<string, Cell | string | number | boolean> | undefined, rowCount: number, colCount: number): void;
+export declare function emitCelldataDeletesBeyondGrid(ctx: Context, sheetId: string, beforePersisted: Map<string, Cell | string | number | boolean> | undefined, rowCount: number, colCount: number, sink?: YdocChangeSink): void;
 export type MergeBounds = {
     minR: number;
     minC: number;

package/dist/sheet-engine/react/components/ContextMenu/sheet-tab-menu-items.d.ts

@@ -0,0 +1,15 @@
+export declare const COPY_SHEET_LINK_ITEM = "copy-link";
+type ReadOnlyFlags = {
+    isFlvReadOnly?: boolean;
+    allowEdit?: boolean;
+};
+type CopyLinkHooks = {
+    onCopySheetLink?: unknown;
+};
+export declare function isSheetTabReadOnly(ctx: ReadOnlyFlags): boolean;
+export declare function canOpenSheetTabMenu(ctx: ReadOnlyFlags, hooks: CopyLinkHooks): boolean;
+export declare function getVisibleSheetTabMenuItems(items: string[], opts: {
+    readOnly: boolean;
+    hasCopyLink: boolean;
+}): string[];
+export {};

package/dist/sheet-engine/react/components/Workbook/api.d.ts

@@ -31,6 +31,10 @@ export declare function generateAPIs(context: Context, setContext: (recipe: (ctx
     applyRemoteCellValue: (row: number, column: number, value: any, options?: api.CommonOptions & {
         type?: keyof Cell;
     }) => void;
+    /** Remote formula-list change, applied in place (A4). */
+    setSheetCalcChain: (calcChain: Sheet["calcChain"], options?: api.CommonOptions) => void;
+    /** Remote cell batch: one quiet update, off the local undo stack (A5). */
+    applyRemoteCells: (cells: api.RemoteCellChange[], options?: api.CommonOptions, onSkip?: (cell: api.RemoteCellChange, error: unknown) => void) => void;
     setCellError: (row: number, column: number, errorMessage: {
         title: string;
         message: string;

package/dist/sheet-engine/react/components/Workbook/denomination-scan.d.ts

@@ -0,0 +1,16 @@
+import { Cell } from '../../../core/types';
+
+/**
+ * True when any displayed value (`m`) contains BTC, ETH or SOL. Walks the grid
+ * in place and returns at the first hit; no intermediate cell list is built.
+ */
+export declare function hasDenominatedCell(data: (Cell | null)[][]): boolean;
+type BannerDoc = Pick<Document, 'getElementById' | 'getElementsByClassName'>;
+/**
+ * Show or hide the crypto-denomination banner and move the scrollbar and
+ * add-row bar to match. A no-op when the host has not mounted the banner
+ * element; call again later (for example on selection change) to retry.
+ * Returns true when the banner element was found.
+ */
+export declare function applyDenominationBanner(denominated: boolean, doc?: BannerDoc): boolean;
+export {};

package/dist/sheet-engine/react/components/Workbook/denomination-scan.test.d.ts

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

package/dist/sheet-engine/react/components/Workbook/index.d.ts

@@ -33,6 +33,8 @@ declare const Workbook: React.ForwardRefExoticComponent<Settings & AdditionalPro
     applyRemoteCellValue: (row: number, column: number, value: any, options?: api.CommonOptions & {
         type?: keyof import('../../../core').Cell;
     }) => void;
+    setSheetCalcChain: (calcChain: SheetType["calcChain"], options?: api.CommonOptions) => void;
+    applyRemoteCells: (cells: api.RemoteCellChange[], options?: api.CommonOptions, onSkip?: (cell: api.RemoteCellChange, error: unknown) => void) => void;
     setCellError: (row: number, column: number, errorMessage: {
         title: string;
         message: string;