@univerjs-pro/engine-formula-rust 1.0.0-insiders.20260725-1b9c8d8

package/lib/types/regression/xlsx-sample-compatibility.d.ts

@@ -0,0 +1,56 @@
+export declare const DEFAULT_XLSX_SAMPLE_COMPATIBILITY_ROOT = "C:\\Users\\wbfsa\\Downloads\\gdpval";
+export declare const XLSX_SAMPLE_COMPATIBILITY_GROUPS: readonly ['deliverable_files', 'reference_files'];
+export type XlsxSampleCompatibilityGroup = (typeof XLSX_SAMPLE_COMPATIBILITY_GROUPS)[number];
+export type XlsxSampleCompatibilityStatus = 'pending' | 'running' | 'failed' | 'passed' | 'unsupported-recorded';
+export type XlsxSampleCompatibilityStage = 'sourceExcelOracle' | 'rustImport' | 'viewerOpen' | 'viewerCompare' | 'rustExport' | 'exportedExcelOpen' | 'exportedCompare' | 'reportWrite';
+export interface XlsxSampleCompatibilityRunnerArgs {
+    readonly sampleRoot: string;
+    readonly outputRoot: string;
+    readonly manifestPath?: string;
+    readonly caseSelector?: string;
+}
+export interface XlsxSampleWorkbookFile {
+    readonly path: string;
+    readonly size: number;
+    readonly modifiedTimeMs: number;
+}
+export interface XlsxSampleCompatibilityDiagnostic {
+    readonly classification: string;
+    readonly message: string;
+}
+export interface XlsxSampleCompatibilityCase {
+    readonly activeStage: XlsxSampleCompatibilityStage | null;
+    readonly artifactDir: string;
+    readonly caseId: string;
+    readonly group: XlsxSampleCompatibilityGroup;
+    readonly lastDiagnostic: XlsxSampleCompatibilityDiagnostic | null;
+    readonly modifiedTimeMs: number;
+    readonly relativePath: string;
+    readonly size: number;
+    readonly sourcePath: string;
+    readonly status: XlsxSampleCompatibilityStatus;
+}
+export interface XlsxSampleCompatibilityManifest {
+    readonly cases: readonly XlsxSampleCompatibilityCase[];
+    readonly createdAt: string;
+    readonly outputRoot: string;
+    readonly runId: string;
+    readonly sampleRoot: string;
+}
+export interface CreateXlsxSampleCompatibilityManifestOptions {
+    readonly listWorkbookFiles?: (groupRoot: string) => Promise<readonly XlsxSampleWorkbookFile[]>;
+    readonly now?: () => Date;
+    readonly outputRoot: string;
+    readonly runId: string;
+    readonly sampleRoot?: string;
+}
+export interface RunXlsxSampleCompatibilityRunnerOptions extends CreateXlsxSampleCompatibilityManifestOptions {
+    readonly caseSelector?: string;
+    readonly manifestPath?: string;
+    readonly startStage?: XlsxSampleCompatibilityStage;
+}
+export declare function runXlsxSampleCompatibilityRunner(options: RunXlsxSampleCompatibilityRunnerOptions): Promise<XlsxSampleCompatibilityManifest>;
+export declare function parseXlsxSampleCompatibilityRunnerArgs(args: readonly string[]): XlsxSampleCompatibilityRunnerArgs;
+export declare function createXlsxSampleCompatibilityManifest(options: CreateXlsxSampleCompatibilityManifestOptions): Promise<XlsxSampleCompatibilityManifest>;
+export declare function persistXlsxSampleCompatibilityManifest(manifest: XlsxSampleCompatibilityManifest, manifestPath: string): Promise<void>;
+export declare function startXlsxSampleCompatibilityCase(manifest: XlsxSampleCompatibilityManifest, caseId: string, activeStage: XlsxSampleCompatibilityStage): XlsxSampleCompatibilityManifest;

package/lib/types/services/calculate-formula.service.d.ts

