@univerjs-pro/engine-formula-rust 1.0.0-rc.0 → 1.0.1

package/lib/es/index.js

@@ -80,11 +80,6 @@ function loadSnapshotOnRust(snapshotJson) {
     throw new Error("Native binding not loaded. Call loadNativeBinding() first.");
   return nativeBinding.rustEngineLoadSnapshot(snapshotJson);
 }
-function loadSnapshotBinaryOnRust(snapshotBytes) {
-  if (!nativeBinding)
-    throw new Error("Native binding not loaded. Call loadNativeBinding() first.");
-  return nativeBinding.rustEngineLoadSnapshotBinary(snapshotBytes);
-}
 function applyMutationOnRust(mutationJson) {
   if (!nativeBinding)
     throw new Error("Native binding not loaded. Call loadNativeBinding() first.");
@@ -135,11 +130,6 @@ function syncRustFormulaDependenciesOnRust(inputJson) {
     throw new Error("Native binding not loaded. Call loadNativeBinding() first.");
   return nativeBinding.rustEngineSyncFormulaDependencies(inputJson);
 }
-function inspectRustFormulaDependencyGraphOnRust() {
-  if (!nativeBinding)
-    throw new Error("Native binding not loaded. Call loadNativeBinding() first.");
-  return nativeBinding.rustEngineInspectFormulaDependencyGraph();
-}
 function markRustFormulaDirtyOnRust(inputJson) {
   if (!nativeBinding)
     throw new Error("Native binding not loaded. Call loadNativeBinding() first.");
@@ -155,28 +145,43 @@ function clearRustFormulaDirtyOnRust() {
     throw new Error("Native binding not loaded. Call loadNativeBinding() first.");
   return nativeBinding.rustEngineClearFormulaDirty();
 }
-function executeDirtyFormulasOnRust(maxIteration, includeCalculatedNodes, includeRuntimeData, includeResultBatches) {
-  if (!nativeBinding)
-    throw new Error("Native binding not loaded. Call loadNativeBinding() first.");
-  return nativeBinding.rustEngineExecuteDirtyFormulas(
-    maxIteration,
-    includeCalculatedNodes,
-    includeRuntimeData,
-    includeResultBatches
-  );
-}
 function materializeWorkbookSnapshotOnRust(workbookJson, unitId, rev, dirtyInputJson) {
   if (!nativeBinding)
     throw new Error("Native binding not loaded. Call loadNativeBinding() first.");
   return nativeBinding.rustMaterializeWorkbookSnapshot(workbookJson, unitId, rev, dirtyInputJson);
 }
+var RustFormulaEngineSession = class {
+  _engine = null;
+  _disposed = !1;
+  async initialize() {
+    if (this._disposed) throw new Error("Rust formula engine session is disposed");
+    if (this._engine) return;
+    let binding = await loadNativeBinding();
+    if (this._disposed) throw new Error("Rust formula engine session is disposed");
+    if (!this._engine) {
+      if (typeof binding.RustFormulaEngine != "function")
+        throw new Error("Native formula binding lacks instance isolation; upgrade engine-formula-rust-binding");
+      this._engine = new binding.RustFormulaEngine();
+    }
+  }
+  get binding() {
+    if (this._disposed) throw new Error("Rust formula engine session is disposed");
+    if (!this._engine) throw new Error("Rust formula engine session is not initialized");
+    return this._engine;
+  }
+  dispose() {
+    this._disposed || (this._disposed = !0, this._engine?.dispose(), this._engine = null);
+  }
+};
 
 // src/controllers/rust-engine-sync.controller.ts
 import { CommandType, Disposable, ICommandService, setDependencies } from "@univerjs/core";
 
 // src/services/rust-formula-projection.service.ts
 import {
+  BooleanNumber,
   CellValueType,
+  FormulaType,
   ObjectMatrix
 } from "@univerjs/core";
 var XLSX_WORKBOOK_CALCULATION_RESOURCE = "UNIVER_CLI_XLSX_WORKBOOK_CALCULATION_PLUGIN", EXTERNAL_DATA_RESOURCE = "SHEET_EXTERNAL_DATA_PLUGIN", EXTERNAL_DATA_SIGNATURE = "external_data", RUST_UPSERT_REFERENCE_DATA_MUTATION_ID = "formula.mutation.upsert-reference-data", RUST_UPSERT_PROJECTION_WORKBOOK_MUTATION_ID = "formula.mutation.upsert-projection-workbook", RUST_SET_SUPER_TABLES_MUTATION_ID = "formula.mutation.set-super-tables", RUST_FORMULA_RELEVANT_MUTATIONS = /* @__PURE__ */ new Set([
@@ -195,6 +200,11 @@ var XLSX_WORKBOOK_CALCULATION_RESOURCE = "UNIVER_CLI_XLSX_WORKBOOK_CALCULATION_P
   "sheet.mutation.set-col-visible",
   "sheet.mutation.set-row-hidden",
   "sheet.mutation.set-row-visible",
+  "sheet.mutation.set-table-filter",
+  "sheet.mutation.set-filter-range",
+  "sheet.mutation.set-filter-criteria",
+  "sheet.mutation.remove-filter",
+  "sheet.mutation.re-calc-filter",
   "sheet.mutation.set-worksheet-name",
   "sheet.mutation.reorder-range",
   "sheet.mutation.set-worksheet-row-count",
@@ -268,11 +278,18 @@ function serializeRuntimeWorkbookSnapshots(workbooks) {
 }
 function serializeRuntimeWorkbookSnapshot(input) {
   let { snapshot } = input, sheetOrder = snapshot.sheetOrder?.length > 0 ? snapshot.sheetOrder : Object.keys(snapshot.sheets ?? {}), calculation = serializeCalculation(snapshot), precisionAsDisplayed = calculation?.fullPrecision === !1, sheets = sheetOrder.map(
-    (sheetId) => serializeSheetSnapshot(sheetId, snapshot.sheets?.[sheetId], snapshot.styles, precisionAsDisplayed)
+    (sheetId) => serializeSheetSnapshot(
+      sheetId,
+      snapshot.sheets?.[sheetId],
+      snapshot.styles,
+      precisionAsDisplayed,
+      input.styleResolver
+    )
   ).filter((sheet) => sheet != null);
   return {
     unitId: input.unitId || snapshot.id,
     name: snapshot.name,
+    dateSystem: snapshot.dateSystem,
     sheets,
     ...calculation ? { calculation } : {},
     resources: serializeResources(snapshot),
@@ -340,13 +357,16 @@ function otherFormulaDataToUnitOtherData(otherFormulaData) {
           if (!colMap) return;
           let row = Number(rowKey), rowData = {};
           formulaData[row] = rowData, Object.entries(colMap).forEach(([colKey, value]) => {
-            rowData[Number(colKey)] = [[cellDataFromRustValue(value)]];
+            rowData[Number(colKey)] = otherFormulaResultFromRustValue(value);
           });
         });
       });
     });
   }), unitOtherData;
 }
