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

package/lib/types/regression/rust-only-formula-comparison.d.ts

@@ -0,0 +1,43 @@
+import type { RustOnlyMismatchClassification, RustOnlyMismatchGroup } from './rust-only-report.js';
+export declare const REQUIRED_RUST_ONLY_MISMATCH_CLASSIFICATIONS: readonly ["import", "formula", "number-format", "export", "feature-model", "view-render", "excel-com-unavailable", "unsupported-external-cache", "corrupt-zip", "invalid-package", "unsupported-workbook", "timeout", "performance", "unknown"];
+export type RustOnlyMismatchSignal = 'missing-record-value-1' | 'formula-value-differs' | 'format-or-type-differs' | 'record-value-2-differs-from-record-value-1' | 'external-cache-unsupported' | 'case-timeout' | 'excel-com-unavailable' | 'unrecognized';
+export interface RustOnlyFormulaValue {
+    readonly sheet: string;
+    readonly address: string;
+    readonly formula?: string;
+    readonly value: unknown;
+    readonly valueType: string;
+}
+export interface CompareRecordValue1ToExcelComOracleOptions {
+    readonly excelComOracleValues: readonly RustOnlyFormulaValue[];
+    readonly recordValue1Values: readonly RustOnlyFormulaValue[];
+}
+export interface RustOnlyFormulaComparisonResult {
+    readonly comparedCount: number;
+    readonly mismatchGroups: readonly RustOnlyMismatchGroup[];
+    readonly skippedVolatileFormulaCount: number;
+    readonly skippedFormulaExamples: readonly RustOnlySkippedFormulaExample[];
+}
+export interface CompareRecordValue2RoundTripOptions {
+    readonly excelComOracleValues: readonly RustOnlyFormulaValue[];
+    readonly recordValue1Values: readonly RustOnlyFormulaValue[];
+    readonly recordValue2Values: readonly RustOnlyFormulaValue[];
+}
+export interface RustOnlyRecordValue2ComparisonResult {
+    readonly comparedToExcelComCount: number;
+    readonly comparedToRecordValue1Count: number;
+    readonly mismatchGroups: readonly RustOnlyMismatchGroup[];
+    readonly skippedVolatileFormulaCount: number;
+    readonly skippedFormulaExamples: readonly RustOnlySkippedFormulaExample[];
+}
+export interface RustOnlySkippedFormulaExample {
+    readonly sheet: string;
+    readonly address: string;
+    readonly formula?: string;
+    readonly reason: 'volatile-random-function';
+}
+export declare function classifyRustOnlyMismatch(options: {
+    readonly signal: RustOnlyMismatchSignal;
+}): RustOnlyMismatchClassification;
+export declare function compareRecordValue1ToExcelComOracle(options: CompareRecordValue1ToExcelComOracleOptions): RustOnlyFormulaComparisonResult;
+export declare function compareRecordValue2RoundTrip(options: CompareRecordValue2RoundTripOptions): RustOnlyRecordValue2ComparisonResult;

package/lib/types/regression/rust-only-ooxml-diff.d.ts

@@ -0,0 +1,23 @@
+export interface RustOnlyOoxmlChangedPart {
+    readonly partName: string;
+    readonly sourceHash: string;
+    readonly exportedHash: string;
+    readonly firstDifference: {
+        readonly index: number;
+        readonly sourceSnippet: string;
+        readonly exportedSnippet: string;
+    };
+}
+export interface RustOnlyOoxmlDiff {
+    readonly comparedXmlPartCount: number;
+    readonly missingInExported: readonly string[];
+    readonly missingInSource: readonly string[];
+    readonly changedXmlParts: readonly RustOnlyOoxmlChangedPart[];
+}
+export interface WriteRustOnlyOoxmlDiffArtifactOptions {
+    readonly sourceXlsxPath: string;
+    readonly exportedXlsxPath: string;
+    readonly outputJsonPath: string;
+}
+export declare function writeRustOnlyOoxmlDiffArtifact(options: WriteRustOnlyOoxmlDiffArtifactOptions): Promise<RustOnlyOoxmlDiff>;
+export declare function diffRustOnlyOoxmlParts(sourceParts: Record<string, string>, exportedParts: Record<string, string>): RustOnlyOoxmlDiff;

package/lib/types/regression/rust-only-ooxml-feature-extraction.d.ts

@@ -0,0 +1,7 @@
+export interface RustOnlyOoxmlFeatureFact {
+    readonly status: 'present';
+    readonly count: number;
+    readonly ooxmlParts: readonly string[];
+}
+export type RustOnlyOoxmlFeatureFacts = Record<string, RustOnlyOoxmlFeatureFact>;
+export declare function extractRustOnlyOoxmlFeatureFacts(parts: Record<string, string>): RustOnlyOoxmlFeatureFacts;