@@ -0,0 +1,106 @@
+import type { IUnitRange, Nullable } from '@univerjs/core';
+import type { IAllRuntimeData, ICalculateFormulaService, IExecutionInProgressParams, IFeatureDirtyRangeType, IFormulaDependencyTreeJson, IFormulaDatasetConfig, IFormulaExecuteResultMap, IFormulaStringMap, IRuntimeUnitDataType, ISetFormulaCalculationResultMutation, IUnitRowData } from '@univerjs/engine-formula';
+import type { IRustFormulaDependencyExecutionOutput } from '../types.js';
+import { Disposable, ICommandService, IConfigService } from '@univerjs/core';
+import { IFeatureCalculationManagerService, IFormulaCurrentConfigService, IFormulaDependencyGenerator, IFormulaRuntimeService, IOtherFormulaManagerService } from '@univerjs/engine-formula';
+import { ExternalReferencePrefetchPlanner, ExternalReferencePrefetchService } from '@univerjs-pro/engine-formula';
+import { Subject } from 'rxjs';
+import { RustEngineSyncController } from '../controllers/rust-engine-sync.controller.js';
+export interface IRustCalculateFormulaService extends ICalculateFormulaService {
+}
+export declare const IRustCalculateFormulaService: import("@wendellhu/redi").IdentifierDecorator<IRustCalculateFormulaService>;
+export declare function rustExecutionOutputToCalculationResult(output: IRustFormulaDependencyExecutionOutput): ISetFormulaCalculationResultMutation;
+/**
+ * Rust-backed implementation of ICalculateFormulaService.
+ *
+ * This service acts as an adapter: it gathers all necessary data from the TS-side
+ * DI container, serializes it, sends it to the Rust engine via NAPI, then writes
+ * the results back into IFormulaRuntimeService.
+ */
+export declare class RustCalculateFormulaService extends Disposable implements IRustCalculateFormulaService {
+    protected readonly _configService: IConfigService;
+    protected readonly _currentConfigService: IFormulaCurrentConfigService;
+    protected readonly _runtimeService: IFormulaRuntimeService;
+    protected readonly _formulaDependencyGenerator: IFormulaDependencyGenerator;
+    protected readonly _featureCalculationManagerService: IFeatureCalculationManagerService;
+    protected readonly _otherFormulaManagerService: IOtherFormulaManagerService;
+    protected readonly _commandService: ICommandService;
+    private readonly _rustEngineSyncController;
+    private readonly _externalPrefetchPlanner;
+    private readonly _externalPrefetchService;
+    protected readonly _executionInProgressListener$: Subject<IExecutionInProgressParams>;
+    readonly executionInProgressListener$: import("rxjs").Observable<IExecutionInProgressParams>;
+    protected readonly _executionCompleteListener$: Subject<IAllRuntimeData>;
+    readonly executionCompleteListener$: import("rxjs").Observable<IAllRuntimeData>;
+    private _executeLock;
+    private _nativeLoaded;
+    private _syncedSnapshotEpoch;
+    private _syncedDependencyInvalidationEpoch;
+    private _externalFormulaDatasetConfig;
+    constructor(_configService: IConfigService, _currentConfigService: IFormulaCurrentConfigService, _runtimeService: IFormulaRuntimeService, _formulaDependencyGenerator: IFormulaDependencyGenerator, _featureCalculationManagerService: IFeatureCalculationManagerService, _otherFormulaManagerService: IOtherFormulaManagerService, _commandService: ICommandService, _rustEngineSyncController: RustEngineSyncController, _externalPrefetchPlanner: ExternalReferencePrefetchPlanner, _externalPrefetchService: ExternalReferencePrefetchService);
+    dispose(): void;
+    stopFormulaExecution(): void;
+    setRuntimeFeatureCellData(featureId: string, featureData: IRuntimeUnitDataType): void;
+    setRuntimeFeatureRange(featureId: string, featureRange: IFeatureDirtyRangeType): void;
+    execute(formulaDatasetConfig: IFormulaDatasetConfig): Promise<void>;
+    private _executeStep;
+    private _prefetchStaticExternalReferences;
+    private _resolveExternalReferenceNeeds;
+    private _groupExternalReferenceNeeds;
+    private _hostUnitIdFromSynthetic;
+    private _buildRustInput;
+    private _syncRustFormulaDependencies;
+    private _syncRustFormulaDependencyDefinitions;
+    private _collectRustFormulaDependencySyncState;
+    private _markRustFormulaDirty;
+    private _dirtyFeatureMapFor;
+    private _featureKey;
+    private _featureSignatureMap;
+    private _serializeFeatureDirtyRanges;
+    private _serializeRuntimeFeatureCellData;
+    private _serializeFormulaData;
+    private _serializeUnitData;
+    private _serializeCellData;
+    private _applyRustOutput;
+    private _applyRustDependencyOutput;
+    calculate(formulaString: string): Promise<{} | null>;
+    executeFormulas(formulas: IFormulaStringMap, rowData?: IUnitRowData): Promise<IFormulaExecuteResultMap>;
+    getAllDependencyJson(_rowData?: IUnitRowData): Promise<IFormulaDependencyTreeJson[]>;
+    getCellDependencyJson(unitId: string, sheetId: string, row: number, column: number, _rowData?: IUnitRowData): Promise<{
+        treeId: number;
+        formula: string;
+        row: number;
+        column: number;
+        unitId: string;
+        subUnitId: string;
+        refOffsetX: number;
+        refOffsetY: number;
+        rangeList: IUnitRange[];
+        refTreeId: number | undefined;
+        formulaId: Nullable<string>;
+        featureId: Nullable<string>;
+        type: Nullable<import("@univerjs/engine-formula").FormulaDependencyTreeType>;
+        children: IFormulaDependencyTreeJson[];
+        parents: IFormulaDependencyTreeJson[];
+    } | undefined>;
+    getRangeDependents(unitRanges: IUnitRange[]): Promise<IFormulaDependencyTreeJson[]>;
+    getInRangeFormulas(unitRanges: IUnitRange[]): Promise<IFormulaDependencyTreeJson[]>;
+    getDependentsAndInRangeFormulas(unitRanges: IUnitRange[]): Promise<{
+        dependents: IFormulaDependencyTreeJson[];
+        inRanges: IFormulaDependencyTreeJson[];
+    }>;
+    private _formulaStringMapToFormulaData;
+    private _formulaExecutionOutputToResultMap;
+    private _getRustDependencyGraph;
+    private _getRustInspectGraph;
+    private _rustAllDependencyJson;
+    private _rustGraphDependencyJson;
+    private _rustDependencyNodeToJson;
+    private _rustFormulaNodeToDependencyJson;
+    private _rustRangeToUnitRange;
+    private _serializeUnitRanges;
+    private _rustDependencyJsonByCell;
+    private _cellKey;
+    private _cellInUnitRanges;
+    private _uniqueDependencyJson;
+}

