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

package/lib/cjs/index.cjs

@@ -32,6 +32,7 @@ __export(index_exports, {
   RUST_UPSERT_REFERENCE_DATA_MUTATION_ID: () => RUST_UPSERT_REFERENCE_DATA_MUTATION_ID,
   RustCalculateFormulaService: () => RustCalculateFormulaService,
   RustEngineSyncController: () => RustEngineSyncController,
+  RustFormulaEngineSession: () => RustFormulaEngineSession,
   RustFormulaProjectionService: () => RustFormulaProjectionService,
   UniverRustFormulaEnginePlugin: () => UniverRustFormulaEnginePlugin,
   analyzeNumberFormatBatch: () => analyzeNumberFormatBatch,
@@ -150,11 +151,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.");
@@ -205,11 +201,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.");
@@ -225,21 +216,34 @@ 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
 var import_core2 = require("@univerjs/core");
@@ -262,6 +266,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",
@@ -335,11 +344,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),
@@ -407,13 +423,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,
@@ -422,12 +441,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 {
@@ -440,7 +467,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) {
@@ -452,16 +481,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) {
@@ -476,7 +505,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,
@@ -484,7 +513,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 {
@@ -496,7 +529,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),
@@ -505,7 +538,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) {
@@ -947,19 +980,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 import_core.ObjectMatrix ? cellData.getMatrix() : cellData;
   for (let [rowKey, row] of Object.entries(rawCellData ?? {})) {
     if (!row)
@@ -968,13 +1001,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 === import_core.BooleanNumber.FALSE || cellRecord.fd === import_core.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);
@@ -997,23 +1032,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 === import_core.FormulaType.ARRAY && cell.fd !== import_core.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, "");
@@ -1041,19 +1072,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);
@@ -1093,6 +1111,17 @@ var RustEngineSyncController = class extends import_core2.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;
@@ -1126,7 +1155,7 @@ var RustEngineSyncController = class extends import_core2.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);
   }