package/lib/types/regression/rust-only-partial-artifacts.d.ts

@@ -0,0 +1,7 @@
+import type { RustOnlyCaseArtifacts } from './rust-only-report.js';
+export interface ResolveRustOnlyPartialArtifactsOptions {
+    readonly caseDir: string;
+    readonly sourcePath: string;
+    readonly exists?: (path: string) => boolean;
+}
+export declare function resolveRustOnlyPartialArtifacts(options: ResolveRustOnlyPartialArtifactsOptions): RustOnlyCaseArtifacts;

package/lib/types/regression/rust-only-pipeline.d.ts

@@ -0,0 +1,55 @@
+import type { RustOnlyRegressionCase } from './rust-only-discovery.js';
+import type { RustOnlyFormulaCalculationMode } from './rust-only-report.js';
+export interface RustOnlyExchangeImportRequest {
+    readonly inputPath: string;
+    readonly outputJsonPath: string;
+    readonly formulaCalculationMode: RustOnlyFormulaCalculationMode;
+    readonly calcChainMode?: 'off' | 'trusted';
+}
+export interface RustOnlyExchangeExportRequest {
+    readonly snapshotJsonPath: string;
+    readonly outputXlsxPath: string;
+    readonly formulaCalculationMode: RustOnlyFormulaCalculationMode;
+}
+export interface RustOnlyExchangePort {
+    readonly importXlsx: (request: RustOnlyExchangeImportRequest) => Promise<void>;
+}
+export interface RustOnlyExchangeExportPort extends RustOnlyExchangePort {
+    readonly exportXlsx: (request: RustOnlyExchangeExportRequest) => Promise<void>;
+}
+export interface RustOnlyFormulaValueExtractorPort {
+    readonly extractXlsxFormulaValues: (request: {
+        readonly inputXlsxPath: string;
+        readonly outputJsonPath: string;
+    }) => Promise<void>;
+}
+export interface GenerateRustOnlyRecordValue1Options {
+    readonly testCase: RustOnlyRegressionCase;
+    readonly caseDir: string;
+    readonly exchange: RustOnlyExchangePort;
+    readonly sourceWorkbookPath?: string;
+    readonly formulaCalculationMode?: RustOnlyFormulaCalculationMode;
+    readonly calcChainMode?: 'off' | 'trusted';
+    readonly now?: () => number;
+}
+export interface GenerateRustOnlyRecordValue1Result {
+    readonly recordValue1Json: string;
+    readonly rustImportFormulaMs: number;
+}
+export interface GenerateRustOnlyRecordValue2Options {
+    readonly recordValue1Json: string;
+    readonly caseDir: string;
+    readonly exchange: RustOnlyExchangeExportPort;
+    readonly formulaValueExtractor: RustOnlyFormulaValueExtractorPort;
+    readonly formulaCalculationMode?: RustOnlyFormulaCalculationMode;
+    readonly now?: () => number;
+}
+export interface GenerateRustOnlyRecordValue2Result {
+    readonly recordValue2Xlsx: string;
+    readonly recordValue2FormulaValues: string;
+    readonly rustExportMs: number;
+    readonly formulaCacheExtractionMs: number;
+}
+export declare function resolveRustOnlyRegressionFormulaCalculationMode(mode?: RustOnlyFormulaCalculationMode): RustOnlyFormulaCalculationMode;
+export declare function generateRustOnlyRecordValue1(options: GenerateRustOnlyRecordValue1Options): Promise<GenerateRustOnlyRecordValue1Result>;
+export declare function generateRustOnlyRecordValue2(options: GenerateRustOnlyRecordValue2Options): Promise<GenerateRustOnlyRecordValue2Result>;

package/lib/types/regression/rust-only-process.d.ts

@@ -0,0 +1,9 @@
+export interface RunRustOnlyProcessOptions {
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly cwd: string;
+    readonly timeoutMs: number;
+    readonly maxBufferBytes?: number;
+    readonly killProcessTree?: (pid: number) => Promise<void> | void;
+}
+export declare function runRustOnlyProcess(options: RunRustOnlyProcessOptions): Promise<void>;

package/lib/types/regression/rust-only-real-runner.d.ts

