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

package/lib/index.js

@@ -0,0 +1,2114 @@
+// src/binding.ts
+import { createRequire } from "node:module";
+import process from "node:process";
+var nativeBinding = null, nativeBindingSource = null, nodeRequire = createRequire(import.meta.url);
+function getNativeBindingSource() {
+  return nativeBindingSource;
+}
+function formatBindingLoadError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function createBindingLoadFailure(errors) {
+  return new Error(
+    [
+      "Failed to load native formula engine binding.",
+      `platform=${process.platform}`,
+      `arch=${process.arch}`,
+      "expected npm package=@univerjs-pro/engine-formula-rust-binding",
+      "attempted paths:",
+      ...errors.map((item) => `- ${item}`)
+    ].join(`
+`)
+  );
+}
+async function loadNativeBinding() {
+  if (nativeBinding)
+    return nativeBinding;
+  if (typeof process < "u" && process.versions?.node) {
+    let errors = [];
+    try {
+      return nativeBinding = nodeRequire("@univerjs-pro/engine-formula-rust-binding"), nativeBindingSource = "@univerjs-pro/engine-formula-rust-binding", nativeBinding;
+    } catch (error) {
+      errors.push(`@univerjs-pro/engine-formula-rust-binding: ${formatBindingLoadError(error)}`);
+    }
+    throw createBindingLoadFailure(errors);
+  } else
+    throw new Error("WASM binding not yet implemented");
+}
+function executeOnRust(inputJson) {
+  if (!nativeBinding)
+    throw new Error("Native binding not loaded. Call loadNativeBinding() first.");
+  return nativeBinding.formulaEngineExecute(inputJson);
+}
+function buildLexerTreeOnRust(formula, transformSuffix = !0) {
+  if (!nativeBinding)
+    throw new Error("Native binding not loaded. Call loadNativeBinding() first.");
+  return nativeBinding.formulaLexerTreeBuild(formula, transformSuffix);
+}
+function buildSequenceNodesOnRust(formula) {
+  if (!nativeBinding)
+    throw new Error("Native binding not loaded. Call loadNativeBinding() first.");
+  return nativeBinding.formulaSequenceNodesBuild(formula);
+}
+function checkIfAddBracketOnRust(formula) {
+  if (!nativeBinding)
+    throw new Error("Native binding not loaded. Call loadNativeBinding() first.");
+  return nativeBinding.formulaCheckIfAddBracket(formula);
+}
+function formatNumberBatchOnRust(inputJson) {
+  if (!nativeBinding)
+    throw new Error("Native binding not loaded. Call loadNativeBinding() first.");
+  return nativeBinding.rustNumfmtFormatBatch(inputJson);
+}
+function parseNumberFormatInputBatchOnRust(inputJson) {
+  if (!nativeBinding)
+    throw new Error("Native binding not loaded. Call loadNativeBinding() first.");
+  return nativeBinding.rustNumfmtParseBatch(inputJson);
+}
+function parseNumberFormatMatrixBatchOnRust(inputJson) {
+  if (!nativeBinding)
+    throw new Error("Native binding not loaded. Call loadNativeBinding() first.");
+  return nativeBinding.rustNumfmtParseMatrixBatch(inputJson);
+}
+function analyzeNumberFormatBatchOnRust(inputJson) {
+  if (!nativeBinding)
+    throw new Error("Native binding not loaded. Call loadNativeBinding() first.");
+  return nativeBinding.rustNumfmtAnalyzeBatch(inputJson);
+}
+function loadSnapshotOnRust(snapshotJson) {
+  if (!nativeBinding)
+    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.");
+  return nativeBinding.rustEngineApplyMutation(mutationJson);
+}
+function disposeWorkbookOnRust(unitId) {
+  if (!nativeBinding)
+    throw new Error("Native binding not loaded. Call loadNativeBinding() first.");
+  return nativeBinding.rustEngineDisposeWorkbook(unitId);
+}
+function disposeAllWorkbooksOnRust() {
+  if (!nativeBinding)
+    throw new Error("Native binding not loaded. Call loadNativeBinding() first.");
+  return nativeBinding.rustEngineDisposeAllWorkbooks();
+}
+function getRustModelStats() {
+  if (!nativeBinding)
+    throw new Error("Native binding not loaded. Call loadNativeBinding() first.");
+  return nativeBinding.rustEngineGetModelStats();
+}
+function getRustCellOnRust(unitId, sheetId, row, col) {
+  if (!nativeBinding)
+    throw new Error("Native binding not loaded. Call loadNativeBinding() first.");
+  return nativeBinding.rustEngineGetCell(unitId, sheetId, row, col);
+}
+function getRustSheetStateOnRust(unitId, sheetId) {
+  if (!nativeBinding)
+    throw new Error("Native binding not loaded. Call loadNativeBinding() first.");
+  return nativeBinding.rustEngineGetSheetState(unitId, sheetId);
+}
+function getRustFormulaDataOnRust(unitId) {
+  if (!nativeBinding)
+    throw new Error("Native binding not loaded. Call loadNativeBinding() first.");
+  return nativeBinding.rustEngineGetFormulaData(unitId);
+}
+function buildRustDependencyGraphOnRust(unitId) {
+  if (!nativeBinding)
+    throw new Error("Native binding not loaded. Call loadNativeBinding() first.");
+  return nativeBinding.rustEngineBuildDependencyGraph(unitId);
+}
+function getRustDirtyDependenciesOnRust(dirtyRangesJson, unitId) {
+  if (!nativeBinding)
+    throw new Error("Native binding not loaded. Call loadNativeBinding() first.");
+  return nativeBinding.rustEngineGetDirtyDependencies(dirtyRangesJson, unitId);
+}
+function syncRustFormulaDependenciesOnRust(inputJson) {
+  if (!nativeBinding)
+    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.");
+  return nativeBinding.rustEngineMarkFormulaDirty(inputJson);
+}
+function clearRustFormulaDependenciesOnRust(inputJson) {
+  if (!nativeBinding)
+    throw new Error("Native binding not loaded. Call loadNativeBinding() first.");
+  return nativeBinding.rustEngineClearFormulaDependencies(inputJson);
+}
+function clearRustFormulaDirtyOnRust() {
+  if (!nativeBinding)
+    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);
+}
+
+// src/controllers/rust-engine-sync.controller.ts
+import { CommandType, Disposable, ICommandService, setDependencies } from "@univerjs/core";
+
+// src/services/rust-formula-projection.service.ts
+import { CellValueType, 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_FORMULA_RELEVANT_MUTATIONS = /* @__PURE__ */ new Set([
+  "sheet.mutation.set-range-values",
+  "sheet.mutation.insert-row",
+  "sheet.mutation.insert-col",
+  "sheet.mutation.insert-sheet",
+  "sheet.mutation.move-range",
+  "sheet.mutation.move-rows",
+  "sheet.mutation.move-columns",
+  "sheet.mutation.move-cols",
+  "sheet.mutation.remove-col",
+  "sheet.mutation.remove-rows",
+  "sheet.mutation.remove-sheet",
+  "sheet.mutation.set-col-hidden",
+  "sheet.mutation.set-col-visible",
+  "sheet.mutation.set-row-hidden",
+  "sheet.mutation.set-row-visible",
+  "sheet.mutation.set-worksheet-name",
+  "sheet.mutation.reorder-range",
+  "sheet.mutation.set-worksheet-row-count",
+  "sheet.mutation.set-worksheet-column-count",
+  "formula.mutation.set-array-formula-data",
+  "formula.mutation.set-defined-name",
+  "formula.mutation.set-feature-calculation",
+  "formula.mutation.set-formula-data",
+  "formula.mutation.set-image-formula-data",
+  "formula.mutation.set-other-formula",
+  "formula.mutation.set-super-table",
+  "formula.mutation.set-super-table-option",
+  "formula.mutation.remove-defined-name",
+  "formula.mutation.remove-feature-calculation",
+  "formula.mutation.remove-other-formula",
+  "formula.mutation.remove-super-table"
+]), RUST_INCREMENTAL_DEPENDENCY_MUTATIONS = /* @__PURE__ */ new Set(["sheet.mutation.set-range-values"]);
+function isRustFormulaRelevantMutation(id) {
+  return RUST_FORMULA_RELEVANT_MUTATIONS.has(id);
+}
+function isRustIncrementalDependencyMutation(id) {
+  return RUST_INCREMENTAL_DEPENDENCY_MUTATIONS.has(id);
+}
+function createReferenceDataUpsertMutations(config, needs) {
+  let unitNameMap = config.unitNameMap, grouped = /* @__PURE__ */ new Map();
+  for (let need of needs) {
+    let key = `${need.unitId}\0${need.sheetId}`, group = grouped.get(key) ?? [];
+    group.push(need), grouped.set(key, group);
+  }
+  return Array.from(grouped.values()).flatMap((group) => {
+    let first = group[0], unitData = config.allUnitData?.[first.unitId], sheetNameMap = config.unitSheetNameMap?.[first.unitId] ?? {}, resolvedSheetId = unitData?.[first.sheetId] ? first.sheetId : sheetNameMap[first.sheetId] ?? first.sheetId, sheet = unitData?.[resolvedSheetId];
+    if (!sheet)
+      return [];
+    let sheetName = Object.entries(sheetNameMap).find(([, sheetId]) => sheetId === resolvedSheetId)?.[0] ?? first.sheetId, ranges = group.map(({ range }) => range);
+    return [
+      {
+        id: RUST_UPSERT_REFERENCE_DATA_MUTATION_ID,
+        params: {
+          unitId: first.unitId,
+          name: unitNameMap?.[first.unitId]?.name,
+          sheet: {
+            name: sheetName,
+            sheetId: resolvedSheetId,
+            rowCount: sheet.rowCount,
+            columnCount: sheet.columnCount,
+            coverage: ranges,
+            cellData: serializeCellDataInRanges(sheet.cellData, ranges)
+          }
+        },
+        dirtyRanges: ranges.map((range) => ({
+          unitId: first.unitId,
+          sheetId: resolvedSheetId,
+          range
+        }))
+      }
+    ];
+  });
+}
+function serializeRuntimeWorkbookSnapshots(workbooks) {
+  return {
+    workbooks: workbooks.map((workbook) => serializeRuntimeWorkbookSnapshot(workbook))
+  };
+}
+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)
+  ).filter((sheet) => sheet != null);
+  return {
+    unitId: input.unitId || snapshot.id,
+    name: snapshot.name,
+    sheets,
+    ...calculation ? { calculation } : {},
+    resources: serializeResources(snapshot),
+    definedNames: serializeDefinedNames(input.definedNames, snapshot),
+    externalLinks: serializeExternalLinks(snapshot),
+    tables: serializeTables(snapshot)
+  };
+}
+function rustExecutionOutputToFormulaCalculationPatch(output) {
+  let arrayFormulaOutput = output;
+  return {
+    unitData: output.resultBatches?.length ? resultBatchesToUnitData(output.resultBatches) : runtimeDataToUnitData(output.runtimeData),
+    unitOtherData: otherFormulaDataToUnitOtherData(output.otherFormulaData),
+    ...arrayFormulaOutput.arrayFormulaRange ? { arrayFormulaRange: arrayFormulaOutput.arrayFormulaRange } : {},
+    ...arrayFormulaOutput.arrayFormulaCellData ? { arrayFormulaCellData: arrayFormulaOutput.arrayFormulaCellData } : {},
+    errors: output.errors?.map((error) => ({
+      code: "RUST_FORMULA_CALCULATION_ERROR",
+      unitId: error.unitId,
+      sheetId: error.sheetId,
+      row: error.row,
+      column: error.column,
+      message: error.message
+    }))
+  };
+}
+function otherFormulaDataToUnitOtherData(otherFormulaData) {
+  let unitOtherData = {};
+  return Object.entries(otherFormulaData ?? {}).forEach(([unitId, sheetMap]) => {
+    if (!sheetMap) return;
+    let unitSheetData = {};
+    unitOtherData[unitId] = unitSheetData, Object.entries(sheetMap).forEach(([sheetId, formulaMap]) => {
+      if (!formulaMap) return;
+      let sheetData = {};
+      unitSheetData[sheetId] = sheetData, Object.entries(formulaMap).forEach(([formulaId, rowMap]) => {
+        if (!rowMap) return;
+        let formulaData = {};
+        sheetData[formulaId] = formulaData, Object.entries(rowMap).forEach(([rowKey, colMap]) => {
+          if (!colMap) return;
+          let row = Number(rowKey), rowData = {};
+          formulaData[row] = rowData, Object.entries(colMap).forEach(([colKey, value]) => {
+            rowData[Number(colKey)] = [[cellDataFromRustValue(value)]];
+          });
+        });
+      });
+    });
+  }), unitOtherData;
+}
+function createFormulaProjectionDesyncSignal(reason, error, mutationId) {
+  return {
+    reason,
+    mutationId,
+    message: error instanceof Error ? error.message : String(error)
+  };
+}
+var RustFormulaProjectionService = class {
+  _nativeLoaded = !1;
+  async load(workbooks) {
+    await this._ensureNativeLoaded();
+    try {
+      return {
+        stats: JSON.parse(loadSnapshotOnRust(JSON.stringify(serializeRuntimeWorkbookSnapshots(workbooks))))
+      };
+    } catch (error) {
+      return {
+        desync: createFormulaProjectionDesyncSignal("snapshot-load-failed", error),
+        errors: [errorToFormulaCalculationError("RUST_FORMULA_LOAD_ERROR", error)]
+      };
+    }
+  }
+  async applyMutation(mutation) {
+    await this._ensureNativeLoaded();
+    try {
+      return {
+        stats: JSON.parse(applyMutationOnRust(JSON.stringify(normalizeRustEngineMutation(mutation)))),
+        dependencyInvalidated: !isRustIncrementalDependencyMutation(mutation.id)
+      };
+    } catch (error) {
+      return {
+        dependencyInvalidated: !0,
+        desync: createFormulaProjectionDesyncSignal("mutation-apply-failed", error, mutation.id),
+        errors: [errorToFormulaCalculationError("RUST_FORMULA_MUTATION_ERROR", error)]
+      };
+    }
+  }
+  async syncFormulaDependencies(input) {
+    return await this._ensureNativeLoaded(), JSON.parse(syncRustFormulaDependenciesOnRust(JSON.stringify(input)));
+  }
+  async markDirty(input) {
+    return await this._ensureNativeLoaded(), JSON.parse(markRustFormulaDirtyOnRust(JSON.stringify(input)));
+  }
+  async calculateDirty(maxIteration = 1) {
+    await this._ensureNativeLoaded();
+    try {
+      let output = JSON.parse(
+        executeDirtyFormulasOnRust(maxIteration, !1, !1, !0)
+      );
+      return rustExecutionOutputToFormulaCalculationPatch(output);
+    } catch (error) {
+      return {
+        unitData: {},
+        unitOtherData: {},
+        desync: createFormulaProjectionDesyncSignal("dirty-calculation-failed", error),
+        errors: [errorToFormulaCalculationError("RUST_FORMULA_CALCULATION_ERROR", error)]
+      };
+    }
+  }
+  async reset() {
+    await this._ensureNativeLoaded();
+    try {
+      return clearRustFormulaDirtyOnRust(), clearRustFormulaDependenciesOnRust(
+        JSON.stringify({
+          unitId: "",
+          clearSheetFormulas: !0,
+          clearFeatureFormulas: !0,
+          clearOtherFormulas: !0
+        })
+      ), {
+        stats: JSON.parse(loadSnapshotOnRust(JSON.stringify({ workbooks: [] })))
+      };
+    } catch (error) {
+      return {
+        desync: createFormulaProjectionDesyncSignal("projection-reset-failed", error),
+        errors: [errorToFormulaCalculationError("RUST_FORMULA_RESET_ERROR", error)]
+      };
+    }
+  }
+  async disposeWorkbook(unitId) {
+    await this._ensureNativeLoaded();
+    try {
+      return { stats: JSON.parse(disposeWorkbookOnRust(unitId)) };
+    } catch (error) {
+      return {
+        desync: createFormulaProjectionDesyncSignal("workbook-dispose-failed", error),
+        errors: [errorToFormulaCalculationError("RUST_FORMULA_DISPOSE_ERROR", error)]
+      };
+    }
+  }
+  async _ensureNativeLoaded() {
+    this._nativeLoaded || (await loadNativeBinding(), this._nativeLoaded = !0);
+  }
+};
+function normalizeRustEngineMutation(mutation) {
+  return {
+    id: mutation.id,
+    params: mutation.params ?? {},
+    dirtyRanges: Array.isArray(mutation.dirtyRanges) ? mutation.dirtyRanges : []
+  };
+}
+function resultBatchesToUnitData(resultBatches) {
+  let unitData = {};
+  for (let batch of resultBatches) {
+    let unitSheetData = unitData[batch.unitId] ?? {};
+    unitData[batch.unitId] = unitSheetData;
+    let sheetData = unitSheetData[batch.sheetId] ?? {};
+    unitSheetData[batch.sheetId] = sheetData;
+    for (let index = 0; index < batch.values.length; index++) {
+      let row = batch.rows[index], col = batch.cols[index], value = batch.values[index], rowData = sheetData[row] ?? {};
+      sheetData[row] = rowData, rowData[col] = cellDataFromRustValue(value);
+    }
+  }
+  return unitData;
+}
+function runtimeDataToUnitData(runtimeData) {
+  let unitData = {};
+  return Object.entries(runtimeData ?? {}).forEach(([unitId, sheetMap]) => {
+    if (!sheetMap) return;
+    let unitSheetData = {};
+    unitData[unitId] = unitSheetData, Object.entries(sheetMap).forEach(([sheetId, rowMap]) => {
+      if (!rowMap) return;
+      let sheetData = {};
+      unitSheetData[sheetId] = sheetData, Object.entries(rowMap).forEach(([rowKey, colMap]) => {
+        if (!colMap) return;
+        let row = Number(rowKey), rowData = {};
+        sheetData[row] = rowData, Object.entries(colMap).forEach(([colKey, value]) => {
+          rowData[Number(colKey)] = cellDataFromRustValue(value);
+        });
+      });
+    });
+  }), unitData;
+}
+function cellDataFromRustValue(value) {
+  if (value == null)
+    return null;
+  if (typeof value == "number")
+    return { t: CellValueType.NUMBER, v: value };
+  if (typeof value == "boolean")
+    return { t: CellValueType.BOOLEAN, v: value };
+  if (typeof value == "string")
+    return { t: CellValueType.STRING, v: value };
+  if (isRecord(value)) {
+    let cell = sanitizeCoreCellData(value);
+    if (Object.keys(cell).length > 0)
+      return cell;
+  }
+  return { v: value };
+}
+function sanitizeCoreCellData(value) {
+  let cell = {};
+  for (let key of ["v", "t", "p", "s", "f", "si", "ref", "xf", "custom"])
+    key in value && (cell[key] = value[key]);
+  return cell;
+}
+function serializeResources(snapshot) {
+  let resources = snapshot.resources;
+  if (!resources || typeof resources != "object")
+    return;
+  let serialized = {};
+  for (let [id, resource] of Object.entries(resources))
+    typeof resource?.name == "string" && (serialized[id] = {
+      name: resource.name,
+      data: resource.data
+    });
+  return Object.keys(serialized).length > 0 ? serialized : void 0;
+}
+function serializeCalculation(snapshot) {
+  for (let resource of Object.values(
+    snapshot.resources ?? {}
+  )) {
+    if (resource?.name !== XLSX_WORKBOOK_CALCULATION_RESOURCE)
+      continue;
+    let data = parseResourceData(resource.data);
+    if (!data || typeof data != "object")
+      return;
+    let fullPrecision = data.fullPrecision;
+    return typeof fullPrecision == "boolean" ? { fullPrecision } : void 0;
+  }
+}
+function serializeTables(snapshot) {
+  for (let resource of Object.values(
+    snapshot.resources ?? {}
+  )) {
+    if (resource?.name !== "SHEET_TABLE_PLUGIN")
+      continue;
+    let data = parseResourceData(resource.data);
+    if (!data || typeof data != "object")
+      return;
+    let tables = {};
+    for (let [sheetId, sheetTables] of Object.entries(data)) {
+      let tableList = sheetTables?.tables;
+      if (Array.isArray(tableList))
+        for (let table of tableList) {
+          let serialized = serializeTableSnapshot(sheetId, table, snapshot);
+          serialized && (tables[serialized.name] = serialized.table);
+        }
+    }
+    return Object.keys(tables).length > 0 ? tables : void 0;
+  }
+}
+function serializeTableSnapshot(sheetId, table, snapshot) {
+  if (!table || typeof table != "object")
+    return null;
+  let record = table, name2 = typeof record.name == "string" ? record.name : void 0, range = record.range;
+  if (!name2 || !range || typeof range.startRow != "number" || typeof range.endRow != "number" || typeof range.startColumn != "number" || typeof range.endColumn != "number")
+    return null;
+  let columns = Array.isArray(record.columns) ? record.columns.map((column) => {
+    let displayName = column?.displayName;
+    return typeof displayName == "string" ? { displayName } : null;
+  }).filter((column) => column != null) : [], showHeader = record.options?.showHeader !== !1, showFooter = typeof record.options?.showFooter == "boolean" ? record.options.showFooter : inferTableFooter(snapshot, sheetId, range.startRow, range.endRow, range.startColumn, range.endColumn);
+  return {
+    name: name2,
+    table: {
+      sheetId,
+      range: {
+        startRow: range.startRow,
+        endRow: range.endRow,
+        startColumn: range.startColumn,
+        endColumn: range.endColumn
+      },
+      columns,
+      showHeader,
+      showFooter
+    }
+  };
+}
+function parseResourceData(data) {
+  if (typeof data != "string")
+    return data;
+  try {
+    return JSON.parse(data || "{}");
+  } catch {
+    return;
+  }
+}
+function inferTableFooter(snapshot, sheetId, startRow, endRow, startColumn, endColumn) {
+  let row = snapshot.sheets?.[sheetId]?.cellData?.[endRow];
+  if (!row)
+    return !1;
+  for (let col = startColumn; col <= endColumn; col++) {
+    let cell = row[col];
+    if (cell && (typeof cell.f == "string" && /\bSUBTOTAL\s*\(/iu.test(cell.f) || col === startColumn && typeof cell.v == "string" && cell.v.trim().toLowerCase() === "total"))
+      return !0;
+  }
+  return !1;
+}
+function serializeExternalLinks(snapshot) {
+  let externalLinks = snapshot.externalLinks, serializedLinks = Array.isArray(externalLinks) ? externalLinks.map((link) => serializeExternalLink(link)).filter((link) => link != null) : [];
+  return serializedLinks.push(...serializeExternalLinksFromResource(snapshot)), serializedLinks.length > 0 ? serializedLinks : void 0;
+}
+function serializeExternalLinksFromResource(snapshot) {
+  let links = [];
+  for (let resource of Object.values(
+    snapshot.resources ?? {}
+  )) {
+    if (resource?.name !== EXTERNAL_DATA_RESOURCE)
+      continue;
+    let data = parseResourceData(resource.data);
+    if (isRecord(data)) {
+      if (data.schemaVersion === 1 && Array.isArray(data.links)) {
+        links.push(
+          ...data.links.map((link) => serializeVersionedExternalLink(link)).filter((link) => link != null)
+        );
+        continue;
+      }
+      if (!(data.signature !== EXTERNAL_DATA_SIGNATURE || !isRecord(data.units)))
+        for (let [unitId, unit] of Object.entries(data.units)) {
+          let link = serializeExternalDataUnit(unitId, unit);
+          link && links.push(link);
+        }
+    }
+  }
+  return links;
+}
+function serializeVersionedExternalLink(link) {
+  if (!isRecord(link) || !Number.isInteger(link.slot) || Number(link.slot) <= 0 || !isRecord(link.target))
+    return null;
+  let target = link.target, cache = isRecord(link.cache) ? link.cache : void 0, cachedSheets = Array.isArray(cache?.sheets) ? cache.sheets.map((sheet) => serializeVersionedExternalSheet(sheet)).filter((sheet) => sheet != null) : [], cachedNames = new Set(cachedSheets.map((sheet) => sheet.name.toLocaleLowerCase())), uncachedSheets = Array.isArray(link.sheetNames) ? link.sheetNames.flatMap((item) => {
+    if (!isRecord(item)) return [];
+    let { name: name2 } = item;
+    return typeof name2 != "string" || cachedNames.has(name2.toLocaleLowerCase()) ? [] : [
+      {
+        name: name2,
+        rowCount: 1048576,
+        columnCount: 16384,
+        cellData: {},
+        coverage: []
+      }
+    ];
+  }) : [], sheets = [...cachedSheets, ...uncachedSheets], definedNames = serializeVersionedExternalDefinedNames(link.definedNames), tables = serializeVersionedExternalTables(link.tables), aliases = [link.name, target.name, target.uri].filter(
+    (alias) => typeof alias == "string" && alias.length > 0
+  );
+  return {
+    ...aliases.length > 0 ? { aliases: [...new Set(aliases)] } : {},
+    ...definedNames ? { definedNames } : {},
+    sheets,
+    ...tables ? { tables } : {},
+    ...typeof target.uri == "string" ? { target: target.uri } : typeof target.name == "string" ? { target: target.name } : typeof link.name == "string" ? { target: link.name } : {},
+    unitId: String(link.slot)
+  };
+}
+function serializeVersionedExternalDefinedNames(value) {
+  if (!Array.isArray(value))
+    return;
+  let result = {};
+  for (let item of value)
+    !isRecord(item) || typeof item.name != "string" || (result[item.name] = {
+      name: item.name,
+      ...typeof item.formulaOrRefString == "string" ? { formulaOrRefString: item.formulaOrRefString } : {}
+    });
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function serializeVersionedExternalTables(value) {
+  if (!Array.isArray(value))
+    return;
+  let result = {};
+  for (let item of value) {
+    if (!isRecord(item) || typeof item.name != "string" || typeof item.sheetName != "string" || !isRange(item.range)) continue;
+    let columns = Array.isArray(item.columns) ? item.columns.flatMap((column) => {
+      if (!isRecord(column)) return [];
+      let { name: name2 } = column;
+      return typeof name2 == "string" ? [{ displayName: name2 }] : [];
+    }) : [];
+    result[item.name] = {
+      sheetId: item.sheetName,
+      range: item.range,
+      columns,
+      showHeader: item.showHeader !== !1
+    };
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function serializeVersionedExternalSheet(sheet) {
+  if (!isRecord(sheet) || typeof sheet.name != "string") return null;
+  let cellData = {};
+  if (Array.isArray(sheet.cells))
+    for (let cell of sheet.cells) {
+      if (!isExternalCell(cell)) continue;
+      let { row, column } = cell;
+      (cellData[row] ??= {})[column] = {
+        v: cell.value,
+        ...typeof cell.valueType == "number" ? { t: cell.valueType } : {}
+      };
+    }
+  return {
+    name: sheet.name,
+    ...typeof sheet.sheetId == "string" ? { sheetId: sheet.sheetId } : {},
+    rowCount: typeof sheet.rowCount == "number" ? sheet.rowCount : 0,
+    columnCount: typeof sheet.columnCount == "number" ? sheet.columnCount : 0,
+    cellData,
+    coverage: Array.isArray(sheet.coverage) ? sheet.coverage.filter(isRange) : []
+  };
+}
+function isRange(value) {
+  return value != null && typeof value == "object" && "startRow" in value && typeof value.startRow == "number" && "endRow" in value && typeof value.endRow == "number" && "startColumn" in value && typeof value.startColumn == "number" && "endColumn" in value && typeof value.endColumn == "number";
+}
+function isRustTableSnapshot(value) {
+  return value != null && typeof value == "object" && "sheetId" in value && typeof value.sheetId == "string" && "range" in value && isRange(value.range) && "columns" in value && Array.isArray(value.columns);
+}
+function isExternalCell(value) {
+  return isRecord(value) && Number.isInteger(value.row) && Number.isInteger(value.column);
+}
+function serializeExternalDataUnit(unitId, unit) {
+  if (!unit || typeof unit != "object")
+    return null;
+  let record = unit;
+  if (!record.sheets || typeof record.sheets != "object")
+    return null;
+  let sheets = Object.values(record.sheets).map((sheet) => serializeExternalSheet(sheet)).filter((sheet) => sheet != null);
+  if (sheets.length === 0)
+    return null;
+  let definedNames = serializeExternalDefinedNames(record.definedNames);
+  return {
+    ...definedNames === void 0 ? {} : { definedNames },
+    sheets,
+    ...typeof record.target == "string" ? { target: record.target } : {},
+    unitId
+  };
+}
+function serializeExternalLink(link) {
+  if (!isRecord(link))
+    return null;
+  let record = link;
+  if (!Array.isArray(record.sheets))
+    return null;
+  let sheets = record.sheets.map((sheet) => serializeExternalSheet(sheet)).filter((sheet) => sheet != null);
+  if (sheets.length === 0)
+    return null;
+  let definedNames = serializeExternalDefinedNames(record.definedNames), tables = serializeExternalTables(record.tables);
+  return {
+    ...definedNames === void 0 ? {} : { definedNames },
+    sheets,
+    ...tables === void 0 ? {} : { tables },
+    ...typeof record.target == "string" ? { target: record.target } : {},
+    ...typeof record.unitId == "string" ? { unitId: record.unitId } : {}
+  };
+}
+function serializeExternalTables(value) {
+  if (!isRecord(value)) return;
+  let result = {};
+  for (let [name2, table] of Object.entries(value))
+    !table || typeof table != "object" || isRustTableSnapshot(table) && (result[name2] = table);
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function serializeExternalDefinedNames(value) {
+  if (!isRecord(value))
+    return;
+  let definedNames = {};
+  for (let [key, item] of Object.entries(value)) {
+    if (!isRecord(item))
+      continue;
+    let record = item, name2 = typeof record.name == "string" ? record.name : key;
+    definedNames[key] = {
+      ...typeof record.id == "string" ? { id: record.id } : {},
+      name: name2,
+      ...typeof record.formulaOrRefString == "string" ? { formulaOrRefString: record.formulaOrRefString } : {},
+      ...typeof record.localSheetId == "string" ? { localSheetId: record.localSheetId } : {}
+    };
+  }
+  return Object.keys(definedNames).length > 0 ? definedNames : void 0;
+}
+function serializeExternalSheet(sheet) {
+  if (!sheet || typeof sheet != "object")
+    return null;
+  let record = sheet;
+  return typeof record.name != "string" ? null : {
+    name: record.name,
+    ...typeof record.sheetId == "string" ? { sheetId: record.sheetId } : {},
+    rowCount: typeof record.rowCount == "number" ? record.rowCount : 0,
+    columnCount: typeof record.columnCount == "number" ? record.columnCount : 0,
+    cellData: serializeCellData(record.cellData)
+  };
+}
+function serializeDefinedNames(definedNames, snapshot) {
+  let direct = definedNames && Object.keys(definedNames).length > 0 ? definedNames : extractDefinedNames(snapshot), sheetIds = new Set(Object.keys(snapshot.sheets ?? {})), sheetNameToId = new Map(
+    Object.entries(snapshot.sheets ?? {}).map(([sheetId, sheet]) => [sheet.name, sheetId])
+  );
+  return Object.fromEntries(
+    Object.entries(direct).map(([id, definedName]) => [
+      id,
+      {
+        id: definedName.id,
+        name: definedName.name,
+        formulaOrRefString: definedName.formulaOrRefString,
+        localSheetId: normalizeDefinedNameLocalSheetId(
+          definedName.localSheetId,
+          definedName.formulaOrRefString,
+          sheetIds,
+          sheetNameToId
+        )
+      }
+    ])
+  );
+}
+function normalizeDefinedNameLocalSheetId(localSheetId, formulaOrRefString, sheetIds, sheetNameToId) {
+  if (!localSheetId || localSheetId === "AllDefaultWorkbook")
+    return localSheetId;
+  let sheetName = extractLeadingSheetName(formulaOrRefString), sheetIdFromFormula = sheetName ? sheetNameToId.get(sheetName) : void 0;
+  return sheetIdFromFormula && sheetIdFromFormula !== localSheetId ? sheetIdFromFormula : sheetIds.has(localSheetId) || !sheetName ? localSheetId : sheetIdFromFormula ?? localSheetId;
+}
+function extractLeadingSheetName(formulaOrRefString) {
+  if (!formulaOrRefString)
+    return;
+  let quotedMatch = /^'((?:[^']|'')+)'!/.exec(formulaOrRefString);
+  return quotedMatch ? quotedMatch[1].replace(/''/g, "'") : /^([^=!]+)!/.exec(formulaOrRefString)?.[1];
+}
+function extractDefinedNames(snapshot) {
+  let direct = snapshot.definedNames;
+  if (direct && Object.keys(direct).length > 0)
+    return direct;
+  for (let resource of Object.values(
+    snapshot.resources ?? {}
+  )) {
+    if (resource?.name !== "SHEET_DEFINED_NAME_PLUGIN")
+      continue;
+    let data = parseResourceData(resource.data);
+    return data && typeof data == "object" ? data : {};
+  }
+  return {};
+}
+function serializeSheetSnapshot(sheetId, sheet, styles, precisionAsDisplayed) {
+  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),
+    rowData: serializeVisibilityData(sheet.rowData),
+    columnData: serializeVisibilityData(sheet.columnData)
+  } : null;
+}
+function serializeCellData(cellData = {}, styles, precisionAsDisplayed = !1) {
+  let result = {}, rawCellData = cellData instanceof ObjectMatrix ? cellData.getData() : cellData;
+  for (let [rowKey, row] of Object.entries(rawCellData ?? {})) {
+    if (!row)
+      continue;
+    let serializedRow = {};
+    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" && (value.ref = cellRecord.ref), 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);
+        displayPrecision !== void 0 && (value.displayPrecision = displayPrecision);
+      }
+      Object.keys(value).length > 0 && (serializedRow[Number(colKey)] = value);
+    }
+    Object.keys(serializedRow).length > 0 && (result[Number(rowKey)] = serializedRow);
+  }
+  return result;
+}
+function serializeCellDataInRanges(cellData, ranges) {
+  let serialized = serializeCellData(cellData), result = {};
+  for (let [rowKey, row] of Object.entries(serialized)) {
+    let rowIndex = Number(rowKey);
+    for (let [columnKey, value] of Object.entries(row)) {
+      let columnIndex = Number(columnKey);
+      ranges.some(
+        (range) => rowIndex >= range.startRow && rowIndex <= range.endRow && columnIndex >= range.startColumn && columnIndex <= range.endColumn
+      ) && ((result[rowIndex] ??= {})[columnIndex] = value);
+    }
+  }
+  return result;
+}
+function inferDisplayPrecision(styleId, styles) {
+  if (typeof styleId != "string" || !styles || typeof styles != "object")
+    return;
+  let style = styles[styleId];
+  if (!style || typeof style != "object")
+    return;
+  let numberFormat = style.n;
+  if (!numberFormat || typeof numberFormat != "object")
+    return;
+  let pattern = numberFormat.pattern;
+  return typeof pattern == "string" ? inferFixedNumberFormatPrecision(pattern) : void 0;
+}
+function inferFixedNumberFormatPrecision(pattern) {
+  let cleaned = (pattern.split(";")[0] ?? pattern).replace(/"[^"]*"/gu, "").replace(/\\./gu, "").replace(/_.|\*./gu, "");
+  if (!/[0#?]/u.test(cleaned) || /[%Ee]|[ymdhsa]/iu.test(cleaned))
+    return;
+  let decimalMatch = cleaned.match(/\.([0#?]+)/u);
+  return decimalMatch?.[1] ? decimalMatch[1].length : 0;
+}
+function serializeVisibilityData(data = {}) {
+  let result = {};
+  for (let [indexKey, metadata] of Object.entries(data))
+    !metadata || typeof metadata != "object" || !("hd" in metadata) || (result[Number(indexKey)] = {
+      hd: metadata.hd
+    });
+  return result;
+}
+function errorToFormulaCalculationError(code, error) {
+  return {
+    code,
+    message: error instanceof Error ? error.message : String(error)
+  };
+}
+function isRecord(value) {
+  return typeof value == "object" && value !== null && !Array.isArray(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);
+}
+function summarizeObjectMatrixPayload(value) {
+  if (!value || typeof value != "object")
+    return {};
+  let cellValueCells = 0;
+  for (let row of Object.values(value))
+    !row || typeof row != "object" || (cellValueCells += Object.keys(row).length);
+  return {
+    cellValueRows: Object.keys(value).length,
+    cellValueCells
+  };
+}
+function hasObjectMatrixValues(value) {
+  return !value || typeof value != "object" ? !1 : Object.values(value).some(
+    (row) => row != null && typeof row == "object" && Object.keys(row).length > 0
+  );
+}
+function hasRecordEntries(value) {
+  return value != null && typeof value == "object" && Object.keys(value).length > 0;
+}
+function countDisplayPrecisionCells(snapshot) {
+  let count = 0;
+  for (let workbook of snapshot.workbooks)
+    for (let sheet of workbook.sheets)
+      for (let row of Object.values(sheet.cellData))
+        for (let cell of Object.values(row))
+          typeof cell.displayPrecision == "number" && (count += 1);
+  return count;
+}
+var RustEngineSyncController = class extends Disposable {
+  constructor(_commandService) {
+    super();
+    this._commandService = _commandService;
+    this._initialize();
+  }
+  _commandService;
+  _nativeReady = !1;
+  _snapshotLoaded = !1;
+  _projectionLoadPromise = null;
+  _pendingMutations = [];
+  _initialize() {
+    this.disposeWithMe(
+      this._commandService.onCommandExecuted((command, options) => {
+        this._shouldSyncMutation(command, options) && this._queueOrSyncMutation(this._serializeMutation(command, options));
+      })
+    );
+  }
+  async loadProjection(workbooks) {
+    let loadPromise = this._loadProjection(workbooks);
+    this._projectionLoadPromise = loadPromise;
+    try {
+      await loadPromise;
+    } finally {
+      this._projectionLoadPromise === loadPromise && (this._projectionLoadPromise = null);
+    }
+  }
+  async waitForProjectionLoad() {
+    await this._projectionLoadPromise;
+  }
+  async _loadProjection(workbooks) {
+    await loadNativeBinding(), this._nativeReady = !0;
+    let serializeStartedAt = performance.now(), snapshot = serializeRuntimeWorkbookSnapshots(workbooks);
+    this._loadSerializedSnapshot(snapshot, performance.now() - serializeStartedAt);
+  }
+  applyProjectionMutation(mutation) {
+    this._queueOrSyncMutation(mutation);
+  }
+  upsertReferenceData(config, needs) {
+    let mutations = createReferenceDataUpsertMutations(config, needs);
+    return mutations.forEach((mutation) => this._queueOrSyncMutation(mutation)), mutations.length;
+  }
+  disposeProjectionWorkbook(unitId) {
+    if (!(!this._nativeReady || !this._snapshotLoaded))
+      try {
+        disposeWorkbookOnRust(unitId), markRustFormulaDependenciesInvalidated();
+      } catch {
+        this._markProjectionDesynced();
+      }
+  }
+  dispose() {
+    if (super.dispose(), this._pendingMutations.length = 0, this._projectionLoadPromise = null, !this._nativeReady) {
+      this._snapshotLoaded = !1;
+      return;
+    }
+    try {
+      disposeAllWorkbooksOnRust();
+    } catch {
+      this._markProjectionDesynced();
+      return;
+    }
+    this._nativeReady = !1, this._snapshotLoaded = !1;
+  }
+  _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;
+    try {
+      nativeTimings = JSON.parse(nativeOutput).timingsMs;
+    } catch {
+      nativeTimings = void 0;
+    }
+    emitRustEngineSyncDebugEvent({
+      type: "loadSnapshot",
+      payload: {
+        workbookCount: snapshot.workbooks.length,
+        serializeMs,
+        stringifyMs,
+        nativeMs,
+        precisionAsDisplayedWorkbookCount,
+        displayPrecisionCellCount,
+        snapshotBytes: snapshotBuffer?.byteLength ?? snapshotJson.length,
+        transport: snapshotBuffer ? "binary-json" : "string-json",
+        nativeTimings
+      }
+    }), this._pendingMutations.splice(0, pendingCountCoveredBySnapshot), this._snapshotLoaded = !0, markRustSnapshotLoaded(), this._flushPendingMutations();
+  }
+  _queueOrSyncMutation(mutation) {
+    if (!this._nativeReady || !this._snapshotLoaded) {
+      this._pendingMutations.push(mutation);
+      return;
+    }
+    this._syncMutation(mutation);
+  }
+  _flushPendingMutations() {
+    for (; this._pendingMutations.length > 0; ) {
+      let mutation = this._pendingMutations.shift();
+      mutation && this._syncMutation(mutation);
+    }
+  }
+  _syncMutation(mutation) {
+    let totalStartedAt = performance.now(), stringifyStartedAt = performance.now(), payload = JSON.stringify(mutation), stringifyMs = performance.now() - stringifyStartedAt, nativeStartedAt = performance.now();
+    try {
+      applyMutationOnRust(payload), isRustIncrementalDependencyMutation(mutation.id) || markRustFormulaDependenciesInvalidated();
+    } catch {
+      this._markProjectionDesynced();
+    } finally {
+      emitRustEngineSyncDebugEvent({
+        type: "applyMutation",
+        payload: {
+          id: mutation.id,
+          stringifyMs,
+          nativeMs: performance.now() - nativeStartedAt,
+          totalMs: performance.now() - totalStartedAt,
+          ...summarizeObjectMatrixPayload(
+            mutation.params?.cellValue
+          )
+        }
+      });
+    }
+  }
+  _markProjectionDesynced() {
+    this._nativeReady = !1, this._snapshotLoaded = !1;
+  }
+  _shouldSyncMutation(command, options) {
+    if (command.type !== CommandType.MUTATION || !isRustFormulaRelevantMutation(command.id))
+      return !1;
+    let syncOptions = options;
+    if (syncOptions?.fromRustFormulaEngine === !0 || syncOptions?.applyFormulaCalculationResult === !0 || command.id === "sheet.mutation.set-range-values" && !hasObjectMatrixValues(command.params?.cellValue))
+      return !1;
+    if (command.id === "formula.mutation.set-formula-calculation-result") {
+      let params = command.params;
+      if (!hasRecordEntries(params?.unitData) && !hasRecordEntries(params?.unitOtherData))
+        return !1;
+    }
+    if (command.id === "formula.mutation.set-array-formula-data") {
+      let params = command.params;
+      if (!hasRecordEntries(params?.arrayFormulaRange) && !hasRecordEntries(params?.arrayFormulaCellData) && !hasRecordEntries(params?.arrayFormulaEmbedded))
+        return !1;
+    }
+    return !0;
+  }
+  _serializeMutation(command, options) {
+    let dirtyRanges = options?.dirtyRanges;
+    return {
+      id: command.id,
+      params: command.params ?? {},
+      dirtyRanges: Array.isArray(dirtyRanges) ? dirtyRanges : []
+    };
+  }
+};
+setDependencies(RustEngineSyncController, [ICommandService]);
+
+// src/numfmt.ts
+var nativeBindingReady = null;
+function ensureNativeBinding() {
+  return nativeBindingReady ??= loadNativeBinding().catch((error) => {
+    throw nativeBindingReady = null, error;
+  }), nativeBindingReady;
+}
+function parseJsonOutput(output) {
+  return JSON.parse(output);
+}
+async function formatNumberBatch(input) {
+  return await ensureNativeBinding(), parseJsonOutput(formatNumberBatchOnRust(JSON.stringify(input)));
+}
+async function parseNumberFormatBatch(input) {
+  return await ensureNativeBinding(), parseJsonOutput(parseNumberFormatInputBatchOnRust(JSON.stringify(input)));
+}
+async function parseNumberFormatMatrixBatch(input) {
+  return await ensureNativeBinding(), parseJsonOutput(
+    parseNumberFormatMatrixBatchOnRust(JSON.stringify(input))
+  );
+}
+async function analyzeNumberFormatBatch(input) {
+  return await ensureNativeBinding(), parseJsonOutput(analyzeNumberFormatBatchOnRust(JSON.stringify(input)));
+}
+
+// src/plugin.ts
+import { IConfigService as IConfigService2, Injector, setDependencies as setDependencies4, touchDependencies } from "@univerjs/core";
+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-insiders.20260725-1b9c8d8";
+
+// src/controllers/rust-same-runtime-projection.controller.ts
+import {
+  Disposable as Disposable2,
+  CommandType as CommandType2,
+  ICommandService as ICommandService2,
+  IUniverInstanceService,
+  LocaleType,
+  setDependencies as setDependencies2,
+  toDisposable,
+  UniverInstanceType
+} from "@univerjs/core";
+import { FormulaDataModel, ISuperTableService, SetFormulaCalculationResultMutation } from "@univerjs/engine-formula";
+var RustSameRuntimeProjectionController = class extends Disposable2 {
+  constructor(_univerInstanceService, _rustEngineSyncController, _formulaDataModel, _superTableService, _commandService) {
+    super();
+    this._univerInstanceService = _univerInstanceService;
+    this._rustEngineSyncController = _rustEngineSyncController;
+    this._formulaDataModel = _formulaDataModel;
+    this._superTableService = _superTableService;
+    this._commandService = _commandService;
+    this._initialize();
+  }
+  _univerInstanceService;
+  _rustEngineSyncController;
+  _formulaDataModel;
+  _superTableService;
+  _commandService;
+  _projectionReload = null;
+  _projectionReloadRequested = !1;
+  _initialize() {
+    this._scheduleProjectionReload(), this.disposeWithMe(
+      toDisposable(
+        this._univerInstanceService.getTypeOfUnitAdded$(UniverInstanceType.UNIVER_SHEET).subscribe(() => {
+          this._scheduleProjectionReload();
+        })
+      )
+    ), this.disposeWithMe(
+      toDisposable(
+        this._univerInstanceService.getTypeOfUnitAdded$(UniverInstanceType.UNIVER_BASE).subscribe(() => {
+          this._scheduleProjectionReload();
+        })
+      )
+    ), this.disposeWithMe(
+      this._commandService.onCommandExecuted((command) => {
+        command.type !== CommandType2.MUTATION || !hasUnitId(command.params) || this._univerInstanceService.getUnit(command.params.unitId, UniverInstanceType.UNIVER_BASE) && (hasTrigger(command.params) && command.params.trigger === SetFormulaCalculationResultMutation.id || this._scheduleProjectionReload());
+      })
+    ), this.disposeWithMe(
+      toDisposable(
+        this._univerInstanceService.getTypeOfUnitDisposed$(UniverInstanceType.UNIVER_BASE).subscribe((base) => {
+          this._rustEngineSyncController.disposeProjectionWorkbook(base.getUnitId());
+        })
+      )
+    ), this.disposeWithMe(
+      toDisposable(
+        this._univerInstanceService.getTypeOfUnitDisposed$(UniverInstanceType.UNIVER_SHEET).subscribe((workbook) => {
+          this._rustEngineSyncController.disposeProjectionWorkbook(workbook.getUnitId());
+        })
+      )
+    );
+  }
+  _scheduleProjectionReload() {
+    this._projectionReloadRequested = !0, !this._projectionReload && (this._projectionReload = this._drainProjectionReloads().finally(() => {
+      this._projectionReload = null, this._projectionReloadRequested && this._scheduleProjectionReload();
+    }));
+  }
+  async _drainProjectionReloads() {
+    for (; this._projectionReloadRequested; )
+      this._projectionReloadRequested = !1, await this._loadAllWorkbookProjections();
+  }
+  async _loadAllWorkbookProjections() {
+    let workbooks = this._univerInstanceService.getAllUnitsForType(UniverInstanceType.UNIVER_SHEET).map((workbook) => ({
+      unitId: workbook.getUnitId(),
+      snapshot: workbook.getSnapshot()
+    })), calculationData = this._formulaDataModel.getCalculateData(), formulaData = this._formulaDataModel.getFormulaData(), baseWorkbooks = this._univerInstanceService.getAllUnitsForType(UniverInstanceType.UNIVER_BASE).map(
+      (base) => this._createBaseWorkbookProjection(
+        base.getUnitId(),
+        calculationData.allUnitData,
+        calculationData.unitSheetNameMap,
+        calculationData.unitNameMap ?? {},
+        formulaData
+      )
+    ).filter((workbook) => workbook != null);
+    workbooks.push(...baseWorkbooks), await this._rustEngineSyncController.loadProjection(workbooks);
+  }
+  _createBaseWorkbookProjection(unitId, allUnitData, unitSheetNameMap, unitNameMap, formulaData) {
+    let unitData = allUnitData[unitId];
+    if (!unitData) return null;
+    let sheetNameMap = unitSheetNameMap[unitId] ?? {}, sheetOrder = Object.keys(unitData), resources = this._createBaseTableResource(unitId), sheets = {};
+    for (let sheetId of sheetOrder) {
+      let sheet = unitData[sheetId];
+      if (!sheet) continue;
+      let cellData = this._rawCellData(sheet.cellData);
+      for (let [rowKey, row] of Object.entries(formulaData[unitId]?.[sheetId] ?? {}))
+        for (let [columnKey, formula] of Object.entries(row ?? {})) {
+          if (!formula) continue;
+          let rowIndex = Number(rowKey), columnIndex = Number(columnKey), current = cellData[rowIndex]?.[columnIndex] ?? {};
+          (cellData[rowIndex] ??= {})[columnIndex] = { ...current, ...formula };
+        }
+      sheets[sheetId] = {
+        id: sheetId,
+        name: Object.entries(sheetNameMap).find(([, currentSheetId]) => currentSheetId === sheetId)?.[0] ?? sheetId,
+        rowCount: sheet.rowCount,
+        columnCount: sheet.columnCount,
+        cellData,
+        rowData: sheet.rowData,
+        columnData: sheet.columnData
+      };
+    }
+    return {
+      unitId,
+      snapshot: {
+        id: unitId,
+        name: unitNameMap[unitId]?.name ?? unitId,
+        appVersion: "",
+        locale: LocaleType.EN_US,
+        styles: {},
+        sheetOrder,
+        sheets,
+        resources
+      }
+    };
+  }
+  _createBaseTableResource(unitId) {
+    let tableMap = this._superTableService.getTableMap(unitId);
+    if (!tableMap) return [];
+    let data = {};
+    for (let [name2, table] of tableMap) {
+      let columns = Array.from(table.titleMap.entries()).toSorted((left, right) => left[1] - right[1]).map(([displayName]) => ({ displayName }));
+      (data[table.sheetId] ??= { tables: [] }).tables.push({
+        name: name2,
+        range: table.range,
+        columns,
+        options: { showHeader: table.showHeader !== !1 }
+      });
+    }
+    return [
+      {
+        name: "SHEET_TABLE_PLUGIN",
+        data: JSON.stringify(data)
+      }
+    ];
+  }
+  _rawCellData(cellData) {
+    let raw = cellData.getData(), result = {};
+    for (let [row, values] of Object.entries(raw ?? {})) {
+      let rowData = {};
+      for (let [column, value] of Object.entries(values ?? {}))
+        value && (rowData[Number(column)] = { ...value });
+      result[Number(row)] = rowData;
+    }
+    return result;
+  }
+};
+function hasUnitId(value) {
+  return value != null && typeof value == "object" && "unitId" in value && typeof value.unitId == "string";
+}
+function hasTrigger(value) {
+  return "trigger" in value && typeof value.trigger == "string";
+}
+setDependencies2(RustSameRuntimeProjectionController, [
+  IUniverInstanceService,
+  RustEngineSyncController,
+  FormulaDataModel,
+  ISuperTableService,
+  ICommandService2
+]);
+
+// src/services/calculate-formula.service.ts
+import {
+  AsyncLock,
+  createIdentifier,
+  Disposable as Disposable3,
+  ICommandService as ICommandService3,
+  IConfigService,
+  setDependencies as setDependencies3
+} from "@univerjs/core";
+import {
+  ENGINE_FORMULA_PLUGIN_CONFIG_KEY,
+  FormulaExecuteStageType,
+  IFeatureCalculationManagerService,
+  IFormulaCurrentConfigService,
+  IFormulaDependencyGenerator,
+  IFormulaRuntimeService,
+  IOtherFormulaManagerService,
+  SetFormulaCalculationResultMutation as SetFormulaCalculationResultMutation2
+} from "@univerjs/engine-formula";
+import { ExternalReferencePrefetchPlanner, ExternalReferencePrefetchService } from "@univerjs-pro/engine-formula";
+import { Subject } from "rxjs";
+var IRustCalculateFormulaService = createIdentifier(
+  "engine-formula-rust.calculate-formula.service"
+), DEFAULT_INTERVAL_COUNT = 500, MAX_FEATURE_CALCULATION_PASSES = 8, MAX_EXTERNAL_REFERENCE_PASSES = 8, FORMULA_TREE_TYPE_NORMAL = 0, FORMULA_TREE_TYPE_OTHER = 1, FORMULA_TREE_TYPE_FEATURE = 2;
+function emitRustFormulaDebugEvent(event) {
+  let hook = globalThis.__UNIVER_RUST_FORMULA_DEBUG_HOOK__;
+  typeof hook == "function" && hook(event);
+}
+function firstResultBatchValue(output) {
+  return output.resultBatches?.find((batch) => batch.values.length > 0)?.values[0];
+}
+function resultBatchSheetCounts(output) {
+  let counts = {};
+  for (let batch of output.resultBatches ?? []) {
+    let key = `${batch.unitId}/${batch.sheetId}`;
+    counts[key] = (counts[key] ?? 0) + batch.values.length;
+  }
+  return counts;
+}
+function rustExecutionOutputToCalculationResult(output) {
+  let patch = rustExecutionOutputToFormulaCalculationPatch(output);
+  return {
+    unitData: patch.unitData,
+    unitOtherData: patch.unitOtherData
+  };
+}
+var RustCalculateFormulaService = class extends Disposable3 {
+  constructor(_configService, _currentConfigService, _runtimeService, _formulaDependencyGenerator, _featureCalculationManagerService, _otherFormulaManagerService, _commandService, _rustEngineSyncController, _externalPrefetchPlanner, _externalPrefetchService) {
+    super();
+    this._configService = _configService;
+    this._currentConfigService = _currentConfigService;
+    this._runtimeService = _runtimeService;
+    this._formulaDependencyGenerator = _formulaDependencyGenerator;
+    this._featureCalculationManagerService = _featureCalculationManagerService;
+    this._otherFormulaManagerService = _otherFormulaManagerService;
+    this._commandService = _commandService;
+    this._rustEngineSyncController = _rustEngineSyncController;
+    this._externalPrefetchPlanner = _externalPrefetchPlanner;
+    this._externalPrefetchService = _externalPrefetchService;
+    this._commandService.hasCommand(SetFormulaCalculationResultMutation2.id) || this.disposeWithMe(this._commandService.registerCommand(SetFormulaCalculationResultMutation2));
+  }
+  _configService;
+  _currentConfigService;
+  _runtimeService;
+  _formulaDependencyGenerator;
+  _featureCalculationManagerService;
+  _otherFormulaManagerService;
+  _commandService;
+  _rustEngineSyncController;
+  _externalPrefetchPlanner;
+  _externalPrefetchService;
+  _executionInProgressListener$ = new Subject();
+  executionInProgressListener$ = this._executionInProgressListener$.asObservable();
+  _executionCompleteListener$ = new Subject();
+  executionCompleteListener$ = this._executionCompleteListener$.asObservable();
+  _executeLock = new AsyncLock();
+  _nativeLoaded = !1;
+  _syncedSnapshotEpoch = -1;
+  _syncedDependencyInvalidationEpoch = -1;
+  _externalFormulaDatasetConfig;
+  dispose() {
+    super.dispose(), this._executionInProgressListener$.complete(), this._executionCompleteListener$.complete();
+  }
+  stopFormulaExecution() {
+    this._runtimeService.stopExecution();
+  }
+  setRuntimeFeatureCellData(featureId, featureData) {
+    this._runtimeService.setRuntimeFeatureCellData(featureId, featureData);
+  }
+  setRuntimeFeatureRange(featureId, featureRange) {
+    this._runtimeService.setRuntimeFeatureRange(featureId, featureRange);
+  }
+  async execute(formulaDatasetConfig) {
+    this._nativeLoaded || (await loadNativeBinding(), this._nativeLoaded = !0), await this._rustEngineSyncController.waitForProjectionLoad(), this._externalFormulaDatasetConfig = formulaDatasetConfig, await this._prefetchStaticExternalReferences(formulaDatasetConfig), this._runtimeService.setFormulaExecuteStage(FormulaExecuteStageType.START), this._executionInProgressListener$.next(this._runtimeService.getRuntimeState()), this._currentConfigService.load(formulaDatasetConfig), 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(), 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;
+    output = await this._resolveExternalReferenceNeeds(output, maxIteration);
+    let applyStartedAt = performance.now(), applyBreakdown = await this._applyRustDependencyOutput(output), applyMs = performance.now() - applyStartedAt;
+    if (emitRustFormulaDebugEvent({
+      type: "executeDirtyFormulas",
+      payload: {
+        calculatedNodeCount: output.calculatedNodeCount,
+        hasCycle: output.hasCycle,
+        cycleIterationCount: output.cycleIterationCount,
+        parallelBatchCount: output.parallelBatchCount,
+        parallelNodeCount: output.parallelNodeCount,
+        errorCount: output.errors.length,
+        resultBatchCount: output.resultBatches?.length ?? 0,
+        firstResultBatchValue: firstResultBatchValue(output),
+        resultBatchSheetCounts: resultBatchSheetCounts(output),
+        timings: output.timings,
+        functionProfile: output.functionProfile,
+        bridgeTimings: {
+          nativeAndSerializeMs,
+          outputBytes: outputJson.length,
+          parseMs,
+          applyMs,
+          applyConvertMs: applyBreakdown.convertMs,
+          applyCommandMs: applyBreakdown.commandMs
+        }
+      }
+    }), syncedFeatures.length > 0)
+      for (let pass = 0; pass < MAX_FEATURE_CALCULATION_PASSES; pass++) {
+        let refreshedFeatures = this._syncRustFormulaDependencyDefinitions(), changedFeatures = refreshedFeatures.filter(
+          (feature) => previousFeatureSignatures.get(this._featureKey(feature)) !== feature.signature
+        );
+        if (changedFeatures.length === 0)
+          break;
+        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({
+          type: "executeDirtyFormulas",
+          payload: {
+            calculatedNodeCount: output.calculatedNodeCount,
+            hasCycle: output.hasCycle,
+            cycleIterationCount: output.cycleIterationCount,
+            parallelBatchCount: output.parallelBatchCount,
+            parallelNodeCount: output.parallelNodeCount,
+            errorCount: output.errors.length,
+            resultBatchCount: output.resultBatches?.length ?? 0,
+            firstResultBatchValue: firstResultBatchValue(output),
+            resultBatchSheetCounts: resultBatchSheetCounts(output),
+            timings: output.timings,
+            functionProfile: output.functionProfile,
+            bridgeTimings: {
+              nativeAndSerializeMs,
+              outputBytes: outputJson.length,
+              parseMs,
+              applyMs,
+              applyConvertMs: applyBreakdown.convertMs,
+              applyCommandMs: applyBreakdown.commandMs
+            }
+          }
+        }), previousFeatureSignatures = this._featureSignatureMap(refreshedFeatures);
+      }
+    return calculatedNodeCount;
+  }
+  async _prefetchStaticExternalReferences(config) {
+    let requests = this._externalPrefetchPlanner.plan(config);
+    if (requests.length === 0) return;
+    let result = await this._externalPrefetchService.prefetch(requests, config);
+    result.dirtyRanges.length > 0 && this._rustEngineSyncController.upsertReferenceData(config, result.dirtyRanges);
+  }
+  async _resolveExternalReferenceNeeds(initialOutput, maxIteration) {
+    let config = this._externalFormulaDatasetConfig;
+    if (!config) return initialOutput;
+    let output = initialOutput;
+    for (let pass = 0; pass < MAX_EXTERNAL_REFERENCE_PASSES; pass++) {
+      let needs = output.needsData ?? [];
+      if (needs.length === 0) break;
+      let requests = /* @__PURE__ */ new Map();
+      for (let [hostUnitId, references] of this._groupExternalReferenceNeeds(config, needs))
+        for (let request of this._externalPrefetchPlanner.planDynamic(hostUnitId, references))
+          requests.set(`${request.hostUnitId}\0${request.bindingSlot}`, request);
+      if (requests.size === 0) break;
+      let result = await this._externalPrefetchService.prefetch(Array.from(requests.values()), config), upsertCount = this._rustEngineSyncController.upsertReferenceData(config, needs);
+      if (result.dirtyRanges.length === 0 || upsertCount === 0) break;
+      output = JSON.parse(executeDirtyFormulasOnRust(maxIteration, !1, !1, !0));
+    }
+    return output;
+  }
+  _groupExternalReferenceNeeds(config, needs) {
+    let grouped = /* @__PURE__ */ new Map();
+    for (let need of needs) {
+      let hostUnitId = this._hostUnitIdFromSynthetic(need.unitId);
+      if (!hostUnitId) continue;
+      let sheetNameMap = config.unitSheetNameMap?.[need.unitId] ?? {}, sheetName = Object.entries(sheetNameMap).find(([, sheetId]) => sheetId === need.sheetId)?.[0] ?? need.sheetId, references = grouped.get(hostUnitId) ?? [];
+      references.push({ unitId: need.unitId, sheetName, range: need.range }), grouped.set(hostUnitId, references);
+    }
+    return grouped;
+  }
+  _hostUnitIdFromSynthetic(unitId) {
+    if (!unitId.startsWith("external:")) return;
+    let separator = unitId.lastIndexOf(":");
+    if (!(separator <= 9 || !/^\d+$/.test(unitId.slice(separator + 1))))
+      try {
+        return decodeURIComponent(unitId.slice(9, separator));
+      } catch {
+        return;
+      }
+  }
+  _buildRustInput() {
+    let unitData = this._currentConfigService.getUnitData(), formulaData = this._currentConfigService.getFormulaData(), dirtyRanges = this._currentConfigService.getDirtyRanges(), config = this._configService.getConfig(ENGINE_FORMULA_PLUGIN_CONFIG_KEY);
+    return {
+      config: {
+        maxIteration: config?.maxIteration ?? 1,
+        intervalCount: config?.intervalCount ?? DEFAULT_INTERVAL_COUNT
+      },
+      formulaData: this._serializeFormulaData(formulaData),
+      unitData: this._serializeUnitData(unitData),
+      dirtyRanges: dirtyRanges || [],
+      definedNames: {}
+    };
+  }
+  _syncRustFormulaDependencies(dirtyUnitFeatureMapOverride) {
+    let syncState = getRustEngineSyncState(), rebuildSheetFormulas = this._syncedSnapshotEpoch !== syncState.snapshotEpoch || this._syncedDependencyInvalidationEpoch !== syncState.dependencyInvalidationEpoch, collectStartedAt = performance.now(), state = this._collectRustFormulaDependencySyncState(), collectMs = performance.now() - collectStartedAt;
+    if (!(rebuildSheetFormulas || state.featureCalculations.length > 0 || state.otherFormulas.length > 0))
+      return emitRustFormulaDebugEvent({
+        type: "syncDependencies",
+        payload: {
+          rebuildSheetFormulas,
+          skipped: !0,
+          featureCalculationCount: 0,
+          otherFormulaCount: 0,
+          syncedFeatureCount: 0,
+          timings: {
+            collectMs,
+            stringifyMs: 0,
+            nativeMs: 0,
+            parseMs: 0,
+            totalMs: collectMs
+          }
+        }
+      }), this._markRustFormulaDirty(state.dirtyData, dirtyUnitFeatureMapOverride, rebuildSheetFormulas), state.syncedFeatures;
+    let stringifyStartedAt = performance.now(), inputJson = JSON.stringify({
+      rebuildSheetFormulas,
+      featureCalculations: state.featureCalculations,
+      otherFormulas: state.otherFormulas
+    }), 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;
+    return emitRustFormulaDebugEvent({
+      type: "syncDependencies",
+      payload: {
+        rebuildSheetFormulas,
+        skipped: !1,
+        featureCalculationCount: state.featureCalculations.length,
+        otherFormulaCount: state.otherFormulas.length,
+        syncedFeatureCount: state.syncedFeatures.length,
+        timings: {
+          collectMs,
+          stringifyMs,
+          nativeMs,
+          parseMs,
+          totalMs: collectMs + stringifyMs + nativeMs + parseMs,
+          rust: output.timings
+        }
+      }
+    }), rebuildSheetFormulas && (this._syncedSnapshotEpoch = syncState.snapshotEpoch, this._syncedDependencyInvalidationEpoch = syncState.dependencyInvalidationEpoch), this._markRustFormulaDirty(state.dirtyData, dirtyUnitFeatureMapOverride, rebuildSheetFormulas), state.syncedFeatures;
+  }
+  _syncRustFormulaDependencyDefinitions() {
+    let state = this._collectRustFormulaDependencySyncState();
+    return syncRustFormulaDependenciesOnRust(
+      JSON.stringify({
+        rebuildSheetFormulas: !1,
+        featureCalculations: state.featureCalculations,
+        otherFormulas: state.otherFormulas
+      })
+    ), state.syncedFeatures;
+  }
+  _collectRustFormulaDependencySyncState() {
+    let featureCalculations = [], syncedFeatures = [], dirtyData = this._currentConfigService.getDirtyData(), runtimeData = this._runtimeService.getAllRuntimeData();
+    this._featureCalculationManagerService.getReferenceExecutorMap().forEach((sheetMap) => {
+      sheetMap.forEach((featureMap) => {
+        featureMap.forEach((params, featureId) => {
+          let { runtimeCellData, dirtyRanges: featureDirtyRanges } = params.getDirtyData(
+            dirtyData,
+            runtimeData
+          ), serializedDirtyRanges = this._serializeFeatureDirtyRanges(featureDirtyRanges), serializedRuntimeCellData = this._serializeRuntimeFeatureCellData(runtimeCellData);
+          this._runtimeService.setRuntimeFeatureCellData(featureId, runtimeCellData), this._runtimeService.setRuntimeFeatureRange(featureId, featureDirtyRanges), featureCalculations.push({
+            unitId: params.unitId,
+            sheetId: params.subUnitId,
+            featureId,
+            dependencyRanges: params.dependencyRanges.map((range) => ({
+              unitId: range.unitId,
+              sheetId: range.sheetId,
+              startRow: range.range.startRow,
+              endRow: range.range.endRow,
+              startColumn: range.range.startColumn,
+              endColumn: range.range.endColumn
+            })),
+            dirtyRanges: serializedDirtyRanges,
+            runtimeCellData: serializedRuntimeCellData
+          }), syncedFeatures.push({
+            unitId: params.unitId,
+            sheetId: params.subUnitId,
+            featureId,
+            signature: JSON.stringify({
+              dirtyRanges: serializedDirtyRanges,
+              runtimeCellData: serializedRuntimeCellData
+            })
+          });
+        });
+      });
+    });
+    let otherFormulas = [], otherFormulaData = this._otherFormulaManagerService.getOtherFormulaData();
+    return Object.entries(otherFormulaData).forEach(([unitId, sheetMap]) => {
+      sheetMap && Object.entries(sheetMap).forEach(([sheetId, formulaMap]) => {
+        formulaMap && Object.entries(formulaMap).forEach(([formulaId, item]) => {
+          item && otherFormulas.push({
+            unitId,
+            sheetId,
+            formulaId,
+            formula: item.f,
+            ranges: item.ranges
+          });
+        });
+      });
+    }), { dirtyData, featureCalculations, otherFormulas, syncedFeatures };
+  }
+  _markRustFormulaDirty(dirtyData, dirtyUnitFeatureMapOverride, forceCalculationOverride = !1) {
+    let payload = {
+      forceCalculation: forceCalculationOverride || dirtyData.forceCalculation,
+      includeDirtyNodes: !1,
+      includeCalculationOrder: !1,
+      dirtyRanges: (dirtyData.dirtyRanges ?? []).map((range) => ({
+        unitId: range.unitId,
+        sheetId: range.sheetId,
+        startRow: range.range.startRow,
+        endRow: range.range.endRow,
+        startColumn: range.range.startColumn,
+        endColumn: range.range.endColumn
+      })),
+      dirtyUnitFeatureMap: dirtyUnitFeatureMapOverride ?? dirtyData.dirtyUnitFeatureMap,
+      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;
+    try {
+      rustTimings = JSON.parse(outputJson).timings;
+    } catch {
+      rustTimings = void 0;
+    }
+    emitRustFormulaDebugEvent({
+      type: "markDirty",
+      payload: {
+        ...payload,
+        timings: {
+          stringifyMs,
+          nativeMs,
+          totalMs: stringifyMs + nativeMs
+        },
+        rustTimings
+      }
+    });
+  }
+  _dirtyFeatureMapFor(features) {
+    let dirtyMap = {};
+    return features.forEach(({ unitId, sheetId, featureId }) => {
+      dirtyMap[unitId] = dirtyMap[unitId] ?? {}, dirtyMap[unitId][sheetId] = dirtyMap[unitId][sheetId] ?? {}, dirtyMap[unitId][sheetId][featureId] = !0;
+    }), dirtyMap;
+  }
+  _featureKey(feature) {
+    return `${feature.unitId}\0${feature.sheetId}\0${feature.featureId}`;
+  }
+  _featureSignatureMap(features) {
+    return new Map(features.map((feature) => [this._featureKey(feature), feature.signature]));
+  }
+  _serializeFeatureDirtyRanges(dirtyRanges) {
+    let serialized = [];
+    return Object.entries(dirtyRanges).forEach(([unitId, sheetMap]) => {
+      sheetMap && Object.entries(sheetMap).forEach(([sheetId, ranges]) => {
+        ranges && ranges.forEach((range) => {
+          serialized.push({
+            unitId,
+            sheetId,
+            startRow: range.startRow,
+            endRow: range.endRow,
+            startColumn: range.startColumn,
+            endColumn: range.endColumn
+          });
+        });
+      });
+    }), serialized;
+  }
+  _serializeRuntimeFeatureCellData(runtimeCellData) {
+    let result = {};
+    return Object.entries(runtimeCellData ?? {}).forEach(([unitId, sheetMap]) => {
+      if (!sheetMap) return;
+      let unitData = {};
+      result[unitId] = unitData, Object.entries(sheetMap).forEach(([sheetId, matrix]) => {
+        if (!matrix) return;
+        let sheetData = {};
+        unitData[sheetId] = sheetData, matrix.forValue((row, column, cell) => {
+          let rowData = sheetData[row] ??= {};
+          rowData[column] = cell == null ? null : {
+            v: cell.v,
+            ...typeof cell.t == "number" ? { t: cell.t } : {},
+            ...cell.p != null ? { p: cell.p } : {},
+            ...typeof cell.f == "string" ? { f: cell.f } : {},
+            ...typeof cell.si == "string" ? { si: cell.si } : {},
+            ...typeof cell.ref == "string" ? { ref: cell.ref } : {},
+            ...typeof cell.xf == "string" ? { xf: cell.xf } : {},
+            ...cell.s != null ? { s: cell.s } : {}
+          };
+        });
+      });
+    }), result;
+  }
+  _serializeFormulaData(formulaData) {
+    let result = {};
+    if (!formulaData || typeof formulaData != "object") return result;
+    for (let [unitId, sheets] of Object.entries(formulaData))
+      if (!(!sheets || typeof sheets != "object")) {
+        result[unitId] = {};
+        for (let [sheetId, rows] of Object.entries(sheets))
+          if (!(!rows || typeof rows != "object")) {
+            result[unitId][sheetId] = {};
+            for (let [rowStr, cols] of Object.entries(rows)) {
+              if (!cols || typeof cols != "object")
+                continue;
+              let row = Number(rowStr);
+              result[unitId][sheetId][row] = {};
+              for (let [colStr, item] of Object.entries(cols)) {
+                let col = Number(colStr);
+                if (typeof item == "string")
+                  result[unitId][sheetId][row][col] = item;
+                else if (item && typeof item == "object" && typeof item.f == "string") {
+                  let formulaItem = item;
+                  result[unitId][sheetId][row][col] = {
+                    f: formulaItem.f,
+                    si: typeof formulaItem.si == "string" ? formulaItem.si : void 0,
+                    ref: typeof formulaItem.ref == "string" ? formulaItem.ref : void 0,
+                    x: typeof formulaItem.x == "number" ? formulaItem.x : void 0,
+                    y: typeof formulaItem.y == "number" ? formulaItem.y : void 0
+                  };
+                }
+              }
+            }
+          }
+      }
+    return result;
+  }
+  _serializeUnitData(unitData) {
+    let result = {};
+    if (!unitData) return result;
+    for (let [unitId, sheets] of Object.entries(unitData)) {
+      result[unitId] = {};
+      for (let [sheetId, sheet] of Object.entries(sheets))
+        result[unitId][sheetId] = {
+          cellData: this._serializeCellData(sheet.cellData),
+          rowCount: sheet.rowCount ?? 0,
+          columnCount: sheet.columnCount ?? 0
+        };
+    }
+    return result;
+  }
+  _serializeCellData(cellData) {
+    let result = {};
+    if (!cellData || typeof cellData != "object") return result;
+    let data = typeof cellData.getMatrix == "function" ? cellData.getMatrix() : cellData;
+    for (let [rowStr, cols] of Object.entries(data)) {
+      let row = Number(rowStr);
+      if (Number.isFinite(row)) {
+        result[row] = {};
+        for (let [colStr, cell] of Object.entries(cols)) {
+          let col = Number(colStr);
+          Number.isFinite(col) && (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
+          });
+        }
+      }
+    }
+    return result;
+  }
+  _applyRustOutput(_output) {
+  }
+  async _applyRustDependencyOutput(output) {
+    let convertStartedAt = performance.now(), result = rustExecutionOutputToCalculationResult(output), convertMs = performance.now() - convertStartedAt, commandStartedAt = performance.now();
+    return await this._commandService.executeCommand(SetFormulaCalculationResultMutation2.id, result, {
+      onlyLocal: !0,
+      fromRustFormulaEngine: !0
+    }), {
+      convertMs,
+      commandMs: performance.now() - commandStartedAt
+    };
+  }
+  async calculate(formulaString) {
+    this._nativeLoaded || (await loadNativeBinding(), this._nativeLoaded = !0);
+    let unitId = "__rust_formula_calculate__", sheetId = "__sheet__", input = {
+      config: { maxIteration: 1, intervalCount: DEFAULT_INTERVAL_COUNT },
+      formulaData: {
+        [unitId]: {
+          [sheetId]: {
+            0: { 0: formulaString }
+          }
+        }
+      },
+      unitData: {
+        [unitId]: {
+          [sheetId]: {
+            rowCount: 1,
+            columnCount: 1,
+            cellData: {}
+          }
+        }
+      },
+      dirtyRanges: [],
+      definedNames: {}
+    };
+    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 = {
+      config: { maxIteration: 1, intervalCount: DEFAULT_INTERVAL_COUNT },
+      formulaData,
+      unitData: this._serializeUnitData(unitData),
+      dirtyRanges: [],
+      definedNames: {}
+    }, output = JSON.parse(executeOnRust(JSON.stringify(input)));
+    return this._formulaExecutionOutputToResultMap(formulas, output);
+  }
+  async getAllDependencyJson(_rowData) {
+    this._nativeLoaded || (await loadNativeBinding(), 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();
+    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
+    );
+    if (!current)
+      return;
+    let byId = new Map(all.map((item) => [item.treeId, item]));
+    return {
+      ...current,
+      children: current.children.map((id) => byId.get(id)).filter(isFormulaDependencyTreeJson),
+      parents: current.parents.map((id) => byId.get(id)).filter(isFormulaDependencyTreeJson)
+    };
+  }
+  async getRangeDependents(unitRanges) {
+    this._nativeLoaded || (await loadNativeBinding(), 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)))
+    );
+    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(
+      (item) => this._cellInUnitRanges(item.unitId, item.subUnitId, item.row, item.column, unitRanges)
+    );
+  }
+  async getDependentsAndInRangeFormulas(unitRanges) {
+    let [dependents, inRanges] = await Promise.all([
+      this.getRangeDependents(unitRanges),
+      this.getInRangeFormulas(unitRanges)
+    ]);
+    return { dependents, inRanges };
+  }
+  _formulaStringMapToFormulaData(formulas) {
+    let formulaData = {};
+    return Object.entries(formulas).forEach(([unitId, sheetMap]) => {
+      sheetMap && (formulaData[unitId] = {}, Object.entries(sheetMap).forEach(([sheetId, rowMap]) => {
+        rowMap && (formulaData[unitId][sheetId] = {}, Object.entries(rowMap).forEach(([rowKey, colMap]) => {
+          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);
+          });
+        }));
+      }));
+    }), formulaData;
+  }
+  _formulaExecutionOutputToResultMap(formulas, output) {
+    let result = {};
+    return Object.entries(formulas).forEach(([unitId, sheetMap]) => {
+      sheetMap && (result[unitId] = {}, Object.entries(sheetMap).forEach(([sheetId, rowMap]) => {
+        rowMap && (result[unitId][sheetId] = {}, Object.entries(rowMap).forEach(([rowKey, colMap]) => {
+          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 }));
+          });
+        }));
+      }));
+    }), result;
+  }
+  _getRustDependencyGraph(unitId) {
+    return JSON.parse(buildRustDependencyGraphOnRust(unitId));
+  }
+  _getRustInspectGraph() {
+    return JSON.parse(inspectRustFormulaDependencyGraphOnRust());
+  }
+  _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));
+    return this._uniqueDependencyJson([...cellItems, ...nonCellItems]);
+  }
+  _rustGraphDependencyJson(graph) {
+    return (graph.nodes ?? []).map((node) => this._rustDependencyNodeToJson(node));
+  }
+  _rustDependencyNodeToJson(node) {
+    return {
+      children: node.children ?? [],
+      parents: node.parents ?? [],
+      treeId: node.id,
+      formula: node.formula,
+      row: node.row,
+      column: node.column,
+      unitId: node.unitId,
+      subUnitId: node.sheetId,
+      refOffsetX: node.offsetX ?? 0,
+      refOffsetY: node.offsetY ?? 0,
+      rangeList: (node.precedentRanges ?? []).map((range) => this._rustRangeToUnitRange(range)),
+      refTreeId: void 0,
+      formulaId: node.formulaId ?? null,
+      featureId: null,
+      type: FORMULA_TREE_TYPE_NORMAL
+    };
+  }
+  _rustFormulaNodeToDependencyJson(index, node) {
+    return {
+      children: [],
+      parents: [],
+      treeId: index,
+      formula: "",
+      row: node.row ?? -1,
+      column: node.column ?? -1,
+      unitId: node.unitId ?? "",
+      subUnitId: node.sheetId ?? "",
+      refOffsetX: node.refOffsetX ?? 0,
+      refOffsetY: node.refOffsetY ?? 0,
+      rangeList: [],
+      refTreeId: void 0,
+      formulaId: node.formulaId ?? null,
+      featureId: node.featureId ?? null,
+      type: node.nodeType === "featureCalculation" ? FORMULA_TREE_TYPE_FEATURE : FORMULA_TREE_TYPE_OTHER
+    };
+  }
+  _rustRangeToUnitRange(range) {
+    return {
+      unitId: range.unitId,
+      sheetId: range.sheetId,
+      range: {
+        startRow: range.startRow,
+        endRow: range.endRow,
+        startColumn: range.startColumn,
+        endColumn: range.endColumn
+      }
+    };
+  }
+  _serializeUnitRanges(unitRanges) {
+    return unitRanges.map((unitRange) => ({
+      unitId: unitRange.unitId,
+      sheetId: unitRange.sheetId,
+      startRow: unitRange.range.startRow,
+      endRow: unitRange.range.endRow,
+      startColumn: unitRange.range.startColumn,
+      endColumn: unitRange.range.endColumn
+    }));
+  }
+  _rustDependencyJsonByCell(items) {
+    return new Map(
+      items.map((item) => [
+        this._cellKey({
+          unitId: item.unitId,
+          sheetId: item.subUnitId,
+          row: item.row,
+          column: item.column
+        }),
+        item
+      ])
+    );
+  }
+  _cellKey(cell) {
+    return `${cell.unitId}\0${cell.sheetId}\0${cell.row}\0${cell.column}`;
+  }
+  _cellInUnitRanges(unitId, sheetId, row, column, unitRanges) {
+    return unitRanges.some(
+      (unitRange) => unitRange.unitId === unitId && unitRange.sheetId === sheetId && row >= unitRange.range.startRow && row <= unitRange.range.endRow && column >= unitRange.range.startColumn && column <= unitRange.range.endColumn
+    );
+  }
+  _uniqueDependencyJson(items) {
+    let seen = /* @__PURE__ */ new Set(), result = [];
+    return items.forEach((item) => {
+      !item || seen.has(item.treeId) || (seen.add(item.treeId), result.push(item));
+    }), result;
+  }
+};
+setDependencies3(RustCalculateFormulaService, [
+  IConfigService,
+  IFormulaCurrentConfigService,
+  IFormulaRuntimeService,
+  IFormulaDependencyGenerator,
+  IFeatureCalculationManagerService,
+  IOtherFormulaManagerService,
+  ICommandService3,
+  RustEngineSyncController,
+  ExternalReferencePrefetchPlanner,
+  ExternalReferencePrefetchService
+]);
+function isFormulaDependencyTreeJson(value) {
+  return value !== void 0;
+}
+function normalizeFormulaResultValue(value) {
+  return value == null || typeof value == "number" || typeof value == "string" || typeof value == "boolean" || Array.isArray(value) && value.every(isFormulaResultRow) ? value : null;
+}
+function isFormulaResultRow(value) {
+  return Array.isArray(value) && value.every(
+    (item) => item == null || typeof item == "number" || typeof item == "string" || typeof item == "boolean"
+  );
+}
+
+// src/plugin.ts
+var DEFAULT_RUST_FORMULA_PLUGIN_CONFIG = {}, UniverRustFormulaEnginePlugin = class extends UniverProFormulaEnginePlugin {
+  constructor(_config = DEFAULT_RUST_FORMULA_PLUGIN_CONFIG, _injector, _configService) {
+    super(_config, _injector, _configService);
+    this._config = _config;
+    this._injector = _injector;
+    this._configService = _configService;
+  }
+  _config;
+  _injector;
+  _configService;
+  static packageName = name;
+  static version = version;
+  onReady() {
+    super.onReady(), !this._config?.notExecuteFormula && this._config?.useRustEngine !== !1 && touchDependencies(this._injector, [[RustEngineSyncController], [RustSameRuntimeProjectionController]]);
+  }
+  /**
+   * UniverProFormulaEnginePlugin invokes this hook before its single DI
+   * registration pass.
+   */
+  _extendFormulaExecutionDependencies(dependencies) {
+    if (this._config?.useRustEngine !== !1 && !this._config?.notExecuteFormula) {
+      let calculateServiceIndex = dependencies.findIndex(
+        (dependency) => Array.isArray(dependency) && dependency[0] === ICalculateFormulaService
+      ), rustDependencies = [
+        [RustEngineSyncController],
+        [RustSameRuntimeProjectionController],
+        [IRustCalculateFormulaService, { useClass: RustCalculateFormulaService }],
+        // eslint-disable-next-line react/no-unnecessary-use-prefix
+        [ICalculateFormulaService, { useFactory: () => this._injector.get(IRustCalculateFormulaService) }]
+      ];
+      calculateServiceIndex >= 0 && dependencies.splice(calculateServiceIndex, 1), dependencies.push(...rustDependencies);
+    }
+  }
+};
+setDependencies4(UniverRustFormulaEnginePlugin, [Injector, IConfigService2], 1);
+
+// src/services/workbook-snapshot-materializer.ts
+import { Buffer } from "node:buffer";
+async function materializeWorkbookSnapshot(workbook, unitID, rev, dirtyInput) {
+  await loadNativeBinding();
+  let result = await materializeWorkbookSnapshotOnRust(
+    Buffer.from(JSON.stringify(workbook)),
+    unitID,
+    rev,
+    dirtyInput == null ? void 0 : JSON.stringify(dirtyInput)
+  ), draft = JSON.parse(result.snapshotDraftJson.toString("utf8")), encoder = new TextEncoder(), sheets = Object.fromEntries(
+    Object.entries(draft.workbook.sheets).map(([sheetID, sheet]) => {
+      let { originalMetaJson: originalMetaJson2, ...meta } = sheet;
+      return [sheetID, { ...meta, originalMeta: encoder.encode(originalMetaJson2) }];
+    })
+  ), { originalMetaJson, ...workbookMeta } = draft.workbook;
+  return {
+    snapshot: {
+      unitID: draft.unitID,
+      type: draft.type,
+      rev: draft.rev,
+      workbook: {
+        ...workbookMeta,
+        sheets,
+        originalMeta: encoder.encode(originalMetaJson)
+      },
+      doc: void 0,
+      slide: void 0,
+      board: void 0
+    },
+    sheetBlocks: Object.fromEntries(result.sheetBlocks.map(({ sheetId, blocks }) => [sheetId, blocks])),
+    warnings: JSON.parse(result.warningsJson.toString("utf8")),
+    calculationStats: JSON.parse(result.calculationStatsJson.toString("utf8"))
+  };
+}
+export {
+  IRustCalculateFormulaService,
+  RUST_FORMULA_RELEVANT_MUTATIONS,
+  RUST_INCREMENTAL_DEPENDENCY_MUTATIONS,
+  RUST_UPSERT_REFERENCE_DATA_MUTATION_ID,
+  RustCalculateFormulaService,
+  RustEngineSyncController,
+  RustFormulaProjectionService,
+  UniverRustFormulaEnginePlugin,
+  analyzeNumberFormatBatch,
+  applyMutationOnRust,
+  buildLexerTreeOnRust,
+  buildRustDependencyGraphOnRust,
+  buildSequenceNodesOnRust,
+  checkIfAddBracketOnRust,
+  clearRustFormulaDependenciesOnRust,
+  clearRustFormulaDirtyOnRust,
+  createFormulaProjectionDesyncSignal,
+  disposeAllWorkbooksOnRust,
+  disposeWorkbookOnRust,
+  executeOnRust,
+  formatNumberBatch,
+  getNativeBindingSource,
+  getRustCellOnRust,
+  getRustDirtyDependenciesOnRust,
+  getRustFormulaDataOnRust,
+  getRustModelStats,
+  getRustSheetStateOnRust,
+  isRustFormulaRelevantMutation,
+  isRustIncrementalDependencyMutation,
+  loadNativeBinding,
+  loadSnapshotOnRust,
+  markRustFormulaDirtyOnRust,
+  materializeWorkbookSnapshot,
+  materializeWorkbookSnapshotOnRust,
+  parseNumberFormatBatch,
+  parseNumberFormatMatrixBatch,
+  rustExecutionOutputToFormulaCalculationPatch,
+  serializeRuntimeWorkbookSnapshot,
+  serializeRuntimeWorkbookSnapshots,
+  syncRustFormulaDependenciesOnRust
+};