@@ -1149,20 +1178,17 @@ var RustEngineSyncController = class extends import_core2.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;
@@ -1170,7 +1196,7 @@ var RustEngineSyncController = class extends import_core2.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 {
@@ -1189,7 +1215,7 @@ var RustEngineSyncController = class extends import_core2.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) {
@@ -1207,9 +1233,9 @@ var RustEngineSyncController = class extends import_core2.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",
@@ -1225,7 +1251,11 @@ var RustEngineSyncController = class extends import_core2.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) {
@@ -1289,7 +1319,7 @@ async function analyzeNumberFormatBatch(input) {
 var import_core5 = require("@univerjs/core"), import_engine_formula4 = require("@univerjs/engine-formula"), import_engine_formula5 = require("@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
 var import_core3 = require("@univerjs/core"), import_engine_formula = require("@univerjs/engine-formula");
@@ -1318,13 +1348,16 @@ var RustSameRuntimeProjectionController = class extends import_core3.Disposable
       import_core3.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(
       (0, import_core3.toDisposable)(
         this._univerInstanceService.getTypeOfUnitAdded$(import_core3.UniverInstanceType.UNIVER_SHEET).subscribe(({ unit }) => {
           this._enqueueProjectionDelta(() => {
             this._rustEngineSyncController.upsertProjectionWorkbook({
               unitId: unit.getUnitId(),
-              snapshot: unit.getSnapshot()
+              snapshot: unit.getSnapshot(),
+              styleResolver: unit.getStyles()
             });
           });
         })
@@ -1538,7 +1571,8 @@ var RustSameRuntimeProjectionController = class extends import_core3.Disposable
   async _loadAllWorkbookProjections() {
     let workbooks = this._univerInstanceService.getAllUnitsForType(import_core3.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(import_core3.UniverInstanceType.UNIVER_BASE).map(
       (base) => this._createBaseWorkbookProjection(
         base.getUnitId(),
@@ -1854,7 +1888,7 @@ function resultBatchSheetCounts(output) {
   return counts;
 }
 var RustCalculateFormulaService = class extends import_core4.Disposable {
-  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;
@@ -1868,6 +1902,7 @@ var RustCalculateFormulaService = class extends import_core4.Disposable {
     this._formulaReferenceDataService = _formulaReferenceDataService;
     this._excelExternalReferenceModel = _excelExternalReferenceModel;
     this._superTableService = _superTableService;
+    this._definedNamesService = _definedNamesService;
     this._commandService.hasCommand(import_engine_formula2.SetFormulaCalculationResultMutation.id) || this.disposeWithMe(this._commandService.registerCommand(import_engine_formula2.SetFormulaCalculationResultMutation)), this._commandService.hasCommand(import_engine_formula2.SetArrayFormulaDataMutation.id) || this.disposeWithMe(this._commandService.registerCommand(import_engine_formula2.SetArrayFormulaDataMutation));
   }
   _configService;
@@ -1882,6 +1917,7 @@ var RustCalculateFormulaService = class extends import_core4.Disposable {
   _formulaReferenceDataService;
   _excelExternalReferenceModel;
   _superTableService;
+  _definedNamesService;
   _executionInProgressListener$ = new import_rxjs.Subject();
   executionInProgressListener$ = this._executionInProgressListener$.asObservable();
   _executionCompleteListener$ = new import_rxjs.Subject();
@@ -1909,14 +1945,19 @@ var RustCalculateFormulaService = class extends import_core4.Disposable {
     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(import_engine_formula2.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(import_engine_formula2.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(import_engine_formula2.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({
@@ -1952,7 +1993,12 @@ var RustCalculateFormulaService = class extends import_core4.Disposable {
         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,
@@ -1997,7 +2043,14 @@ var RustCalculateFormulaService = class extends import_core4.Disposable {
         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;
   }
@@ -2171,7 +2224,7 @@ var RustCalculateFormulaService = class extends import_core4.Disposable {
     };
   }
   _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",
@@ -2195,7 +2248,7 @@ var RustCalculateFormulaService = class extends import_core4.Disposable {
       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: {
@@ -2217,7 +2270,7 @@ var RustCalculateFormulaService = class extends import_core4.Disposable {
   }
   _syncRustFormulaDependencyDefinitions() {
     let state = this._collectRustFormulaDependencySyncState();
-    return syncRustFormulaDependenciesOnRust(
+    return this._rustEngineSyncController.engine.binding.rustEngineSyncFormulaDependencies(
       JSON.stringify({
         rebuildSheetFormulas: !1,
         featureCalculations: state.featureCalculations,
@@ -2292,7 +2345,7 @@ var RustCalculateFormulaService = class extends import_core4.Disposable {
       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 {
@@ -2379,16 +2432,23 @@ var RustCalculateFormulaService = class extends import_core4.Disposable {
     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;
@@ -2398,13 +2458,23 @@ var RustCalculateFormulaService = class extends import_core4.Disposable {
         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);
+            }
+          }
         }
       }
     }
@@ -2413,7 +2483,9 @@ var RustCalculateFormulaService = class extends import_core4.Disposable {
   _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(
       import_engine_formula2.SetArrayFormulaDataMutation.id,
       {
@@ -2440,8 +2512,22 @@ var RustCalculateFormulaService = class extends import_core4.Disposable {
       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 import_core4.ObjectMatrix();
+        new import_core4.ObjectMatrix(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: {
@@ -2466,23 +2552,35 @@ var RustCalculateFormulaService = class extends import_core4.Disposable {
     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
     );
@@ -2496,16 +2594,18 @@ var RustCalculateFormulaService = class extends import_core4.Disposable {
     };
   }
   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)
     );
   }
@@ -2516,7 +2616,7 @@ var RustCalculateFormulaService = class extends import_core4.Disposable {
     ]);
     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]) => {
@@ -2524,8 +2624,7 @@ var RustCalculateFormulaService = class extends import_core4.Disposable {
           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);
           });
         }));
       }));
@@ -2539,20 +2638,27 @@ var RustCalculateFormulaService = class extends import_core4.Disposable {
           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));
@@ -2661,7 +2767,8 @@ var RustCalculateFormulaService = class extends import_core4.Disposable {
   import_engine_formula2.FormulaDataModel,
   import_engine_formula3.IFormulaReferenceDataService,
   import_engine_formula3.ExternalReferenceModel,
-  import_engine_formula2.ISuperTableService
+  import_engine_formula2.ISuperTableService,
+  import_engine_formula2.IDefinedNamesService
 ]);
 function createRustProductExternalSyntheticUnitId(hostUnitId, referenceId) {
   return `external:product:${encodeURIComponent(hostUnitId)}:${encodeURIComponent(referenceId)}`;
@@ -2758,6 +2865,7 @@ async function materializeWorkbookSnapshot(workbook, unitID, rev, dirtyInput) {
   RUST_UPSERT_REFERENCE_DATA_MUTATION_ID,
   RustCalculateFormulaService,
   RustEngineSyncController,
+  RustFormulaEngineSession,
   RustFormulaProjectionService,
   UniverRustFormulaEnginePlugin,
   analyzeNumberFormatBatch,