@@ -0,0 +1,103 @@
+import type { RustOnlyExchangeBinaryProfile } from './rust-only-exchange-binary.js';
+import { type RustOnlyCaseReport, type RustOnlyFeatureFamily, type RustOnlyFormulaCalculationMode, type RustOnlyMismatchClassification } from './rust-only-report.js';
+export interface CreateRustOnlyRegressionRunSummaryOptions {
+    readonly runId: string;
+    readonly outputRoot: string;
+    readonly timeoutMs: number;
+    readonly exchangeBinaryProfile: RustOnlyExchangeBinaryProfile;
+    readonly formulaCalculationMode: RustOnlyFormulaCalculationMode;
+    readonly calcChainMode?: 'off' | 'trusted';
+    readonly reports: readonly RustOnlyCaseReport[];
+    readonly performanceMetricsBySourcePath?: Readonly<Record<string, RustOnlyCasePerformanceMetrics>>;
+}
+export interface RustOnlyRegressionRunSummary {
+    readonly runId: string;
+    readonly generatedAt: string;
+    readonly outputRoot: string;
+    readonly timeoutMs: number;
+    readonly exchangeBinaryProfile: RustOnlyExchangeBinaryProfile;
+    readonly formulaCalculationMode: RustOnlyFormulaCalculationMode;
+    readonly calcChainMode?: 'off' | 'trusted';
+    readonly counts: {
+        readonly total: number;
+        readonly passed: number;
+        readonly failed: number;
+        readonly pendingReview: number;
+        readonly timedOut: number;
+        readonly skipped: number;
+    };
+    readonly directRustTimings: {
+        readonly importFormulaMs: RustOnlyTimingSummary;
+        readonly exportMs: RustOnlyTimingSummary;
+    };
+    readonly formulaValueSkips: RustOnlyFormulaValueSkipSummary;
+    readonly mismatchCountsByClassification: Partial<Record<RustOnlyMismatchClassification, number>>;
+    readonly featureCoverageMatrix: Record<RustOnlyFeatureFamily, RustOnlyFeatureStatusCounts>;
+    readonly performanceFindings: readonly RustOnlyPerformanceFinding[];
+    readonly representativeExamples: readonly RustOnlyRepresentativeCaseExample[];
+    readonly visualReview: {
+        readonly assessmentMode: 'ai-or-human-similarity-review';
+        readonly pixelPerfectComparison: false;
+        readonly passCondition: 'visually-similar';
+    };
+}
+export interface RustOnlyFormulaValueSkipSummary {
+    readonly volatileRandomFormulaCount: number;
+    readonly examples: readonly {
+        readonly sourcePath: string;
+        readonly relativePath: string;
+        readonly sheet: string;
+        readonly address: string;
+        readonly formula?: string;
+        readonly reason: 'volatile-random-function';
+    }[];
+}
+export interface RustOnlyCasePerformanceMetrics {
+    readonly formulaCellCount?: number;
+    readonly totalCellCount?: number;
+}
+export interface RustOnlyPerformanceFinding {
+    readonly sourcePath: string;
+    readonly relativePath: string;
+    readonly stage: 'expanded-timeout' | 'formula' | 'import' | 'export';
+    readonly observedMs: number;
+    readonly thresholdMs: number;
+    readonly formulaCellCount?: number;
+    readonly totalCellCount?: number;
+    readonly severity: 'ok' | 'performance-bug';
+}
+export interface RustOnlyTimingSummary {
+    readonly count: number;
+    readonly totalMs: number;
+    readonly maxMs: number;
+}
+export interface RustOnlyFeatureStatusCounts {
+    readonly present: number;
+    readonly notPresent: number;
+    readonly unsupported: number;
+    readonly failed: number;
+}
+export interface RustOnlyRepresentativeCaseExample {
+    readonly sourcePath: string;
+    readonly relativePath: string;
+    readonly status: RustOnlyCaseReport['status'];
+    readonly classifications: readonly RustOnlyMismatchClassification[];
+    readonly artifactPaths: {
+        readonly recordValue1Json: string;
+        readonly recordValue2Xlsx: string;
+        readonly excelComCalculatedXlsx: string;
+    };
+}
+export interface WriteRustOnlyRegressionRunArtifactsOptions extends CreateRustOnlyRegressionRunSummaryOptions {
+    readonly summaryJsonPath?: string;
+    readonly summaryHtmlPath?: string;
+    readonly timeoutManifestPath?: string;
+}
+export interface RustOnlyRegressionRunArtifacts {
+    readonly summaryJsonPath: string;
+    readonly summaryHtmlPath: string;
+    readonly timeoutManifestPath: string;
+    readonly summary: RustOnlyRegressionRunSummary;
+}
+export declare function createRustOnlyRegressionRunSummary(options: CreateRustOnlyRegressionRunSummaryOptions): RustOnlyRegressionRunSummary;
+export declare function writeRustOnlyRegressionRunArtifacts(options: WriteRustOnlyRegressionRunArtifactsOptions): Promise<RustOnlyRegressionRunArtifacts>;

package/lib/types/regression/rust-only-report.d.ts