package/lib/types/services/rust-formula-projection.service.d.ts

@@ -0,0 +1,70 @@
+import type { IWorkbookData } from '@univerjs/core';
+import type { IFormulaDatasetConfig, ISetFormulaCalculationResultMutation } from '@univerjs/engine-formula';
+import type { IRustDefinedNameSnapshot, IRustDependencyRange, IRustEngineModelStats, IRustEngineMutation, IRustEngineSnapshot, IRustFormulaDependencyExecutionOutput, IRustFormulaDependencySyncInput, IRustFormulaStoreState, IRustWorkbookSnapshot } from '../types.js';
+export declare const RUST_UPSERT_REFERENCE_DATA_MUTATION_ID = "formula.mutation.upsert-reference-data";
+export declare const RUST_FORMULA_RELEVANT_MUTATIONS: Set<string>;
+export declare const RUST_INCREMENTAL_DEPENDENCY_MUTATIONS: Set<string>;
+export interface IRustProjectionWorkbookInput {
+    snapshot: IWorkbookData;
+    unitId?: string;
+    definedNames?: Record<string, IRustDefinedNameSnapshot>;
+}
+export interface IFormulaCalculationError {
+    code: string;
+    message: string;
+    unitId?: string;
+    sheetId?: string;
+    row?: number;
+    column?: number;
+}
+export interface IFormulaProjectionDesyncSignal {
+    reason: string;
+    message: string;
+    mutationId?: string;
+}
+export interface IFormulaCalculationPatch {
+    unitData: ISetFormulaCalculationResultMutation['unitData'];
+    unitOtherData: ISetFormulaCalculationResultMutation['unitOtherData'];
+    arrayFormulaRange?: IRustFormulaStoreState['arrayFormulaRange'];
+    arrayFormulaCellData?: IRustFormulaStoreState['arrayFormulaCellData'];
+    errors?: IFormulaCalculationError[];
+    desync?: IFormulaProjectionDesyncSignal;
+}
+export interface IRustFormulaProjectionLoadResult {
+    stats?: IRustEngineModelStats;
+    errors?: IFormulaCalculationError[];
+    desync?: IFormulaProjectionDesyncSignal;
+}
+export interface IRustFormulaProjectionMutationResult {
+    stats?: IRustEngineModelStats;
+    dependencyInvalidated: boolean;
+    errors?: IFormulaCalculationError[];
+    desync?: IFormulaProjectionDesyncSignal;
+}
+export declare function isRustFormulaRelevantMutation(id: string): boolean;
+export declare function isRustIncrementalDependencyMutation(id: string): boolean;
+export declare function createReferenceDataUpsertMutations(config: IFormulaDatasetConfig, needs: NonNullable<IRustFormulaDependencyExecutionOutput['needsData']>): IRustEngineMutation[];
+export declare function serializeRuntimeWorkbookSnapshots(workbooks: readonly IRustProjectionWorkbookInput[]): IRustEngineSnapshot;
+export declare function serializeRuntimeWorkbookSnapshot(input: IRustProjectionWorkbookInput): IRustWorkbookSnapshot;
+export declare function rustExecutionOutputToFormulaCalculationPatch(output: IRustFormulaDependencyExecutionOutput): IFormulaCalculationPatch;
+export declare function createFormulaProjectionDesyncSignal(reason: string, error: unknown, mutationId?: string): IFormulaProjectionDesyncSignal;
+export declare class RustFormulaProjectionService {
+    private _nativeLoaded;
+    load(workbooks: readonly IRustProjectionWorkbookInput[]): Promise<IRustFormulaProjectionLoadResult>;
+    applyMutation(mutation: IRustEngineMutation): Promise<IRustFormulaProjectionMutationResult>;
+    syncFormulaDependencies(input: IRustFormulaDependencySyncInput): Promise<unknown>;
+    markDirty(input: {
+        forceCalculation?: boolean;
+        includeDirtyNodes?: boolean;
+        includeCalculationOrder?: boolean;
+        dirtyRanges?: IRustDependencyRange[];
+        dirtyUnitFeatureMap?: Record<string, Record<string, Record<string, boolean>>>;
+        dirtyUnitOtherFormulaMap?: Record<string, Record<string, Record<string, boolean>>>;
+        dirtyNameMap?: Record<string, Record<string, string>>;
+        dirtyDefinedNameMap?: Record<string, Record<string, string>>;
+    }): Promise<unknown>;
+    calculateDirty(maxIteration?: number): Promise<IFormulaCalculationPatch>;
+    reset(): Promise<IRustFormulaProjectionLoadResult>;
+    disposeWorkbook(unitId: string): Promise<IRustFormulaProjectionLoadResult>;
+    private _ensureNativeLoaded;
+}