+function otherFormulaResultFromRustValue(value) {
+  return Array.isArray(value) ? value.map((row) => (Array.isArray(row) ? row : [row]).map((cell) => cellDataFromRustValue(cell))) : [[cellDataFromRustValue(value)]];
+}
 function createFormulaProjectionDesyncSignal(reason, error, mutationId) {
   return {
     reason,
@@ -355,12 +375,20 @@ function createFormulaProjectionDesyncSignal(reason, error, mutationId) {
   };
 }
 var RustFormulaProjectionService = class {
+  engine = new RustFormulaEngineSession();
+  dispose() {
+    this.engine.dispose();
+  }
   _nativeLoaded = !1;
   async load(workbooks) {
     await this._ensureNativeLoaded();
     try {
       return {
-        stats: JSON.parse(loadSnapshotOnRust(JSON.stringify(serializeRuntimeWorkbookSnapshots(workbooks))))
+        stats: JSON.parse(
+          this.engine.binding.rustEngineLoadSnapshot(
+            JSON.stringify(serializeRuntimeWorkbookSnapshots(workbooks))
+          )
+        )
       };
     } catch (error) {
       return {
@@ -373,7 +401,9 @@ var RustFormulaProjectionService = class {
     await this._ensureNativeLoaded();
     try {
       return {
-        stats: JSON.parse(applyMutationOnRust(JSON.stringify(normalizeRustEngineMutation(mutation)))),
+        stats: JSON.parse(
+          this.engine.binding.rustEngineApplyMutation(JSON.stringify(normalizeRustEngineMutation(mutation)))
+        ),
         dependencyInvalidated: !isRustIncrementalDependencyMutation(mutation.id)
       };
     } catch (error) {
@@ -385,16 +415,16 @@ var RustFormulaProjectionService = class {
     }
   }
   async syncFormulaDependencies(input) {
-    return await this._ensureNativeLoaded(), JSON.parse(syncRustFormulaDependenciesOnRust(JSON.stringify(input)));
+    return await this._ensureNativeLoaded(), JSON.parse(this.engine.binding.rustEngineSyncFormulaDependencies(JSON.stringify(input)));
   }
   async markDirty(input) {
-    return await this._ensureNativeLoaded(), JSON.parse(markRustFormulaDirtyOnRust(JSON.stringify(input)));
+    return await this._ensureNativeLoaded(), JSON.parse(this.engine.binding.rustEngineMarkFormulaDirty(JSON.stringify(input)));
   }
   async calculateDirty(maxIteration = 1) {
     await this._ensureNativeLoaded();
     try {
       let output = JSON.parse(
-        executeDirtyFormulasOnRust(maxIteration, !1, !1, !0)
+        this.engine.binding.rustEngineExecuteDirtyFormulas(maxIteration, !1, !1, !0)
       );
       return rustExecutionOutputToFormulaCalculationPatch(output);
     } catch (error) {
@@ -409,7 +439,7 @@ var RustFormulaProjectionService = class {
   async reset() {
     await this._ensureNativeLoaded();
     try {
-      return clearRustFormulaDirtyOnRust(), clearRustFormulaDependenciesOnRust(
+      return this.engine.binding.rustEngineClearFormulaDirty(), this.engine.binding.rustEngineClearFormulaDependencies(
         JSON.stringify({
           unitId: "",
           clearSheetFormulas: !0,
@@ -417,7 +447,11 @@ var RustFormulaProjectionService = class {
           clearOtherFormulas: !0
         })
       ), {
-        stats: JSON.parse(loadSnapshotOnRust(JSON.stringify({ workbooks: [] })))
+        stats: JSON.parse(
+          this.engine.binding.rustEngineLoadSnapshot(
+            JSON.stringify({ workbooks: [] })
+          )
+        )
       };
     } catch (error) {
       return {
@@ -429,7 +463,7 @@ var RustFormulaProjectionService = class {
   async disposeWorkbook(unitId) {
     await this._ensureNativeLoaded();
     try {
-      return { stats: JSON.parse(disposeWorkbookOnRust(unitId)) };
+      return { stats: JSON.parse(this.engine.binding.rustEngineDisposeWorkbook(unitId)) };
     } catch (error) {
       return {
         desync: createFormulaProjectionDesyncSignal("workbook-dispose-failed", error),
@@ -438,7 +472,7 @@ var RustFormulaProjectionService = class {
     }
   }
   async _ensureNativeLoaded() {
-    this._nativeLoaded || (await loadNativeBinding(), this._nativeLoaded = !0);
+    this._nativeLoaded || (await this.engine.initialize(), this._nativeLoaded = !0);
   }
 };
 function normalizeRustEngineMutation(mutation) {
@@ -880,19 +914,19 @@ function extractDefinedNames(snapshot) {
   }
   return {};
 }
-function serializeSheetSnapshot(sheetId, sheet, styles, precisionAsDisplayed) {
+function serializeSheetSnapshot(sheetId, sheet, styles, precisionAsDisplayed, styleResolver) {
   return sheet ? {
     sheetId: sheet.id ?? sheetId,
     name: sheet.name,
     rowCount: sheet.rowCount ?? 0,
     columnCount: sheet.columnCount ?? 0,
     transitionEvaluation: sheet.transitionEvaluation === !0,
-    cellData: serializeCellData(sheet.cellData, styles, precisionAsDisplayed),
+    cellData: serializeCellData(sheet.cellData, styles, precisionAsDisplayed, styleResolver),
     rowData: serializeVisibilityData(sheet.rowData),
     columnData: serializeVisibilityData(sheet.columnData)
   } : null;
 }
-function serializeCellData(cellData = {}, styles, precisionAsDisplayed = !1) {
+function serializeCellData(cellData = {}, styles, precisionAsDisplayed = !1, styleResolver) {
   let result = {}, rawCellData = cellData instanceof ObjectMatrix ? cellData.getMatrix() : cellData;
   for (let [rowKey, row] of Object.entries(rawCellData ?? {})) {
     if (!row)
@@ -901,13 +935,15 @@ function serializeCellData(cellData = {}, styles, precisionAsDisplayed = !1) {
     for (let [colKey, cell] of Object.entries(row)) {
       if (!cell || typeof cell != "object")
         continue;
-      let cellRecord = cell, value = {};
-      if ("v" in cellRecord && (value.v = cellRecord.v), typeof cellRecord.t == "number" && (value.t = cellRecord.t), "p" in cellRecord && (value.p = cellRecord.p), typeof cellRecord.f == "string" && (value.f = cellRecord.f), typeof cellRecord.si == "string" && (value.si = cellRecord.si), typeof cellRecord.ref == "string") {
+      let cellRecord = cell, resolvedStyle = styleResolver?.getStyleByCell(cell), value = {};
+      if ("v" in cellRecord && (value.v = cellRecord.v), typeof cellRecord.t == "number" && (value.t = cellRecord.t), "p" in cellRecord && (value.p = cellRecord.p), typeof cellRecord.f == "string" && (value.f = cellRecord.f), typeof cellRecord.ft == "number" && (value.ft = cellRecord.ft), (cellRecord.fd === BooleanNumber.FALSE || cellRecord.fd === BooleanNumber.TRUE) && (value.fd = cellRecord.fd), typeof cellRecord.si == "string" && (value.si = cellRecord.si), typeof cellRecord.ref == "string") {
         let hasFormula = typeof cellRecord.f == "string" && cellRecord.f.length > 0;
         typeof cellRecord.si == "string" || hasFormula && isLegacyArrayFormulaCell(cellRecord) ? value.ref = cellRecord.ref : hasFormula && (value.dynamicArrayRef = cellRecord.ref);
       }
-      if (typeof cellRecord.xf == "string" && (value.xf = cellRecord.xf), "s" in cellRecord && (value.s = cellRecord.s), precisionAsDisplayed && typeof cellRecord.f == "string") {
-        let displayPrecision = inferDisplayPrecision(cellRecord.s, styles);
+      typeof cellRecord.xf == "string" && (value.xf = cellRecord.xf), "s" in cellRecord && (value.s = cellRecord.s);
+      let numberFormat = resolveNumberFormatPattern(cellRecord.s, styles, resolvedStyle);
+      if (numberFormat !== void 0 && (value.numberFormat = numberFormat), precisionAsDisplayed && typeof cellRecord.f == "string") {
+        let displayPrecision = inferDisplayPrecision(cellRecord.s, styles, resolvedStyle);
         displayPrecision !== void 0 && (value.displayPrecision = displayPrecision);
       }
       Object.keys(value).length > 0 && (serializedRow[Number(colKey)] = value);
@@ -930,23 +966,19 @@ function serializeCellDataInRanges(cellData, ranges) {
   return result;
 }
 function isLegacyArrayFormulaCell(cell) {
-  let custom = cell.custom;
-  if (!custom || typeof custom != "object")
-    return !1;
-  let xlsx = custom._xlsx;
-  return xlsx != null && typeof xlsx == "object" && xlsx.legacyArrayFormula === !0;
+  return cell.ft === FormulaType.ARRAY && cell.fd !== BooleanNumber.TRUE;
 }
-function inferDisplayPrecision(styleId, styles) {
-  if (typeof styleId != "string" || !styles || typeof styles != "object")
-    return;
-  let style = styles[styleId];
-  if (!style || typeof style != "object")
-    return;
+function inferDisplayPrecision(styleId, styles, resolvedStyle) {
+  let pattern = resolveNumberFormatPattern(styleId, styles, resolvedStyle);
+  return pattern === void 0 ? void 0 : inferFixedNumberFormatPrecision(pattern);
+}
+function resolveNumberFormatPattern(styleRef, styles, resolvedStyle) {
+  let style = resolvedStyle ?? (typeof styleRef == "string" && styles && typeof styles == "object" ? styles[styleRef] : styleRef);
+  if (!style || typeof style != "object") return;
   let numberFormat = style.n;
-  if (!numberFormat || typeof numberFormat != "object")
-    return;
+  if (!numberFormat || typeof numberFormat != "object") return;
   let pattern = numberFormat.pattern;
-  return typeof pattern == "string" ? inferFixedNumberFormatPrecision(pattern) : void 0;
+  return typeof pattern == "string" ? pattern : void 0;
 }
 function inferFixedNumberFormatPrecision(pattern) {
   let cleaned = (pattern.split(";")[0] ?? pattern).replace(/"[^"]*"/gu, "").replace(/\\./gu, "").replace(/_.|\*./gu, "");
@@ -974,19 +1006,6 @@ function isRecord(value) {
 }
 
 // src/controllers/rust-engine-sync.controller.ts
-var rustEngineSyncState = {
-  snapshotEpoch: 0,
-  dependencyInvalidationEpoch: 0
-};
-function getRustEngineSyncState() {
-  return { ...rustEngineSyncState };
-}
-function markRustSnapshotLoaded() {
-  rustEngineSyncState.snapshotEpoch += 1, rustEngineSyncState.dependencyInvalidationEpoch += 1;
-}
-function markRustFormulaDependenciesInvalidated() {
-  rustEngineSyncState.dependencyInvalidationEpoch += 1;
-}
 function emitRustEngineSyncDebugEvent(event) {
   let hook = globalThis.__UNIVER_RUST_FORMULA_DEBUG_HOOK__;
   typeof hook == "function" && hook(event);
@@ -1026,6 +1045,17 @@ var RustEngineSyncController = class extends Disposable {
     this._initialize();
   }
   _commandService;
+  engine = new RustFormulaEngineSession();
+  _syncState = { snapshotEpoch: 0, dependencyInvalidationEpoch: 0 };
+  getSyncState() {
+    return { ...this._syncState };
+  }
+  _markSnapshotLoaded() {
+    this._syncState.snapshotEpoch += 1, this._syncState.dependencyInvalidationEpoch += 1;
+  }
+  _markDependenciesInvalidated() {
+    this._syncState.dependencyInvalidationEpoch += 1;
+  }
   _nativeReady = !1;
   _snapshotLoaded = !1;
   _projectionLoadPromise = null;
@@ -1059,7 +1089,7 @@ var RustEngineSyncController = class extends Disposable {
     this._projectionDeltaBarrier = barrier;
   }
   async _loadProjection(workbooks) {
-    await loadNativeBinding(), this._nativeReady = !0;
+    await this.engine.initialize(), this._nativeReady = !0;
     let serializeStartedAt = performance.now(), snapshot = serializeRuntimeWorkbookSnapshots(workbooks);
     this._loadSerializedSnapshot(snapshot, performance.now() - serializeStartedAt);
   }
@@ -1082,20 +1112,17 @@ var RustEngineSyncController = class extends Disposable {
   disposeProjectionWorkbook(unitId) {
     if (!(!this._nativeReady || !this._snapshotLoaded))
       try {
-        disposeWorkbookOnRust(unitId), markRustFormulaDependenciesInvalidated();
+        this.engine.binding.rustEngineDisposeWorkbook(unitId), this._markDependenciesInvalidated();
       } catch {
-        this._markProjectionDesynced();
+        this.markProjectionDesynced();
       }
   }
   dispose() {
-    if (super.dispose(), this._pendingMutations.length = 0, this._projectionManagedTableUnits.clear(), this._projectionLoadPromise = null, this._projectionDeltaBarrier = Promise.resolve(), !this._nativeReady) {
-      this._snapshotLoaded = !1;
-      return;
-    }
+    super.dispose(), this._pendingMutations.length = 0, this._projectionManagedTableUnits.clear(), this._projectionLoadPromise = null, this._projectionDeltaBarrier = Promise.resolve();
     try {
-      disposeAllWorkbooksOnRust();
+      this.engine.dispose();
     } catch {
-      this._markProjectionDesynced();
+      this.markProjectionDesynced();
       return;
     }
     this._nativeReady = !1, this._snapshotLoaded = !1;
@@ -1103,7 +1130,7 @@ var RustEngineSyncController = class extends Disposable {
   _loadSerializedSnapshot(snapshot, serializeMs) {
     let precisionAsDisplayedWorkbookCount = snapshot.workbooks.filter(
       (workbook) => workbook.calculation?.fullPrecision === !1
-    ).length, displayPrecisionCellCount = countDisplayPrecisionCells(snapshot), pendingCountCoveredBySnapshot = this._pendingMutations.length, stringifyStartedAt = performance.now(), snapshotJson = JSON.stringify(snapshot), stringifyMs = performance.now() - stringifyStartedAt, snapshotBuffer = globalThis.Buffer?.from(snapshotJson), nativeStartedAt = performance.now(), nativeOutput = snapshotBuffer ? loadSnapshotBinaryOnRust(snapshotBuffer) : loadSnapshotOnRust(snapshotJson), nativeMs = performance.now() - nativeStartedAt, nativeTimings;
+    ).length, displayPrecisionCellCount = countDisplayPrecisionCells(snapshot), pendingCountCoveredBySnapshot = this._pendingMutations.length, stringifyStartedAt = performance.now(), snapshotJson = JSON.stringify(snapshot), stringifyMs = performance.now() - stringifyStartedAt, snapshotBuffer = globalThis.Buffer?.from(snapshotJson), nativeStartedAt = performance.now(), nativeOutput = snapshotBuffer ? this.engine.binding.rustEngineLoadSnapshotBinary(snapshotBuffer) : this.engine.binding.rustEngineLoadSnapshot(snapshotJson), nativeMs = performance.now() - nativeStartedAt, nativeTimings;
     try {
       nativeTimings = JSON.parse(nativeOutput).timingsMs;
     } catch {
@@ -1122,7 +1149,7 @@ var RustEngineSyncController = class extends Disposable {
         transport: snapshotBuffer ? "binary-json" : "string-json",
         nativeTimings
       }
-    }), this._pendingMutations.splice(0, pendingCountCoveredBySnapshot), this._snapshotLoaded = !0, markRustSnapshotLoaded(), this._flushPendingMutations();
+    }), this._pendingMutations.splice(0, pendingCountCoveredBySnapshot), this._snapshotLoaded = !0, this._markSnapshotLoaded(), this._flushPendingMutations();
   }
   _queueOrSyncMutation(mutation) {
     if (!this._nativeReady || !this._snapshotLoaded) {
@@ -1140,9 +1167,9 @@ var RustEngineSyncController = class extends Disposable {
   _syncMutation(mutation) {
     let totalStartedAt = performance.now(), stringifyStartedAt = performance.now(), payload = JSON.stringify(normalizeRustEngineMutation(mutation)), stringifyMs = performance.now() - stringifyStartedAt, nativeStartedAt = performance.now();
     try {
-      applyMutationOnRust(payload), isRustIncrementalDependencyMutation(mutation.id) || markRustFormulaDependenciesInvalidated();
+      this.engine.binding.rustEngineApplyMutation(payload), isRustIncrementalDependencyMutation(mutation.id) || this._markDependenciesInvalidated();
     } catch {
-      this._markProjectionDesynced();
+      this.markProjectionDesynced();
     } finally {
       emitRustEngineSyncDebugEvent({
         type: "applyMutation",
@@ -1158,7 +1185,11 @@ var RustEngineSyncController = class extends Disposable {
       });
     }
   }
-  _markProjectionDesynced() {
+  /**
+   * Marks the native projection as out of sync so the next mutation reloads it.
+   * Also used by the projection controller when a background projection load fails.
+   */
+  markProjectionDesynced() {
     this._nativeReady = !1, this._snapshotLoaded = !1;
   }
   _shouldSyncMutation(command, options) {
@@ -1224,7 +1255,7 @@ import { ICalculateFormulaService } from "@univerjs/engine-formula";
 import { UniverProFormulaEnginePlugin } from "@univerjs-pro/engine-formula";
 
 // package.json
-var name = "@univerjs-pro/engine-formula-rust", version = "1.0.0-rc.0";
+var name = "@univerjs-pro/engine-formula-rust", version = "1.0.1";
 
 // src/controllers/rust-same-runtime-projection.controller.ts
 import {
@@ -1272,13 +1303,16 @@ var RustSameRuntimeProjectionController = class extends Disposable2 {
       UniverInstanceType.UNIVER_BASE
     ))
       this._rustEngineSyncController.setProjectionManagedTableUnit(base.getUnitId()), this._rememberBaseProjectionStructure(base.getSnapshot());
-    this._initialProjectionLoad = this._loadAllWorkbookProjections(), this.disposeWithMe(
+    this._initialProjectionLoad = this._loadAllWorkbookProjections().catch(() => {
+      this._rustEngineSyncController.markProjectionDesynced();
+    }), this.disposeWithMe(
       toDisposable(
         this._univerInstanceService.getTypeOfUnitAdded$(UniverInstanceType.UNIVER_SHEET).subscribe(({ unit }) => {
           this._enqueueProjectionDelta(() => {
             this._rustEngineSyncController.upsertProjectionWorkbook({
               unitId: unit.getUnitId(),
-              snapshot: unit.getSnapshot()
+              snapshot: unit.getSnapshot(),
+              styleResolver: unit.getStyles()
             });
           });
         })
@@ -1492,7 +1526,8 @@ var RustSameRuntimeProjectionController = class extends Disposable2 {
   async _loadAllWorkbookProjections() {
     let workbooks = this._univerInstanceService.getAllUnitsForType(UniverInstanceType.UNIVER_SHEET).map((workbook) => ({
       unitId: workbook.getUnitId(),
-      snapshot: workbook.getSnapshot()
+      snapshot: workbook.getSnapshot(),
+      styleResolver: workbook.getStyles()
     })), calculationData = this._formulaDataModel.getCalculateData(), formulaData = this._formulaDataModel.getFormulaData(), baseWorkbooks = this._univerInstanceService.getAllUnitsForType(UniverInstanceType.UNIVER_BASE).map(
       (base) => this._createBaseWorkbookProjection(
         base.getUnitId(),
@@ -1778,6 +1813,7 @@ import {
   FormulaExecuteStageType,
   IFeatureCalculationManagerService,
   IFormulaCurrentConfigService,
+  IDefinedNamesService,
   IFormulaDependencyGenerator,
   IFormulaRuntimeService,
   IOtherFormulaManagerService,
@@ -1834,7 +1870,7 @@ function resultBatchSheetCounts(output) {
   return counts;
 }
 var RustCalculateFormulaService = class extends Disposable3 {
-  constructor(_configService, _currentConfigService, _runtimeService, _formulaDependencyGenerator, _featureCalculationManagerService, _otherFormulaManagerService, _commandService, _rustEngineSyncController, _formulaDataModel, _formulaReferenceDataService, _excelExternalReferenceModel, _superTableService) {
+  constructor(_configService, _currentConfigService, _runtimeService, _formulaDependencyGenerator, _featureCalculationManagerService, _otherFormulaManagerService, _commandService, _rustEngineSyncController, _formulaDataModel, _formulaReferenceDataService, _excelExternalReferenceModel, _superTableService, _definedNamesService) {
     super();
     this._configService = _configService;
     this._currentConfigService = _currentConfigService;
@@ -1848,6 +1884,7 @@ var RustCalculateFormulaService = class extends Disposable3 {
     this._formulaReferenceDataService = _formulaReferenceDataService;
     this._excelExternalReferenceModel = _excelExternalReferenceModel;
     this._superTableService = _superTableService;
+    this._definedNamesService = _definedNamesService;
     this._commandService.hasCommand(SetFormulaCalculationResultMutation2.id) || this.disposeWithMe(this._commandService.registerCommand(SetFormulaCalculationResultMutation2)), this._commandService.hasCommand(SetArrayFormulaDataMutation.id) || this.disposeWithMe(this._commandService.registerCommand(SetArrayFormulaDataMutation));
   }
   _configService;
@@ -1862,6 +1899,7 @@ var RustCalculateFormulaService = class extends Disposable3 {
   _formulaReferenceDataService;
   _excelExternalReferenceModel;
   _superTableService;
+  _definedNamesService;
   _executionInProgressListener$ = new Subject();
   executionInProgressListener$ = this._executionInProgressListener$.asObservable();
   _executionCompleteListener$ = new Subject();
@@ -1889,14 +1927,19 @@ var RustCalculateFormulaService = class extends Disposable3 {
     this._runtimeService.setRuntimeFeatureRange(featureId, featureRange);
   }
   async execute(formulaDatasetConfig) {
-    this._nativeLoaded || (await loadNativeBinding(), this._nativeLoaded = !0), await this._rustEngineSyncController.waitForProjectionLoad(), this._externalFormulaDatasetConfig = formulaDatasetConfig, this._currentConfigService.load(formulaDatasetConfig), this._externalRequestGeneration++, this._externalInflight.clear(), this._externalCompleted.clear(), this._runtimeService.setFormulaExecuteStage(FormulaExecuteStageType.START), this._executionInProgressListener$.next(this._runtimeService.getRuntimeState()), this._runtimeService.reset();
+    this._nativeLoaded || (await this._rustEngineSyncController.engine.initialize(), this._nativeLoaded = !0), await this._rustEngineSyncController.waitForProjectionLoad(), this._externalFormulaDatasetConfig = formulaDatasetConfig, this._currentConfigService.load(formulaDatasetConfig), this._externalRequestGeneration++, this._externalInflight.clear(), this._externalCompleted.clear(), this._runtimeService.setFormulaExecuteStage(FormulaExecuteStageType.START), this._executionInProgressListener$.next(this._runtimeService.getRuntimeState()), this._runtimeService.reset();
     let cycleReferenceCount = Math.max(formulaDatasetConfig.maxIteration || 1, 1);
     await this._executeLock.acquire("FORMULA_EXECUTION_LOCK", async () => {
       this._runtimeService.setFormulaCycleIndex(0), await this._executeStep(cycleReferenceCount) > 0 ? this._runtimeService.markedAsSuccessfullyExecuted() : this._runtimeService.markedAsNoFunctionsExecuted(), this._runtimeService.setFormulaExecuteStage(FormulaExecuteStageType.CALCULATION_COMPLETED), this._executionInProgressListener$.next(this._runtimeService.getRuntimeState()), this._executionCompleteListener$.next(this._runtimeService.getAllRuntimeData()), this._runtimeService.reset();
     });
   }
   async _executeStep(maxIteration) {
-    let syncedFeatures = this._syncRustFormulaDependencies(void 0, !0), previousFeatureSignatures = this._featureSignatureMap(syncedFeatures), executeStartedAt = performance.now(), outputJson = executeDirtyFormulasOnRust(maxIteration, !1, !1, !0), nativeAndSerializeMs = performance.now() - executeStartedAt, parseStartedAt = performance.now(), output = JSON.parse(outputJson), calculatedNodeCount = output.calculatedNodeCount, parseMs = performance.now() - parseStartedAt;
+    let syncedFeatures = this._syncRustFormulaDependencies(void 0, !0), previousFeatureSignatures = this._featureSignatureMap(syncedFeatures), executeStartedAt = performance.now(), outputJson = this._rustEngineSyncController.engine.binding.rustEngineExecuteDirtyFormulas(
+      maxIteration,
+      !1,
+      !1,
+      !0
+    ), nativeAndSerializeMs = performance.now() - executeStartedAt, parseStartedAt = performance.now(), output = JSON.parse(outputJson), calculatedNodeCount = output.calculatedNodeCount, parseMs = performance.now() - parseStartedAt;
     output = await this._resolveExternalReferenceNeeds(output, maxIteration);
     let applyStartedAt = performance.now(), applyBreakdown = await this._applyRustDependencyOutput(output), applyMs = performance.now() - applyStartedAt;
     if (emitRustFormulaDebugEvent({
@@ -1932,7 +1975,12 @@ var RustCalculateFormulaService = class extends Disposable3 {
         this._markRustFormulaDirty(
           this._currentConfigService.getDirtyData(),
           this._dirtyFeatureMapFor(changedFeatures)
-        ), executeStartedAt = performance.now(), outputJson = executeDirtyFormulasOnRust(maxIteration, !1, !1, !0), nativeAndSerializeMs = performance.now() - executeStartedAt, parseStartedAt = performance.now(), output = JSON.parse(outputJson), calculatedNodeCount += output.calculatedNodeCount, parseMs = performance.now() - parseStartedAt, output = await this._resolveExternalReferenceNeeds(output, maxIteration), applyStartedAt = performance.now(), applyBreakdown = await this._applyRustDependencyOutput(output), applyMs = performance.now() - applyStartedAt, emitRustFormulaDebugEvent({
+        ), executeStartedAt = performance.now(), outputJson = this._rustEngineSyncController.engine.binding.rustEngineExecuteDirtyFormulas(
+          maxIteration,
+          !1,
+          !1,
+          !0
+        ), nativeAndSerializeMs = performance.now() - executeStartedAt, parseStartedAt = performance.now(), output = JSON.parse(outputJson), calculatedNodeCount += output.calculatedNodeCount, parseMs = performance.now() - parseStartedAt, output = await this._resolveExternalReferenceNeeds(output, maxIteration), applyStartedAt = performance.now(), applyBreakdown = await this._applyRustDependencyOutput(output), applyMs = performance.now() - applyStartedAt, emitRustFormulaDebugEvent({
           type: "executeDirtyFormulas",
           payload: {
             calculatedNodeCount: output.calculatedNodeCount,
@@ -1977,7 +2025,14 @@ var RustCalculateFormulaService = class extends Disposable3 {
         loadedRanges,
         this._superTableService
       ) === 0) break;
-      this._syncRustFormulaDependencies(), output = JSON.parse(executeDirtyFormulasOnRust(maxIteration, !1, !1, !0));
+      this._syncRustFormulaDependencies(), output = JSON.parse(
+        this._rustEngineSyncController.engine.binding.rustEngineExecuteDirtyFormulas(
+          maxIteration,
+          !1,
+          !1,
+          !0
+        )
+      );
     }
     return output;
   }
@@ -2151,7 +2206,7 @@ var RustCalculateFormulaService = class extends Disposable3 {
     };
   }
   _syncRustFormulaDependencies(dirtyUnitFeatureMapOverride, includeExternalReferences = !1) {
-    let syncState = getRustEngineSyncState(), externalReferences = includeExternalReferences ? this._externalFormulaDatasetConfig?.externalReferences ?? {} : void 0, externalReferenceSignature = externalReferences ? JSON.stringify(externalReferences) : this._syncedExternalReferenceSignature, shouldSendExternalReferences = includeExternalReferences && (externalReferenceSignature !== "{}" || this._syncedExternalReferenceSignature !== "{}"), rebuildSheetFormulas = this._syncedSnapshotEpoch !== syncState.snapshotEpoch || this._syncedDependencyInvalidationEpoch !== syncState.dependencyInvalidationEpoch || shouldSendExternalReferences, collectStartedAt = performance.now(), state = this._collectRustFormulaDependencySyncState(), collectMs = performance.now() - collectStartedAt;
+    let syncState = this._rustEngineSyncController.getSyncState(), externalReferences = includeExternalReferences ? this._externalFormulaDatasetConfig?.externalReferences ?? {} : void 0, externalReferenceSignature = externalReferences ? JSON.stringify(externalReferences) : this._syncedExternalReferenceSignature, shouldSendExternalReferences = includeExternalReferences && (externalReferenceSignature !== "{}" || this._syncedExternalReferenceSignature !== "{}"), rebuildSheetFormulas = this._syncedSnapshotEpoch !== syncState.snapshotEpoch || this._syncedDependencyInvalidationEpoch !== syncState.dependencyInvalidationEpoch || shouldSendExternalReferences, collectStartedAt = performance.now(), state = this._collectRustFormulaDependencySyncState(), collectMs = performance.now() - collectStartedAt;
     if (!(shouldSendExternalReferences || rebuildSheetFormulas || state.featureCalculations.length > 0 || state.otherFormulas.length > 0))
       return emitRustFormulaDebugEvent({
         type: "syncDependencies",
@@ -2175,7 +2230,7 @@ var RustCalculateFormulaService = class extends Disposable3 {
       featureCalculations: state.featureCalculations,
       otherFormulas: state.otherFormulas,
       ...shouldSendExternalReferences ? { externalReferences } : {}
-    }), stringifyMs = performance.now() - stringifyStartedAt, nativeStartedAt = performance.now(), outputJson = syncRustFormulaDependenciesOnRust(inputJson), nativeMs = performance.now() - nativeStartedAt, parseStartedAt = performance.now(), output = JSON.parse(outputJson), parseMs = performance.now() - parseStartedAt;
+    }), stringifyMs = performance.now() - stringifyStartedAt, nativeStartedAt = performance.now(), outputJson = this._rustEngineSyncController.engine.binding.rustEngineSyncFormulaDependencies(inputJson), nativeMs = performance.now() - nativeStartedAt, parseStartedAt = performance.now(), output = JSON.parse(outputJson), parseMs = performance.now() - parseStartedAt;
     return emitRustFormulaDebugEvent({
       type: "syncDependencies",
       payload: {
@@ -2197,7 +2252,7 @@ var RustCalculateFormulaService = class extends Disposable3 {
   }
   _syncRustFormulaDependencyDefinitions() {
     let state = this._collectRustFormulaDependencySyncState();
-    return syncRustFormulaDependenciesOnRust(
+    return this._rustEngineSyncController.engine.binding.rustEngineSyncFormulaDependencies(
       JSON.stringify({
         rebuildSheetFormulas: !1,
         featureCalculations: state.featureCalculations,
@@ -2272,7 +2327,7 @@ var RustCalculateFormulaService = class extends Disposable3 {
       dirtyUnitOtherFormulaMap: dirtyData.dirtyUnitOtherFormulaMap,
       dirtyNameMap: dirtyData.dirtyNameMap,
       dirtyDefinedNameMap: dirtyData.dirtyDefinedNameMap
-    }, stringifyStartedAt = performance.now(), inputJson = JSON.stringify(payload), stringifyMs = performance.now() - stringifyStartedAt, nativeStartedAt = performance.now(), outputJson = markRustFormulaDirtyOnRust(inputJson), nativeMs = performance.now() - nativeStartedAt, rustTimings;
+    }, stringifyStartedAt = performance.now(), inputJson = JSON.stringify(payload), stringifyMs = performance.now() - stringifyStartedAt, nativeStartedAt = performance.now(), outputJson = this._rustEngineSyncController.engine.binding.rustEngineMarkFormulaDirty(inputJson), nativeMs = performance.now() - nativeStartedAt, rustTimings;
     try {
       rustTimings = JSON.parse(outputJson).timings;
     } catch {
@@ -2359,16 +2414,23 @@ var RustCalculateFormulaService = class extends Disposable3 {
     if (!unitData) return result;
     for (let [unitId, sheets] of Object.entries(unitData)) {
       result[unitId] = {};
+      let styles = this._currentConfigService.getUnitStylesData()[unitId], sheetNames = Object.fromEntries(
+        Object.entries(this._currentConfigService.getSheetNameMap()[unitId] ?? {}).map(([name2, id]) => [
+          id,
+          name2
+        ])
+      );
       for (let [sheetId, sheet] of Object.entries(sheets))
         result[unitId][sheetId] = {
-          cellData: this._serializeCellData(sheet.cellData),
+          name: sheetNames[sheetId],
+          cellData: this._serializeCellData(sheet.cellData, styles),
           rowCount: sheet.rowCount ?? 0,
           columnCount: sheet.columnCount ?? 0
         };
     }
     return result;
   }
-  _serializeCellData(cellData) {
+  _serializeCellData(cellData, styles) {
     let result = {};
     if (!cellData || typeof cellData != "object") return result;
     let data = typeof cellData.getMatrix == "function" ? cellData.getMatrix() : cellData;
@@ -2378,13 +2440,23 @@ var RustCalculateFormulaService = class extends Disposable3 {
         result[row] = {};
         for (let [colStr, cell] of Object.entries(cols)) {
           let col = Number(colStr);
-          Number.isFinite(col) && (result[row][col] = {
+          if (!Number.isFinite(col))
+            continue;
+          result[row][col] = {
             v: cell?.v ?? null,
             t: cell?.t ?? void 0,
             p: cell?.p ?? void 0,
             f: cell?.f ?? void 0,
             s: cell?.s ?? void 0
-          });
+          };
+          let style = styles?.getStyleByCell(cell);
+          if (style && typeof style == "object") {
+            let numberFormat = style.n;
+            if (numberFormat && typeof numberFormat == "object") {
+              let pattern = numberFormat.pattern;
+              typeof pattern == "string" && (result[row][col].numberFormat = pattern);
+            }
+          }
         }
       }
     }
@@ -2393,7 +2465,9 @@ var RustCalculateFormulaService = class extends Disposable3 {
   _applyRustOutput(_output) {
   }
   async _applyRustDependencyOutput(output) {
-    let convertStartedAt = performance.now(), patch = rustExecutionOutputToFormulaCalculationPatch(output), convertMs = performance.now() - convertStartedAt, commandStartedAt = performance.now();
+    let convertStartedAt = performance.now(), patch = rustExecutionOutputToFormulaCalculationPatch(output);
+    this._mergeRuntimeUnitData(patch.unitData);
+    let convertMs = performance.now() - convertStartedAt, commandStartedAt = performance.now();
     return (patch.arrayFormulaRange || patch.arrayFormulaCellData) && (this._formulaDataModel.setArrayFormulaRange(patch.arrayFormulaRange ?? {}), this._formulaDataModel.setArrayFormulaCellData(patch.arrayFormulaCellData ?? {}), await this._commandService.executeCommand(
       SetArrayFormulaDataMutation.id,
       {
@@ -2420,8 +2494,22 @@ var RustCalculateFormulaService = class extends Disposable3 {
       commandMs: performance.now() - commandStartedAt
     };
   }
+  _mergeRuntimeUnitData(unitData) {
+    let runtimeUnitData = this._runtimeService.getUnitData();
+    Object.entries(unitData).forEach(([unitId, sheetMap]) => {
+      if (!sheetMap) return;
+      let runtimeSheetMap = runtimeUnitData[unitId] ??= {};
+      Object.entries(sheetMap).forEach(([sheetId, cellData]) => {
+        if (!cellData) return;
+        let runtimeMatrix = runtimeSheetMap[sheetId] ??= new ObjectMatrix3();
+        new ObjectMatrix3(cellData).forValue((row, column, cell) => {
+          runtimeMatrix.setValue(row, column, cell);
+        });
+      });
+    });
+  }
   async calculate(formulaString) {
-    this._nativeLoaded || (await loadNativeBinding(), this._nativeLoaded = !0);
+    this._nativeLoaded || (await this._rustEngineSyncController.engine.initialize(), this._nativeLoaded = !0);
     let unitId = "__rust_formula_calculate__", sheetId = "__sheet__", input = {
       config: { maxIteration: 1, intervalCount: DEFAULT_INTERVAL_COUNT },
       formulaData: {
@@ -2446,23 +2534,35 @@ var RustCalculateFormulaService = class extends Disposable3 {
     return JSON.parse(executeOnRust(JSON.stringify(input))).runtimeData?.[unitId]?.[sheetId]?.[0]?.[0] ?? null;
   }
   async executeFormulas(formulas, rowData) {
-    this._nativeLoaded || (await loadNativeBinding(), this._nativeLoaded = !0), this._currentConfigService.loadDataLite(rowData);
-    let unitData = this._currentConfigService.getUnitData(), formulaData = this._formulaStringMapToFormulaData(formulas), input = {
+    this._nativeLoaded || (await this._rustEngineSyncController.engine.initialize(), this._nativeLoaded = !0), this._currentConfigService.loadDataLite(rowData);
+    let unitData = this._currentConfigService.getUnitData(), definedNames = {};
+    for (let [unitId, names] of Object.entries(this._definedNamesService.getAllDefinedNames()))
+      for (let [id, name2] of Object.entries(names))
+        definedNames[JSON.stringify([unitId, id])] = {
+          unitId,
+          localSheetId: name2.localSheetId === "AllDefaultWorkbook" ? void 0 : name2.localSheetId,
+          name: name2.name,
+          formula: name2.formulaOrRefString
+        };
+    let input = {
       config: { maxIteration: 1, intervalCount: DEFAULT_INTERVAL_COUNT },
-      formulaData,
+      formulaData: {},
+      queryFormulas: this._formulaStringMapToQueryData(formulas),
       unitData: this._serializeUnitData(unitData),
       dirtyRanges: [],
-      definedNames: {}
+      definedNames
     }, output = JSON.parse(executeOnRust(JSON.stringify(input)));
+    if (!output.queryResults)
+      throw new Error("Native formula binding does not support independent formula queries");
     return this._formulaExecutionOutputToResultMap(formulas, output);
   }
   async getAllDependencyJson(_rowData) {
-    this._nativeLoaded || (await loadNativeBinding(), this._nativeLoaded = !0), this._syncRustFormulaDependencyDefinitions();
+    this._nativeLoaded || (await this._rustEngineSyncController.engine.initialize(), this._nativeLoaded = !0), this._syncRustFormulaDependencyDefinitions();
     let graph = this._getRustDependencyGraph(), inspect = this._getRustInspectGraph();
     return this._rustAllDependencyJson(graph, inspect);
   }
   async getCellDependencyJson(unitId, sheetId, row, column, _rowData) {
-    this._nativeLoaded || (await loadNativeBinding(), this._nativeLoaded = !0), this._syncRustFormulaDependencyDefinitions();
+    this._nativeLoaded || (await this._rustEngineSyncController.engine.initialize(), this._nativeLoaded = !0), this._syncRustFormulaDependencyDefinitions();
     let graph = this._getRustDependencyGraph(unitId), all = this._rustGraphDependencyJson(graph), current = all.find(
       (item) => item.unitId === unitId && item.subUnitId === sheetId && item.row === row && item.column === column
     );
@@ -2476,16 +2576,18 @@ var RustCalculateFormulaService = class extends Disposable3 {
     };
   }
   async getRangeDependents(unitRanges) {
-    this._nativeLoaded || (await loadNativeBinding(), this._nativeLoaded = !0), this._syncRustFormulaDependencyDefinitions();
+    this._nativeLoaded || (await this._rustEngineSyncController.engine.initialize(), this._nativeLoaded = !0), this._syncRustFormulaDependencyDefinitions();
     let graph = this._getRustDependencyGraph(), graphItems = this._rustGraphDependencyJson(graph), graphByCell = this._rustDependencyJsonByCell(graphItems), dirty = JSON.parse(
-      getRustDirtyDependenciesOnRust(JSON.stringify(this._serializeUnitRanges(unitRanges)))
+      this._rustEngineSyncController.engine.binding.rustEngineGetDirtyDependencies(
+        JSON.stringify(this._serializeUnitRanges(unitRanges))
+      )
     );
     return this._uniqueDependencyJson(
       (dirty.direct ?? dirty.affected ?? []).map((cell) => graphByCell.get(this._cellKey(cell))).filter(Boolean)
     );
   }
   async getInRangeFormulas(unitRanges) {
-    return this._nativeLoaded || (await loadNativeBinding(), this._nativeLoaded = !0), this._syncRustFormulaDependencyDefinitions(), this._rustGraphDependencyJson(this._getRustDependencyGraph()).filter(
+    return this._nativeLoaded || (await this._rustEngineSyncController.engine.initialize(), this._nativeLoaded = !0), this._syncRustFormulaDependencyDefinitions(), this._rustGraphDependencyJson(this._getRustDependencyGraph()).filter(
       (item) => this._cellInUnitRanges(item.unitId, item.subUnitId, item.row, item.column, unitRanges)
     );
   }
@@ -2496,7 +2598,7 @@ var RustCalculateFormulaService = class extends Disposable3 {
     ]);
     return { dependents, inRanges };
   }
-  _formulaStringMapToFormulaData(formulas) {
+  _formulaStringMapToQueryData(formulas) {
     let formulaData = {};
     return Object.entries(formulas).forEach(([unitId, sheetMap]) => {
       sheetMap && (formulaData[unitId] = {}, Object.entries(sheetMap).forEach(([sheetId, rowMap]) => {
@@ -2504,8 +2606,7 @@ var RustCalculateFormulaService = class extends Disposable3 {
           if (!colMap) return;
           let row = Number(rowKey);
           formulaData[unitId][sheetId][row] = {}, Object.entries(colMap).forEach(([colKey, formulaList]) => {
-            let formula = Array.isArray(formulaList) ? formulaList[0] : void 0;
-            typeof formula == "string" && (formulaData[unitId][sheetId][row][Number(colKey)] = formula);
+            Array.isArray(formulaList) && (formulaData[unitId][sheetId][row][Number(colKey)] = formulaList);
           });
         }));
       }));
@@ -2519,20 +2620,27 @@ var RustCalculateFormulaService = class extends Disposable3 {
           if (!colMap) return;
           let row = Number(rowKey);
           result[unitId][sheetId][row] = {}, Object.entries(colMap).forEach(([colKey, formulaList]) => {
-            let col = Number(colKey), formulasForCell = Array.isArray(formulaList) ? formulaList : [], value = normalizeFormulaResultValue(
-              output.runtimeData?.[unitId]?.[sheetId]?.[row]?.[col]
-            );
-            result[unitId][sheetId][row][col] = formulasForCell.map((formula) => ({ formula, value }));
+            let col = Number(colKey), formulasForCell = Array.isArray(formulaList) ? formulaList : [];
+            result[unitId][sheetId][row][col] = formulasForCell.map((formula, index) => ({
+              formula,
+              value: normalizeFormulaResultValue(
+                output.queryResults?.[unitId]?.[sheetId]?.[row]?.[col]?.[index]?.value
+              )
+            }));
           });
         }));
       }));
     }), result;
   }
   _getRustDependencyGraph(unitId) {
-    return JSON.parse(buildRustDependencyGraphOnRust(unitId));
+    return JSON.parse(
+      this._rustEngineSyncController.engine.binding.rustEngineBuildDependencyGraph(unitId)
+    );
   }
   _getRustInspectGraph() {
-    return JSON.parse(inspectRustFormulaDependencyGraphOnRust());
+    return JSON.parse(
+      this._rustEngineSyncController.engine.binding.rustEngineInspectFormulaDependencyGraph()
+    );
   }
   _rustAllDependencyJson(graph, inspect) {
     let cellItems = this._rustGraphDependencyJson(graph), seen = new Set(cellItems.map((item) => item.treeId)), nonCellItems = (inspect.nodes ?? []).filter((item) => item.node.nodeType !== "cellFormula" && !seen.has(item.index)).map((item) => this._rustFormulaNodeToDependencyJson(item.index, item.node));
@@ -2641,7 +2749,8 @@ setDependencies3(RustCalculateFormulaService, [
   FormulaDataModel2,
   IFormulaReferenceDataService,
   ExternalReferenceModel,
-  ISuperTableService2
+  ISuperTableService2,
+  IDefinedNamesService
 ]);
 function createRustProductExternalSyntheticUnitId(hostUnitId, referenceId) {
   return `external:product:${encodeURIComponent(hostUnitId)}:${encodeURIComponent(referenceId)}`;
@@ -2737,6 +2846,7 @@ export {
   RUST_UPSERT_REFERENCE_DATA_MUTATION_ID,
   RustCalculateFormulaService,
   RustEngineSyncController,
+  RustFormulaEngineSession,
   RustFormulaProjectionService,
   UniverRustFormulaEnginePlugin,
   analyzeNumberFormatBatch,