@@ -0,0 +1,131 @@
+import type { RustOnlyExchangeBinaryProfile } from './rust-only-exchange-binary.js';
+export declare const REQUIRED_FEATURE_FAMILIES: readonly ['conditional-format', 'data-validation', 'grouping', 'chart', 'pivot-table', 'cell-style', 'font-family', 'font-style', 'bold', 'italic', 'underline', 'strikethrough', 'border', 'ordinary-cell-value', 'floating-image', 'cell-image', 'shape', 'filter', 'table', 'defined-name', 'merged-cell', 'number-format', 'sparkline', 'hyperlink', 'alignment', 'protection'];
+export declare const REQUIRED_STAGE_TIMING_KEYS: readonly ['rustImportFormulaMs', 'rustExportMs', 'formulaCacheExtractionMs', 'excelComOracleMs', 'viewHostLoadMs', 'viewHostRenderMs', 'viewHostScreenshotMs', 'featureExtractionMs', 'totalCaseMs'];
+export type RustOnlyFeatureFamily = (typeof REQUIRED_FEATURE_FAMILIES)[number];
+export type RustOnlyStageTimingKey = (typeof REQUIRED_STAGE_TIMING_KEYS)[number];
+export type RustOnlyFormulaCalculationMode = 'forced' | 'when_empty' | 'no';
+export type RustOnlyCaseStatus = 'passed' | 'failed' | 'pending-review' | 'timed-out' | 'skipped';
+export type RustOnlyFeatureStatus = 'present' | 'not-present' | 'unsupported' | 'failed';
+export type RustOnlyMismatchClassification = 'import' | 'formula' | 'number-format' | 'export' | 'feature-model' | 'view-render' | 'excel-com-unavailable' | 'unsupported-external-cache' | 'corrupt-zip' | 'invalid-package' | 'unsupported-workbook' | 'timeout' | 'performance' | 'unknown';
+export interface RustOnlyScreenshotArtifact {
+    readonly path: string;
+    readonly sheet: string;
+    readonly featureTags: readonly RustOnlyFeatureFamily[];
+    readonly capturedAt: string;
+    readonly source?: 'excel-source' | 'view-host-json' | 'excel-export';
+    readonly viewHostUrl?: string;
+    readonly viewport?: string;
+    readonly scrollIndex?: number;
+}
+export interface RustOnlyVisualComparisonArtifact {
+    readonly id: 'source-excel-vs-view-host-json' | 'source-excel-vs-exported-excel';
+    readonly purpose: 'import-accuracy' | 'export-accuracy';
+    readonly expectedPath: string;
+    readonly actualPath: string;
+    readonly diffPath: string;
+    readonly expectedSize: {
+        readonly width: number;
+        readonly height: number;
+    };
+    readonly actualSize: {
+        readonly width: number;
+        readonly height: number;
+    };
+    readonly comparedSize: {
+        readonly width: number;
+        readonly height: number;
+    };
+    readonly threshold: number;
+    readonly passed: boolean;
+    readonly metrics: {
+        readonly similarity: number;
+        readonly ssim: number;
+        readonly meanAbsoluteError: number;
+        readonly rootMeanSquareError: number;
+        readonly differentPixelRatio: number;
+    };
+}
+export interface RustOnlyCaseArtifacts {
+    readonly sourceWorkbook: string;
+    readonly recordValue1Json: string;
+    readonly recordValue1FormulaValues: string;
+    readonly recordValue2Xlsx: string;
+    readonly recordValue2FormulaValues: string;
+    readonly recordValue2ExcelComOpenedXlsx?: string;
+    readonly excelComCalculatedXlsx: string;
+    readonly excelComFormulaValues: string;
+    readonly sourceVsExportedOoxmlDiff?: string;
+    readonly sourceExcelScreenshots: readonly RustOnlyScreenshotArtifact[];
+    readonly viewHostScreenshots: readonly RustOnlyScreenshotArtifact[];
+    readonly recordValue2ExcelScreenshots: readonly RustOnlyScreenshotArtifact[];
+    readonly visualComparisonArtifacts: readonly RustOnlyVisualComparisonArtifact[];
+    readonly visualReviewArtifacts: readonly string[];
+}
+export interface RustOnlyFeatureCoverage {
+    readonly status: RustOnlyFeatureStatus;
+    readonly evidenceArtifacts: readonly string[];
+    readonly comparisonArtifacts: readonly string[];
+    readonly failureStage?: RustOnlyMismatchClassification;
+}
+export interface RustOnlyMismatchExample {
+    readonly sheet: string;
+    readonly address: string;
+    readonly formula?: string;
+    readonly expected: {
+        readonly value: unknown;
+        readonly type: string;
+    };
+    readonly actual: {
+        readonly value: unknown;
+        readonly type: string;
+    };
+    readonly likelyFailureStage: RustOnlyMismatchClassification;
+}
+export interface RustOnlyMismatchGroup {
+    readonly classification: RustOnlyMismatchClassification;
+    readonly formulaFamily?: string;
+    readonly valueTypeTransition?: string;
+    readonly numberFormatCategory?: string;
+    readonly sheet?: string;
+    readonly featureFamily?: RustOnlyFeatureFamily;
+    readonly count: number;
+    readonly examples: readonly RustOnlyMismatchExample[];
+}
+export interface RustOnlyFormulaValueSkips {
+    readonly volatileRandomFormulaCount: number;
+    readonly examples: readonly {
+        readonly sheet: string;
+        readonly address: string;
+        readonly formula?: string;
+        readonly reason: 'volatile-random-function';
+    }[];
+}
+export interface RustOnlyCaseReport {
+    readonly runnerVersion: string;
+    readonly status: RustOnlyCaseStatus;
+    readonly exchangeBinaryProfile: RustOnlyExchangeBinaryProfile;
+    readonly formulaCalculationMode: RustOnlyFormulaCalculationMode;
+    readonly calcChainMode?: 'off' | 'trusted';
+    readonly source: {
+        readonly path: string;
+        readonly root: string;
+        readonly relativePath: string;
+        readonly sha256: string;
+    };
+    readonly artifacts: RustOnlyCaseArtifacts;
+    readonly featureCoverage: Partial<Record<RustOnlyFeatureFamily, RustOnlyFeatureCoverage>>;
+    readonly mismatchGroups: readonly RustOnlyMismatchGroup[];
+    readonly formulaValueSkips?: RustOnlyFormulaValueSkips;
+    readonly performanceMetrics?: {
+        readonly formulaCellCount?: number;
+        readonly totalCellCount?: number;
+    };
+    readonly stageTimings: Partial<Record<RustOnlyStageTimingKey, number>>;
+}
+export type RustOnlyStageTimings = Record<RustOnlyStageTimingKey, number>;
+export interface RustOnlyCaseReportValidationResult {
+    readonly ok: boolean;
+    readonly errors: readonly string[];
+}
+export declare function buildRustOnlyStageTimings(stageTimings: RustOnlyStageTimings): RustOnlyStageTimings;
+export declare function validateRustOnlyCaseReport(input: unknown): RustOnlyCaseReportValidationResult;