package/lib/types/services/workbook-snapshot-materializer.d.ts

@@ -0,0 +1,20 @@
+import type { IWorkbookData } from '@univerjs/core';
+import type { ISheetBlock, ISnapshot } from '@univerjs/protocol';
+import type { IRustFormulaDependencyDirtyInput } from '../types.js';
+export interface IMaterializedWorkbookSnapshot {
+    snapshot: ISnapshot;
+    sheetBlocks: Record<string, ISheetBlock[]>;
+    warnings: unknown[];
+    calculationStats: IMaterializationCalculationStats;
+}
+export interface IMaterializationCalculationStats {
+    fullCalculation: boolean;
+    formulaNodeCount: number;
+    calculatedNodeCount: number;
+    hasCycle: boolean;
+    cycleIterationCount: number;
+    parallelBatchCount: number;
+    parallelNodeCount: number;
+    errorCount: number;
+}
+export declare function materializeWorkbookSnapshot(workbook: IWorkbookData, unitID: string, rev: number, dirtyInput?: IRustFormulaDependencyDirtyInput): Promise<IMaterializedWorkbookSnapshot>;

package/lib/types/types.d.ts

@@ -0,0 +1,398 @@
+/**
+ * Serialized types exchanged between TS and Rust formula engine.
+ */
+export interface IFormulaEngineConfig {
+    maxIteration: number;
+    intervalCount: number;
+}
+export interface IFormulaExecutionInput {
+    config: IFormulaEngineConfig;
+    formulaData: Record<string, Record<string, Record<number, Record<number, string | IRustFormulaDataItem>>>>;
+    unitData: Record<string, Record<string, ISheetData>>;
+    dirtyRanges: IUnitRange[];
+    definedNames: Record<string, IDefinedName>;
+}
+export interface ISheetData {
+    cellData: Record<number, Record<number, ICellValue>>;
+    rowCount: number;
+    columnCount: number;
+}
+export interface ICellValue {
+    v?: unknown;
+    t?: number;
+    p?: unknown;
+    f?: string;
+    si?: string;
+    ref?: string;
+    xf?: string;
+    s?: unknown;
+    displayPrecision?: number;
+}
+export interface IUnitRange {
+    unitId: string;
+    sheetId: string;
+    range: IRange;
+}
+export interface IRange {
+    startRow: number;
+    startColumn: number;
+    endRow: number;
+    endColumn: number;
+}
+export interface IDefinedName {
+    name: string;
+    formula?: string;
+    range?: IRange;
+}
+export interface IFormulaExecutionOutput {
+    runtimeData: Record<string, Record<string, Record<number, Record<number, unknown>>>>;
+    arrayFormulaRange: Record<string, Record<string, Record<number, Record<number, IRange>>>>;
+    cycleDependencies: ICycleDependencyInfo[];
+    errors: IExecutionError[];
+}
+export interface ICycleDependencyInfo {
+    unitId: string;
+    sheetId: string;
+    row: number;
+    column: number;
+}
+export interface IExecutionError {
+    unitId: string;
+    sheetId: string;
+    row: number;
+    column: number;
+    message: string;
+}
+export interface IRustEngineSnapshot {
+    workbooks: IRustWorkbookSnapshot[];
+}
+export interface IRustWorkbookSnapshot {
+    unitId: string;
+    name?: string;
+    sheets: IRustSheetSnapshot[];
+    calculation?: IRustWorkbookCalculationSnapshot;
+    resources?: Record<string, IRustResourceSnapshot>;
+    definedNames?: Record<string, IRustDefinedNameSnapshot>;
+    externalLinks?: IRustExternalLinkSnapshot[];
+    tables?: Record<string, IRustTableSnapshot>;
+}
+export interface IRustResourceSnapshot {
+    name: string;
+    data: unknown;
+}
+export interface IRustWorkbookCalculationSnapshot {
+    fullPrecision?: boolean;
+}
+export interface IRustExternalLinkSnapshot {
+    aliases?: string[];
+    definedNames?: Record<string, IRustDefinedNameSnapshot>;
+    sheets: IRustExternalSheetSnapshot[];
+    tables?: Record<string, IRustTableSnapshot>;
+    target?: string;
+    unitId?: string;
+}
+export interface IRustExternalSheetSnapshot {
+    name: string;
+    sheetId?: string;
+    rowCount: number;
+    columnCount: number;
+    cellData: Record<number, Record<number, ICellValue>>;
+    coverage?: IRange[];
+}
+export interface IRustDefinedNameSnapshot {
+    id?: string;
+    name: string;
+    formulaOrRefString?: string;
+    localSheetId?: string;
+}
+export interface IRustTableSnapshot {
+    sheetId: string;
+    range: {
+        startRow: number;
+        endRow: number;
+        startColumn: number;
+        endColumn: number;
+    };
+    columns: Array<{
+        displayName: string;
+    }>;
+    showHeader?: boolean;
+    showFooter?: boolean;
+}
+export interface IRustSheetSnapshot {
+    sheetId: string;
+    name?: string;
+    rowCount: number;
+    columnCount: number;
+    transitionEvaluation?: boolean;
+    cellData: Record<number, Record<number, ICellValue>>;
+    rowData?: Record<number, IRustVisibilityData>;
+    columnData?: Record<number, IRustVisibilityData>;
+}
+export interface IRustVisibilityData {
+    hd?: unknown;
+}
+export interface IRustEngineMutation {
+    id: string;
+    params?: unknown;
+    dirtyRanges?: unknown[];
+}
+export interface IRustEngineModelStats {
+    workbookCount: number;
+    sheetCount: number;
+    cellCount: number;
+    formulaCount: number;
+    definedNameCount: number;
+    tableCount: number;
+    typedValueCount: number;
+    jsonValueCount: number;
+    valueTileCount: number;
+    valueTileValueCount: number;
+    estimatedMemoryBytes: number;
+    revision: number;
+    applied: boolean;
+}
+export interface IRustSheetState {
+    rowCount: number;
+    columnCount: number;
+    hiddenRows: number[];
+    hiddenCols: number[];
+    revision: number;
+}
+export interface IRustFormulaStoreState {
+    formulaData: Record<string, Record<string, Record<number, Record<number, IRustFormulaDataItem>>>>;
+    arrayFormulaRange: Record<string, Record<string, Record<number, Record<number, IRange>>>>;
+    arrayFormulaCellData: Record<string, Record<string, Record<number, Record<number, ICellValue>>>>;
+}
+export interface IRustFormulaDataItem {
+    f: string;
+    si?: string;
+    ref?: string;
+    x?: number;
+    y?: number;
+}
+export interface IRustDependencyCell {
+    unitId: string;
+    sheetId: string;
+    row: number;
+    column: number;
+}
+export interface IRustDependencyRange {
+    unitId: string;
+    sheetId: string;
+    startRow: number;
+    endRow: number;
+    startColumn: number;
+    endColumn: number;
+}
+export interface IRustDependencyNode {
+    id: number;
+    unitId: string;
+    sheetId: string;
+    row: number;
+    column: number;
+    formula: string;
+    formulaId?: string;
+    offsetX: number;
+    offsetY: number;
+    precedentRanges: IRustDependencyRange[];
+    parents: number[];
+    children: number[];
+    dependents: IRustDependencyCell[];
+}
+export interface IRustDependencyGraph {
+    stats: {
+        formulaCount: number;
+        precedentRangeCount: number;
+        formulaEdgeCount: number;
+        cycleCount: number;
+        errorCount: number;
+    };
+    nodes: IRustDependencyNode[];
+    edges: Array<{
+        from: IRustDependencyCell;
+        to: IRustDependencyCell;
+    }>;
+    calculationOrder: IRustDependencyCell[];
+    calculationForest: IRustDependencyCalculationTree[];
+    cycles: IRustDependencyCell[][];
+    errors: Array<{
+        unitId: string;
+        sheetId: string;
+        row: number;
+        column: number;
+        formula: string;
+        message: string;
+    }>;
+}
+export interface IRustDependencyCalculationTree {
+    hasCycle: boolean;
+    plan: IRustDependencyCalculationPlanItem[];
+    levels: IRustDependencyCell[][];
+}
+export type IRustDependencyCalculationPlanItem = {
+    type: 'nodes';
+    cells: IRustDependencyCell[];
+} | {
+    type: 'cycle';
+    cells: IRustDependencyCell[];
+};
+export interface IRustDependencyDirtyResult {
+    dirtyRanges: IRustDependencyRange[];
+    direct: IRustDependencyCell[];
+    affected: IRustDependencyCell[];
+    calculationForest: IRustDependencyCalculationTree[];
+    cycles: IRustDependencyCell[][];
+    errors: IRustDependencyGraph['errors'];
+}
+export interface IRustFormulaDependencySyncInput {
+    rebuildSheetFormulas?: boolean;
+    featureCalculations?: IRustExternalFeatureCalculation[];
+    otherFormulas?: IRustExternalOtherFormula[];
+}
+export interface IRustExternalFeatureCalculation {
+    unitId: string;
+    sheetId: string;
+    featureId: string;
+    dependencyRanges: IRustDependencyRange[];
+    dirtyRanges?: IRustDependencyRange[];
+    runtimeCellData?: Record<string, Record<string, Record<number, Record<number, ICellValue | null>>>>;
+}
+export interface IRustExternalOtherFormula {
+    unitId: string;
+    sheetId: string;
+    formulaId: string;
+    formula: string;
+    ranges: IRange[];
+}
+export interface IRustFormulaDependencyDirtyInput {
+    forceCalculation?: boolean;
+    includeDirtyNodes?: boolean;
+    includeCalculationOrder?: boolean;
+    dirtyFormulaCells?: IRustDependencyRange[];
+    dirtyRanges?: IRustDependencyRange[];
+    dirtyUnitFeatureMap?: Record<string, Record<string, Record<string, boolean>>>;
+    dirtyUnitOtherFormulaMap?: Record<string, Record<string, Record<string, boolean>>>;
+    dirtyNameMap?: Record<string, Record<string, string>>;
+    dirtyDefinedNameMap?: Record<string, Record<string, string>>;
+}
+export interface IRustFormulaDependencyClearInput {
+    unitId: string;
+    sheetId?: string;
+    clearSheetFormulas?: boolean;
+    clearFeatureFormulas?: boolean;
+    clearOtherFormulas?: boolean;
+    formulaCells?: Array<{
+        row: number;
+        col: number;
+    }>;
+    featureIds?: string[];
+    otherFormulaIds?: string[];
+}
+export interface IRustFormulaDependencySyncOutput {
+    sheetFormulaCount: number;
+    featureFormulaCount: number;
+    otherFormulaCount: number;
+    errorCount: number;
+    errors: IRustDependencyGraph['errors'];
+    timings?: {
+        dependencyInputMs: number;
+        featureSyncMs: number;
+        analyzeMs: number;
+        cacheInsertMs: number;
+        graphSetMs: number;
+        dynamicPrewarmMs: number;
+        dynamicApplyMs: number;
+        otherFormulaMs: number;
+        totalMs: number;
+    };
+}
+export interface IRustFormulaDependencyNodeOutput {
+    nodeType: 'cellFormula' | 'featureCalculation' | 'otherFormula';
+    label: string;
+    unitId?: string;
+    sheetId?: string;
+    row?: number;
+    column?: number;
+    formulaId?: string;
+    featureId?: string;
+    refOffsetX?: number;
+    refOffsetY?: number;
+}
+export interface IRustFormulaDependencyInspectGraph {
+    nodes: IRustFormulaDependencyInspectNode[];
+}
+export interface IRustFormulaDependencyInspectNode {
+    index: number;
+    node: IRustFormulaDependencyNodeOutput;
+    label: string;
+    precedents: string[];
+    dependents: string[];
+}
+export interface IRustFormulaDependencyDirtyOutput {
+    dirtyNodes: IRustFormulaDependencyNodeOutput[];
+    calculationOrder: {
+        hasCycle: boolean;
+        calculationForest: Array<{
+            hasCycle: boolean;
+            plan: Array<{
+                type: string;
+                nodeIndex?: number;
+                nodeIndices?: number[];
+            }>;
+            levels: number[][];
+        }>;
+    };
+}
+export interface IRustFormulaDependencyExecutionOutput {
+    runtimeData: Record<string, Record<string, Record<number, Record<number, unknown>>>>;
+    otherFormulaData?: Record<string, Record<string, Record<string, Record<number, Record<number, unknown>>>>>;
+    resultBatches: Array<{
+        unitId: string;
+        sheetId: string;
+        rows: number[];
+        cols: number[];
+        values: unknown[];
+    }>;
+    calculatedNodes: IRustFormulaDependencyNodeOutput[];
+    calculatedNodeCount: number;
+    errors: Array<{
+        unitId: string;
+        sheetId: string;
+        row: number;
+        column: number;
+        message: string;
+    }>;
+    needsData?: Array<{
+        unitId: string;
+        sheetId: string;
+        range: IRange;
+    }>;
+    hasCycle: boolean;
+    cycleIterationCount: number;
+    parallelBatchCount: number;
+    parallelNodeCount: number;
+    functionProfile?: Array<{
+        name: string;
+        callCount: number;
+        totalMs: number;
+        avgUs: number;
+    }>;
+    timings: {
+        initialDynamicRefreshMs: number;
+        initialDynamicRefreshRequestCount: number;
+        buildValueDataMs: number;
+        planningMs: number;
+        taskBuildMs: number;
+        evaluateMs: number;
+        applyMs: number;
+        applyResultMaterializeMs: number;
+        applyValueDataMs: number;
+        applyWorkbookMs: number;
+        applyRuntimeDynamicPatchMs: number;
+        clearDirtyMs: number;
+        runtimeDynamicRefreshMs: number;
+        runtimeDynamicRefreshRequestCount: number;
+        finalOutputMs: number;
+    };
+}