package/lib/types/regression/rust-only-sequential-runner.d.ts

@@ -0,0 +1,24 @@
+import type { RustOnlyRegressionCase } from './rust-only-discovery.js';
+export interface RustOnlySequentialStages {
+    readonly hashSource: (testCase: RustOnlyRegressionCase) => Promise<void>;
+    readonly generateRecordValue1: (testCase: RustOnlyRegressionCase) => Promise<void>;
+    readonly extractRecordValue1: (testCase: RustOnlyRegressionCase) => Promise<void>;
+    readonly generateRecordValue2: (testCase: RustOnlyRegressionCase) => Promise<void>;
+    readonly extractRecordValue2: (testCase: RustOnlyRegressionCase) => Promise<void>;
+    readonly createExcelComOracle: (testCase: RustOnlyRegressionCase) => Promise<void>;
+    readonly compareFormulaValues: (testCase: RustOnlyRegressionCase) => Promise<void>;
+    readonly extractFeatureEvidence: (testCase: RustOnlyRegressionCase) => Promise<void>;
+    readonly validateViewHost: (testCase: RustOnlyRegressionCase) => Promise<void>;
+    readonly writeCaseReport: (testCase: RustOnlyRegressionCase) => Promise<void>;
+}
+export interface RunRustOnlyRegressionSequentiallyOptions {
+    readonly cases: readonly RustOnlyRegressionCase[];
+    readonly stages: RustOnlySequentialStages;
+}
+export interface RunRustOnlyRegressionCaseOptions {
+    readonly testCase: RustOnlyRegressionCase;
+    readonly stages: RustOnlySequentialStages;
+    readonly legacyHeadlessFormulaCalculation?: (testCase: RustOnlyRegressionCase) => Promise<void>;
+}
+export declare function runRustOnlyRegressionSequentially(options: RunRustOnlyRegressionSequentiallyOptions): Promise<void>;
+export declare function runRustOnlyRegressionCase(options: RunRustOnlyRegressionCaseOptions): Promise<void>;

package/lib/types/regression/rust-only-timeout.d.ts

@@ -0,0 +1,63 @@
+import type { RustOnlyExchangeBinaryProfile } from './rust-only-exchange-binary.js';
+import { type RustOnlyCaseReport, type RustOnlyFormulaCalculationMode, type RustOnlyStageTimingKey } from './rust-only-report.js';
+export declare const DEFAULT_FIRST_PASS_CASE_TIMEOUT_MS = 120000;
+export declare const EXPANDED_TIMEOUT_RERUN_CASE_TIMEOUT_MS = 300000;
+export declare const DEBUG_REPAIR_RERUN_CASE_TIMEOUT_MS = 600000;
+export type RustOnlyRegressionPass = 'first' | 'expanded-timeout';
+export type RustOnlyActiveStage = 'sourceHash' | 'rustImportFormula' | 'recordValue1Extraction' | 'rustExport' | 'recordValue2Extraction' | 'recordValue2ExcelComOpen' | 'excelComOracle' | 'formulaComparison' | 'featureExtraction' | 'viewHostLoad' | 'viewHostRender' | 'sourceExcelScreenshot' | 'exportedExcelScreenshot' | 'viewHostScreenshot' | 'caseReportWrite';
+export interface ResolveRustOnlyCaseTimeoutOptions {
+    readonly pass: RustOnlyRegressionPass;
+    readonly timeoutMs?: number;
+}
+export interface ResolveRustOnlyBinaryProfileCaseTimeoutOptions extends ResolveRustOnlyCaseTimeoutOptions {
+    readonly binaryProfile: RustOnlyExchangeBinaryProfile;
+}
+export interface CreateRustOnlyTimeoutReportOptions {
+    readonly runnerVersion: string;
+    readonly sourcePath: string;
+    readonly sourceRoot: string;
+    readonly relativePath: string;
+    readonly sourceSha256: string;
+    readonly exchangeBinaryProfile: RustOnlyExchangeBinaryProfile;
+    readonly formulaCalculationMode: RustOnlyFormulaCalculationMode;
+    readonly calcChainMode?: 'off' | 'trusted';
+    readonly activeStage: RustOnlyActiveStage;
+    readonly elapsedMs: number;
+    readonly timeoutMs: number;
+    readonly stageTimings?: Partial<Record<RustOnlyStageTimingKey, number>>;
+}
+export interface RustOnlyTimeoutDiagnostics {
+    readonly activeStage: RustOnlyActiveStage;
+    readonly elapsedMs: number;
+    readonly timeoutMs: number;
+}
+export interface RustOnlyTimedOutCaseReport extends RustOnlyCaseReport {
+    readonly timeout: RustOnlyTimeoutDiagnostics;
+}
+export interface RustOnlyTimeoutManifestEntry extends RustOnlyTimeoutDiagnostics {
+    readonly caseId: string;
+    readonly sourcePath: string;
+    readonly sourceRoot: string;
+    readonly relativePath: string;
+}
+export interface RustOnlyExpandedTimeoutRerunCase {
+    readonly caseId: string;
+    readonly sourcePath: string;
+    readonly sourceRoot: string;
+    readonly relativePath: string;
+    readonly firstPassTimeout: RustOnlyTimeoutDiagnostics;
+}
+export interface RustOnlyExpandedTimeoutRerunPlan {
+    readonly pass: 'expanded-timeout';
+    readonly timeoutMs: typeof EXPANDED_TIMEOUT_RERUN_CASE_TIMEOUT_MS;
+    readonly cases: readonly RustOnlyExpandedTimeoutRerunCase[];
+}
+export declare function resolveRustOnlyCaseTimeoutMs(options: ResolveRustOnlyCaseTimeoutOptions): number;
+export declare function resolveRustOnlyBinaryProfileCaseTimeoutMs(options: ResolveRustOnlyBinaryProfileCaseTimeoutOptions): number;
+export declare function resolveRustOnlyStageProcessTimeoutMs(options: {
+    readonly caseTimeoutMs: number;
+    readonly elapsedMs: number;
+}): number;
+export declare function createRustOnlyTimeoutReport(options: CreateRustOnlyTimeoutReportOptions): RustOnlyTimedOutCaseReport;
+export declare function writeRustOnlyTimeoutManifest(manifestPath: string, entries: readonly RustOnlyTimeoutManifestEntry[]): Promise<void>;
+export declare function loadRustOnlyExpandedTimeoutRerunPlan(manifestPath: string): Promise<RustOnlyExpandedTimeoutRerunPlan>;

package/lib/types/regression/rust-only-view-host.d.ts

@@ -0,0 +1,171 @@
+import type { RustOnlyCaseReport, RustOnlyMismatchGroup } from './rust-only-report.js';
+export interface RustOnlyViewHostLoadRequest {
+    readonly workbookJsonPath: string;
+    readonly formulaCalculation: 'disabled';
+}
+export interface RustOnlyViewHostLoadResult {
+    readonly loaded: boolean;
+    readonly rendered: boolean;
+    readonly workbookId?: string;
+    readonly workbookName?: string;
+    readonly sheetIds?: readonly string[];
+    readonly sheetNames?: readonly string[];
+    readonly url: string;
+    readonly sessionId: string;
+    readonly consoleErrors?: readonly string[];
+    readonly uncaughtErrors?: readonly string[];
+    readonly timeout?: {
+        readonly activeStage: string;
+        readonly elapsedMs: number;
+        readonly timeoutMs: number;
+    };
+}
+export interface RustOnlyViewHostPort {
+    readonly loadWorkbookJson: (request: RustOnlyViewHostLoadRequest) => Promise<RustOnlyViewHostLoadResult>;
+    readonly captureScreenshot?: (request: {
+        readonly outputPath: string;
+        readonly sheet: string;
+        readonly viewport?: string;
+    }) => Promise<void>;
+}
+export interface ValidateRustOnlyViewHostRecordValue1Options {
+    readonly recordValue1Json: string;
+    readonly viewHost: RustOnlyViewHostPort;
+    readonly legacyHeadlessFormulaCalculation?: () => Promise<void>;
+}
+export interface RustOnlyViewHostValidationResult extends RustOnlyViewHostLoadResult {
+    readonly ok: boolean;
+}
+export interface RustOnlyViewHostProcessResult {
+    readonly status: number | null;
+    readonly stdout?: string;
+    readonly stderr?: string;
+    readonly error?: Error;
+}
+export interface RustOnlyViewHostProcessRunnerOptions {
+    readonly cwd: string;
+    readonly env: NodeJS.ProcessEnv;
+    readonly timeoutMs: number;
+}
+export type RustOnlyViewHostProcessRunner = (command: string, args: readonly string[], options: RustOnlyViewHostProcessRunnerOptions) => RustOnlyViewHostProcessResult;
+export interface CreateRustOnlyCliViewHostPortOptions {
+    readonly cliCwd: string;
+    readonly chromePath?: string;
+    readonly cliCommand?: string;
+    readonly cliCommandArgsPrefix?: readonly string[];
+    readonly command?: string;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly processRunner?: RustOnlyViewHostProcessRunner;
+    readonly timeoutMs?: number;
+    readonly screenshotWaitMs?: number;
+    readonly screenshotFileWaitMs?: number;
+    readonly viewport?: {
+        readonly width: number;
+        readonly height: number;
+    };
+}
+export interface CreateRustOnlyStaticViewerPortOptions {
+    readonly assetsRoot: string;
+    readonly chromePath?: string;
+    readonly cliCwd: string;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly processRunner?: RustOnlyViewHostProcessRunner;
+    readonly screenshotWaitMs?: number;
+    readonly screenshotFileWaitMs?: number;
+    readonly timeoutMs?: number;
+    readonly univerStorageModulePath?: string;
+    readonly viewport?: {
+        readonly width: number;
+        readonly height: number;
+    };
+}
+export declare function validateRustOnlyViewHostRecordValue1(options: ValidateRustOnlyViewHostRecordValue1Options): Promise<RustOnlyViewHostValidationResult>;
+export declare function createRustOnlyCliViewHostPort(options: CreateRustOnlyCliViewHostPortOptions): RustOnlyViewHostPort;
+export declare function createRustOnlyStaticViewerPort(options: CreateRustOnlyStaticViewerPortOptions): RustOnlyViewHostPort;
+export interface CaptureRustOnlyViewHostScreenshotOptions {
+    readonly workbookJsonPath: string;
+    readonly sheet: string;
+    readonly viewport?: string;
+    readonly featureTags: readonly string[];
+    readonly outputPath: string;
+    readonly viewHostUrl: string;
+    readonly sessionId: string;
+    readonly capturedAt?: string;
+    readonly viewHost: RustOnlyViewHostPort;
+}
+export interface RustOnlyViewHostScreenshotMetadata {
+    readonly path: string;
+    readonly workbookFile: string;
+    readonly sheet: string;
+    readonly viewport?: string;
+    readonly featureTags: readonly string[];
+    readonly capturedAt: string;
+    readonly viewHostUrl: string;
+    readonly sessionId: string;
+}
+export declare function captureRustOnlyViewHostScreenshot(options: CaptureRustOnlyViewHostScreenshotOptions): Promise<RustOnlyViewHostScreenshotMetadata>;
+export interface CreateRustOnlyVisualReviewArtifactOptions {
+    readonly viewHostScreenshotPath: string;
+    readonly excelScreenshotPath?: string;
+    readonly ooxmlFeatureFactsPath?: string;
+    readonly sheet: string;
+    readonly featureTags: readonly string[];
+}
+export interface RustOnlyVisualReviewArtifact {
+    readonly assessmentMode: 'ai-or-human-similarity-review';
+    readonly pixelPerfectComparison: false;
+    readonly passCondition: 'visually-similar';
+    readonly viewHostScreenshotPath: string;
+    readonly excelScreenshotPath?: string;
+    readonly ooxmlFeatureFactsPath?: string;
+    readonly sheet: string;
+    readonly featureTags: readonly string[];
+}
+export declare function createRustOnlyVisualReviewArtifact(options: CreateRustOnlyVisualReviewArtifactOptions): RustOnlyVisualReviewArtifact;
+export interface RustOnlyVisualScreenshotEvidence {
+    readonly path: string;
+    readonly sheet: string;
+    readonly viewport: string;
+    readonly scrollIndex: number;
+}
+export interface CreateRustOnlyAgentVisualReviewArtifactOptions {
+    readonly sourceWorkbookPath: string;
+    readonly recordValue1JsonPath: string;
+    readonly exportedWorkbookPath: string;
+    readonly featureTags: readonly string[];
+    readonly screenshotSets: {
+        readonly sourceExcel: readonly RustOnlyVisualScreenshotEvidence[];
+        readonly viewHostJson: readonly RustOnlyVisualScreenshotEvidence[];
+        readonly exportedExcel: readonly RustOnlyVisualScreenshotEvidence[];
+    };
+}
+export interface RustOnlyAgentVisualReviewComparison {
+    readonly id: 'source-excel-vs-view-host-json' | 'source-excel-vs-exported-excel';
+    readonly purpose: 'import-accuracy' | 'export-accuracy';
+    readonly expected: 'sourceExcel';
+    readonly actual: 'viewHostJson' | 'exportedExcel';
+    readonly status: 'pending-agent-review' | 'passed' | 'failed' | 'unavailable';
+    readonly agentJudgement: null | {
+        readonly accurate: boolean;
+        readonly confidence: 'low' | 'medium' | 'high';
+        readonly summary: string;
+    };
+    readonly notes: readonly string[];
+}
+export interface RustOnlyAgentVisualReviewArtifact {
+    readonly schemaVersion: 1;
+    readonly assessmentMode: 'agent-visual-similarity-review';
+    readonly pixelPerfectComparison: false;
+    readonly passCondition: 'visually-similar-for-present-feature-families';
+    readonly sourceWorkbookPath: string;
+    readonly recordValue1JsonPath: string;
+    readonly exportedWorkbookPath: string;
+    readonly featureTags: readonly string[];
+    readonly screenshotSets: CreateRustOnlyAgentVisualReviewArtifactOptions['screenshotSets'];
+    readonly comparisons: readonly RustOnlyAgentVisualReviewComparison[];
+}
+export declare function createRustOnlyAgentVisualReviewArtifact(options: CreateRustOnlyAgentVisualReviewArtifactOptions): RustOnlyAgentVisualReviewArtifact;
+export declare function createRustOnlyAgentVisualReviewMismatchGroups(artifact: RustOnlyAgentVisualReviewArtifact): RustOnlyMismatchGroup[];
+export declare function hasPendingRustOnlyAgentVisualReview(artifacts: readonly RustOnlyAgentVisualReviewArtifact[]): boolean;
+export declare function applyRustOnlyAgentVisualReviewGateToReport(report: RustOnlyCaseReport, artifacts: readonly RustOnlyAgentVisualReviewArtifact[]): RustOnlyCaseReport;
+export declare function parseRustOnlyAgentVisualReviewArtifactJson(input: string): RustOnlyAgentVisualReviewArtifact;

package/lib/types/regression/rust-only-workbook-json-formula-values.d.ts

@@ -0,0 +1,2 @@
+import type { RustOnlyFormulaValue } from './rust-only-formula-comparison.js';
+export declare function extractRustOnlyWorkbookJsonFormulaValues(workbook: unknown): RustOnlyFormulaValue[];

package/lib/types/regression/rust-only-xlsx-formula-values.d.ts

@@ -0,0 +1,8 @@
+import type { RustOnlyFormulaValue } from './rust-only-formula-comparison.js';
+export declare function extractRustOnlyXlsxFormulaValues(inputXlsxPath: string): Promise<RustOnlyFormulaValue[]>;
+export declare function extractSharedFormulaAnchorMapFromXlsxSheetXml(xml: string): Map<string, string>;
+export declare function formulaFromXlsxCellXml(body: string, sharedFormulaBySi?: ReadonlyMap<string, string>): string | undefined;
+export declare function cachedValueFromXlsxCellXml(body: string, type: string | undefined, sharedStrings: readonly string[]): unknown;
+export declare function inferXlsxCachedValueType(body: string): string;
+export declare function readXlsxTextParts(xlsxPath: string): Promise<Record<string, string>>;
+export declare function decodeXlsxXmlText(value: string): string;