@allurereport/core 3.16.1 → 3.17.0

package/dist/api.d.ts

@@ -1,4 +1,4 @@
-import type { CategoriesConfig, ResolvedAllureServiceConfig } from "@allurereport/core-api";
+import type { CategoriesConfig, PerformanceConfig, ResolvedAllureServiceConfig } from "@allurereport/core-api";
 import type { Plugin, ReportFiles, Config } from "@allurereport/plugin-api";
 import type { ResultsReader } from "@allurereport/reader-api";
 export interface PluginInstance {
@@ -16,9 +16,11 @@ export interface FullConfig extends Omit<Config, "name" | "output" | "open" | "a
     plugins?: PluginInstance[];
     realTime?: any;
     qualityGate?: Config["qualityGate"];
+    performance?: PerformanceConfig;
     allureService?: ResolvedAllureServiceConfig;
     categories?: CategoriesConfig;
     globalAttachments?: string[];
+    cwd?: string;
     resultsDir?: string[];
 }
 export {};

package/dist/config.d.ts

@@ -2,6 +2,7 @@ import type { Config, Plugin, PluginConstructorContext, PluginDescriptor } from
 import type { FullConfig, PluginInstance } from "./api.js";
 type PluginConstructor = new (options?: Record<string, any>, context?: PluginConstructorContext) => Plugin;
 export interface ConfigOverride {
+    cwd?: string;
     name?: Config["name"];
     output?: Config["output"];
     open?: Config["open"];

package/dist/config.js

@@ -107,6 +107,7 @@ export const validateConfig = (config) => {
         "environments",
         "appendHistory",
         "qualityGate",
+        "performance",
         "allureService",
         "categories",
         "globalAttachments",
@@ -210,6 +211,7 @@ export const resolveConfig = async (config, override = {}) => {
         ? { ...(config.resolutions ?? { rules: [] }), knownIssuesPath }
         : undefined;
     const output = resolve(override.output ?? config.output ?? "./allure-report");
+    const cwd = resolve(override.cwd ?? process.cwd());
     const variables = config.variables ?? {};
     const resultsDir = normalizeResultsDir(config.resultsDir);
     let pluginInstances = [];
@@ -235,6 +237,7 @@ export const resolveConfig = async (config, override = {}) => {
     }
     return {
         name,
+        cwd,
         output,
         open,
         port,
@@ -251,6 +254,7 @@ export const resolveConfig = async (config, override = {}) => {
         plugins: pluginInstances,
         defaultLabels: config.defaultLabels ?? {},
         qualityGate: config.qualityGate,
+        performance: config.performance,
         allureService: config.allureService
             ? {
                 accessToken: config.allureService.accessToken,
@@ -289,7 +293,7 @@ export const readConfig = async (cwd = process.cwd(), configPath, override) => {
         default:
             config = DEFAULT_CONFIG;
     }
-    const fullConfig = await resolveConfig(config, override);
+    const fullConfig = await resolveConfig(config, { ...override, cwd });
     return fullConfig;
 };
 export const readRawConfig = async (cwd = process.cwd(), configPath) => {

package/dist/history.d.ts

@@ -1,5 +1,5 @@
-import { type AllureHistory, type HistoryDataPoint, type TestCase, type TestResult } from "@allurereport/core-api";
-export declare const createHistory: (reportUuid: string, reportName: string | undefined, testCases: TestCase[], testResults: TestResult[], remoteUrl?: string) => HistoryDataPoint;
+import { type AllureHistory, type HistoryDataPoint, type MetricSample, type TestCase, type TestResult } from "@allurereport/core-api";
+export declare const createHistory: (reportUuid: string, reportName: string | undefined, testCases: TestCase[], testResults: TestResult[], remoteUrl?: string, metrics?: MetricSample[]) => HistoryDataPoint;
 export declare class AllureLocalHistory implements AllureHistory {
     #private;
     private readonly params;

package/dist/history.js

@@ -43,7 +43,17 @@ const createHistoryItems = (testResults, remoteUrl) => {
         return acc;
     }, {});
 };
-export const createHistory = (reportUuid, reportName = "Allure Report", testCases, testResults, remoteUrl = "") => {
+const metricsToHistoryValues = (metrics) => {
+    const grouped = new Map();
+    for (const metric of metrics) {
+        if (!metric.key || !Number.isFinite(metric.value)) {
+            continue;
+        }
+        grouped.set(metric.key, [...(grouped.get(metric.key) ?? []), metric.value]);
+    }
+    return Object.fromEntries([...grouped.entries()].map(([key, values]) => [key, values.reduce((acc, value) => acc + value, 0) / values.length]));
+};
+export const createHistory = (reportUuid, reportName = "Allure Report", testCases, testResults, remoteUrl = "", metrics = []) => {
     const knownTestCaseIds = testCases.map((tc) => tc.id);
     return {
         uuid: reportUuid,
@@ -51,7 +61,7 @@ export const createHistory = (reportUuid, reportName = "Allure Report", testCase
         timestamp: new Date().getTime(),
         knownTestCaseIds,
         testResults: createHistoryItems(testResults, remoteUrl),
-        metrics: {},
+        metrics: metricsToHistoryValues(metrics),
         url: remoteUrl,
     };
 };

package/dist/index.d.ts

@@ -11,4 +11,4 @@ export * from "./resolutions.js";
 export { resolveConfig, readConfig, readRawConfig, getPluginInstance } from "./config.js";
 export * from "./report.js";
 export * from "./plugin.js";
-export { QualityGateState, qualityGateDefaultRules, maxFailuresRule, minTestsCountRule, successRateRule, maxDurationRule, allTestsContainEnvRule, environmentsTestedRule, convertQualityGateResultsToTestErrors, stringifyQualityGateResults, } from "./qualityGate/index.js";
+export { QualityGateState, qualityGateDefaultRules, maxFailuresRule, minTestsCountRule, successRateRule, maxDurationRule, allTestsContainEnvRule, environmentsTestedRule, metricMaxRule, metricMinRule, metricMaxDeltaRule, metricMaxDeltaPercentRule, convertQualityGateResultsToTestErrors, stringifyQualityGateResults, } from "./qualityGate/index.js";

package/dist/index.js

@@ -10,4 +10,4 @@ export * from "./resolutions.js";
 export { resolveConfig, readConfig, readRawConfig, getPluginInstance } from "./config.js";
 export * from "./report.js";
 export * from "./plugin.js";
-export { QualityGateState, qualityGateDefaultRules, maxFailuresRule, minTestsCountRule, successRateRule, maxDurationRule, allTestsContainEnvRule, environmentsTestedRule, convertQualityGateResultsToTestErrors, stringifyQualityGateResults, } from "./qualityGate/index.js";
+export { QualityGateState, qualityGateDefaultRules, maxFailuresRule, minTestsCountRule, successRateRule, maxDurationRule, allTestsContainEnvRule, environmentsTestedRule, metricMaxRule, metricMinRule, metricMaxDeltaRule, metricMaxDeltaPercentRule, convertQualityGateResultsToTestErrors, stringifyQualityGateResults, } from "./qualityGate/index.js";

package/dist/qualityGate/qualityGate.d.ts

@@ -1,11 +1,11 @@
-import { type TestError, type TestResult } from "@allurereport/core-api";
-import type { QualityGateConfig, QualityGateValidationResult } from "@allurereport/plugin-api";
+import { type MetricSample, type TestError, type TestResult } from "@allurereport/core-api";
+import type { QualityGateConfig, QualityGateMetricHistoryPoint, QualityGateValidationResult } from "@allurereport/plugin-api";
 export declare const stringifyQualityGateResults: (results: QualityGateValidationResult[]) => string;
 export declare const convertQualityGateResultsToTestErrors: (results: QualityGateValidationResult[]) => TestError[];
 export declare class QualityGateState {
     #private;
-    setResult(rule: string, value: any, testResults?: string[]): void;
-    getResult(rule: string): any;
+    setResult(rule: string, value: unknown, testResults?: string[]): void;
+    getResult(rule: string): unknown;
     getTestResults(rule: string): string[];
     markTestResultsProcessed(testResults: TestResult[]): void;
     isTestResultProcessed(trId: string): boolean;
@@ -16,6 +16,8 @@ export declare class QualityGate {
     validate(payload: {
         state?: QualityGateState;
         trs: TestResult[];
+        metrics?: MetricSample[];
+        previousHistory?: QualityGateMetricHistoryPoint[];
         environment?: string;
     }): Promise<{
         fastFailed: boolean;

package/dist/qualityGate/qualityGate.js

@@ -59,7 +59,7 @@ export class QualityGate {
         this.config = config;
     }
     async validate(payload) {
-        const { state, trs, environment } = payload;
+        const { state, trs, metrics = [], previousHistory = [], environment } = payload;
         const trsToValidateById = new Map();
         for (const tr of trs) {
             if (tr.isRetry || isIgnoredFailure(tr) || state?.isTestResultProcessed(tr.id)) {
@@ -98,6 +98,8 @@ export class QualityGate {
                         setResult: (value, testResults) => state?.setResult?.(ruleId, value, testResults),
                     },
                     expected,
+                    metrics,
+                    previousHistory,
                     environment,
                 });
                 if (result.success) {

package/dist/qualityGate/rules.d.ts

@@ -1,14 +1,19 @@
 import { type QualityGateRule } from "@allurereport/plugin-api";
+type MetricRuleConfig = {
+    key: string;
+    value: number;
+    title?: string;
+    unit?: string;
+};
 export declare const maxFailuresRule: QualityGateRule<number>;
 export declare const minTestsCountRule: QualityGateRule<number>;
-export declare const successRateRule: QualityGateRule<number, {
-    totalCount: number;
-    passedCount: number;
-}>;
+export declare const successRateRule: QualityGateRule<number>;
 export declare const maxDurationRule: QualityGateRule<number>;
 export declare const allTestsContainEnvRule: QualityGateRule<string, number>;
 export declare const environmentsTestedRule: QualityGateRule<string[]>;
-export declare const qualityGateDefaultRules: (QualityGateRule<number> | QualityGateRule<number, {
-    totalCount: number;
-    passedCount: number;
-}> | QualityGateRule<string, number> | QualityGateRule<string[]>)[];
+export declare const metricMaxRule: QualityGateRule<MetricRuleConfig>;
+export declare const metricMinRule: QualityGateRule<MetricRuleConfig>;
+export declare const metricMaxDeltaRule: QualityGateRule<MetricRuleConfig>;
+export declare const metricMaxDeltaPercentRule: QualityGateRule<MetricRuleConfig>;
+export declare const qualityGateDefaultRules: (QualityGateRule<number> | QualityGateRule<string, number> | QualityGateRule<string[]> | QualityGateRule<MetricRuleConfig>)[];
+export {};

package/dist/qualityGate/rules.js

@@ -1,10 +1,80 @@
 import { filterSuccessful, filterUnsuccessful } from "@allurereport/core-api";
 import { bold } from "yoctocolors";
+const numberStateValue = (value) => (Number.isFinite(value) ? Number(value) : 0);
+const stringArrayStateValue = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+const successRateStateValue = (value) => {
+    if (typeof value !== "object" || value === null) {
+        return { totalCount: 0, passedCount: 0 };
+    }
+    const state = value;
+    return {
+        totalCount: numberStateValue(state.totalCount),
+        passedCount: numberStateValue(state.passedCount),
+    };
+};
+const metricValues = (metrics, key) => metrics
+    .map((metric) => (metric.key === key ? metric.value : undefined))
+    .filter((value) => Number.isFinite(value));
+const metricAverage = (metrics, key) => {
+    const values = metricValues(metrics, key);
+    if (values.length === 0) {
+        return undefined;
+    }
+    return values.reduce((acc, value) => acc + value, 0) / values.length;
+};
+const previousMetricValue = (history, key) => {
+    const previousHistory = [...history].sort((a, b) => (b.timestamp ?? 0) - (a.timestamp ?? 0));
+    for (const historyPoint of previousHistory) {
+        const value = historyPoint.metrics?.[key];
+        if (Number.isFinite(value)) {
+            return value;
+        }
+    }
+    return undefined;
+};
+const metricActual = (metrics, key, value) => {
+    const sample = metrics.find((metric) => metric.key === key);
+    return {
+        key,
+        value,
+        ...(sample?.title ? { title: sample.title } : {}),
+        ...(sample?.unit ? { unit: sample.unit } : {}),
+    };
+};
+const formatMetricValue = (value, unit) => {
+    if (!Number.isFinite(value)) {
+        return "n/a";
+    }
+    const finiteValue = value;
+    const formatted = Number.isInteger(finiteValue) ? String(finiteValue) : String(Number(finiteValue.toFixed(3)));
+    return unit ? `${formatted} ${unit}` : formatted;
+};
+const metricRuleTitle = (actual) => actual.title ?? actual.key;
+const metricRuleUnit = (actual, expected) => actual.unit ?? expected.unit;
+const missingMetricResult = (actual) => ({
+    success: false,
+    actual,
+    testResults: [],
+});
+const metricRuleResult = (success, actual) => ({
+    success,
+    actual,
+    testResults: [],
+});
+const metricDeltaWithinThreshold = (delta, threshold, better) => {
+    if (better === "lower") {
+        return delta <= threshold;
+    }
+    if (better === "higher") {
+        return -delta <= threshold;
+    }
+    return Math.abs(delta) <= threshold;
+};
 export const maxFailuresRule = {
     rule: "maxFailures",
     message: ({ actual, expected }) => `The number of failed tests ${bold(String(actual))} exceeds the allowed threshold value ${bold(String(expected))}`,
     validate: async ({ trs, expected, state }) => {
-        const previous = state.getResult() ?? 0;
+        const previous = numberStateValue(state.getResult());
         const failedTrs = trs.filter(filterUnsuccessful);
         const testResults = failedTrs.map((tr) => tr.id);
         const actual = previous + failedTrs.length;
@@ -20,7 +90,7 @@ export const minTestsCountRule = {
     rule: "minTestsCount",
     message: ({ actual, expected }) => `The total number of tests ${bold(String(actual))} is less than the expected threshold value ${bold(String(expected))}`,
     validate: async ({ trs, expected, state }) => {
-        const actual = trs.length + (state.getResult() ?? 0);
+        const actual = trs.length + numberStateValue(state.getResult());
         state.setResult(actual, []);
         return {
             success: actual >= expected,
@@ -33,7 +103,7 @@ export const successRateRule = {
     rule: "successRate",
     message: ({ actual, expected }) => `Success rate ${bold(String(actual))} is less, than expected ${bold(String(expected))}`,
     validate: async ({ trs, expected, state }) => {
-        const previous = state.getResult() ?? { totalCount: 0, passedCount: 0 };
+        const previous = successRateStateValue(state.getResult());
         const passedTrs = trs.filter(filterSuccessful);
         const notPassedTrs = trs.filter((tr) => !filterSuccessful(tr));
         const totalCount = previous.totalCount + trs.length;
@@ -52,7 +122,7 @@ export const maxDurationRule = {
     rule: "maxDuration",
     message: ({ actual, expected }) => `Maximum duration of some tests exceed the defined limit; actual ${bold(String(actual))}, expected ${bold(String(expected))}`,
     validate: async ({ trs, expected, state }) => {
-        const previous = state.getResult() ?? 0;
+        const previous = numberStateValue(state.getResult());
         const actual = Math.max(previous, ...trs.map((tr) => tr.duration ?? 0));
         const tooLongTrs = trs.filter((tr) => (tr.duration ?? 0) > expected);
         const testResults = tooLongTrs.map((tr) => tr.id);
@@ -66,9 +136,9 @@ export const maxDurationRule = {
 };
 export const allTestsContainEnvRule = {
     rule: "allTestsContainEnv",
-    message: ({ actual, expected }) => `Not all tests contain the required "${bold(expected)}" environment, ${bold(actual)} tests have different or missing environment`,
+    message: ({ actual, expected }) => `Not all tests contain the required "${bold(expected)}" environment, ${bold(String(actual))} tests have different or missing environment`,
     validate: async ({ trs, expected, state }) => {
-        const previous = state.getResult() ?? 0;
+        const previous = numberStateValue(state.getResult());
         const testsWithoutEnv = trs.filter((tr) => (tr.environment ?? "") !== expected);
         const testResults = testsWithoutEnv.map((tr) => tr.id);
         const actual = testsWithoutEnv.length + previous;
@@ -84,7 +154,7 @@ export const environmentsTestedRule = {
     rule: "environmentsTested",
     message: ({ actual, expected }) => `The following environments were not tested: "${actual.join('", "')}"; expected all of: "${expected.join('", "')}"`,
     validate: async ({ trs, expected, state }) => {
-        const previouslyTested = new Set(state.getResult() ?? []);
+        const previouslyTested = new Set(stringArrayStateValue(state.getResult()));
         const batchTested = trs.map((tr) => tr.environment).filter((env) => env != null && env !== "");
         const testedEnvs = new Set([...previouslyTested, ...batchTested]);
         state.setResult([...testedEnvs], []);
@@ -96,6 +166,62 @@ export const environmentsTestedRule = {
         };
     },
 };
+export const metricMaxRule = {
+    rule: "metricMax",
+    message: ({ actual, expected }) => `${bold(metricRuleTitle(actual))} ${bold(formatMetricValue(actual.value, metricRuleUnit(actual, expected)))} exceeds the allowed maximum ${bold(formatMetricValue(expected.value, metricRuleUnit(actual, expected)))}`,
+    validate: async ({ metrics = [], expected }) => {
+        const value = metricAverage(metrics, expected.key);
+        const actual = metricActual(metrics, expected.key, value ?? Number.NaN);
+        return value === undefined ? missingMetricResult(actual) : metricRuleResult(value <= expected.value, actual);
+    },
+};
+export const metricMinRule = {
+    rule: "metricMin",
+    message: ({ actual, expected }) => `${bold(metricRuleTitle(actual))} ${bold(formatMetricValue(actual.value, metricRuleUnit(actual, expected)))} is below the required minimum ${bold(formatMetricValue(expected.value, metricRuleUnit(actual, expected)))}`,
+    validate: async ({ metrics = [], expected }) => {
+        const value = metricAverage(metrics, expected.key);
+        const actual = metricActual(metrics, expected.key, value ?? Number.NaN);
+        return value === undefined ? missingMetricResult(actual) : metricRuleResult(value >= expected.value, actual);
+    },
+};
+export const metricMaxDeltaRule = {
+    rule: "metricMaxDelta",
+    message: ({ actual, expected }) => `${bold(metricRuleTitle(actual))} changed by ${bold(formatMetricValue(actual.value, metricRuleUnit(actual, expected)))}, which exceeds ${bold(formatMetricValue(expected.value, metricRuleUnit(actual, expected)))}`,
+    validate: async ({ metrics = [], previousHistory = [], expected }) => {
+        const current = metricAverage(metrics, expected.key);
+        if (current === undefined) {
+            return missingMetricResult(metricActual(metrics, expected.key, Number.NaN));
+        }
+        const previous = previousMetricValue(previousHistory, expected.key);
+        if (previous === undefined) {
+            return metricRuleResult(true, metricActual(metrics, expected.key, 0));
+        }
+        const value = current - previous;
+        const actual = metricActual(metrics, expected.key, value);
+        const better = metrics.find((metric) => metric.key === expected.key)?.better;
+        return metricRuleResult(metricDeltaWithinThreshold(value, expected.value, better), actual);
+    },
+};
+export const metricMaxDeltaPercentRule = {
+    rule: "metricMaxDeltaPercent",
+    message: ({ actual, expected }) => `${bold(metricRuleTitle(actual))} changed by ${bold(formatMetricValue(actual.value, "%"))}, which exceeds ${bold(formatMetricValue(expected.value, "%"))}`,
+    validate: async ({ metrics = [], previousHistory = [], expected }) => {
+        const current = metricAverage(metrics, expected.key);
+        if (current === undefined) {
+            return missingMetricResult(metricActual(metrics, expected.key, Number.NaN));
+        }
+        const previous = previousMetricValue(previousHistory, expected.key);
+        if (previous === undefined) {
+            return metricRuleResult(true, metricActual(metrics, expected.key, 0));
+        }
+        const value = previous !== 0 ? ((current - previous) / Math.abs(previous)) * 100 : Number.NaN;
+        const actual = metricActual(metrics, expected.key, value);
+        const better = metrics.find((metric) => metric.key === expected.key)?.better;
+        return Number.isFinite(value)
+            ? metricRuleResult(metricDeltaWithinThreshold(value, expected.value, better), actual)
+            : missingMetricResult(actual);
+    },
+};
 export const qualityGateDefaultRules = [
     maxFailuresRule,
     minTestsCountRule,
@@ -103,4 +229,8 @@ export const qualityGateDefaultRules = [
     maxDurationRule,
     allTestsContainEnvRule,
     environmentsTestedRule,
+    metricMaxRule,
+    metricMinRule,
+    metricMaxDeltaRule,
+    metricMaxDeltaPercentRule,
 ];

package/dist/report.js

@@ -9,14 +9,14 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _AllureReport_instances, _AllureReport_ci, _AllureReport_store, _AllureReport_readers, _AllureReport_plugins, _AllureReport_reportFiles, _AllureReport_realtimeChannel, _AllureReport_realtimeUpdateScheduler, _AllureReport_realTime, _AllureReport_hideLabels, _AllureReport_output, _AllureReport_history, _AllureReport_appendHistory, _AllureReport_allureServiceClient, _AllureReport_qualityGate, _AllureReport_dump, _AllureReport_categories, _AllureReport_environments, _AllureReport_globalAttachments, _AllureReport_knownIssuesPath, _AllureReport_dumpTempDirs, _AllureReport_state, _AllureReport_executionStage, _AllureReport_historyDataPoint, _AllureReport_summaryPath, _AllureReport_testResultsRegistryPath, _AllureReport_summariesByPluginId, _AllureReport_publishedRemoteHrefs, _AllureReport_published, _AllureReport_endGeneratePerfSpan, _AllureReport_publish, _AllureReport_runRealtimeUpdate, _AllureReport_restoreStateDumps, _AllureReport_getReportsToPublish, _AllureReport_cleanupFailedRemoteReport, _AllureReport_logPublishError, _AllureReport_applyPublishLinksToSummaries, _AllureReport_cloneSummariesByPluginId, _AllureReport_writeSummaryFiles, _AllureReport_writeTestResultRegistry, _AllureReport_generateRootSummary, _AllureReport_finishGeneratePerfSpan, _AllureReport_finishPerfMetrics, _AllureReport_eachPlugin, _AllureReport_getPluginState;
+var _AllureReport_instances, _AllureReport_ci, _AllureReport_store, _AllureReport_readers, _AllureReport_plugins, _AllureReport_reportFiles, _AllureReport_realtimeChannel, _AllureReport_realtimeUpdateScheduler, _AllureReport_realTime, _AllureReport_hideLabels, _AllureReport_output, _AllureReport_history, _AllureReport_appendHistory, _AllureReport_allureServiceClient, _AllureReport_qualityGate, _AllureReport_dump, _AllureReport_categories, _AllureReport_environments, _AllureReport_globalAttachments, _AllureReport_knownIssuesPath, _AllureReport_dumpTempDirs, _AllureReport_cwd, _AllureReport_state, _AllureReport_executionStage, _AllureReport_historyDataPoint, _AllureReport_summaryPath, _AllureReport_testResultsRegistryPath, _AllureReport_summariesByPluginId, _AllureReport_publishedRemoteHrefs, _AllureReport_artifactFilesByPath, _AllureReport_published, _AllureReport_endGeneratePerfSpan, _AllureReport_createHistoryDataPoint, _AllureReport_ingestSelfPerfMetrics, _AllureReport_publish, _AllureReport_getCwd, _AllureReport_runRealtimeUpdate, _AllureReport_recordArtifact, _AllureReport_restoreStateDumps, _AllureReport_getReportsToPublish, _AllureReport_cleanupFailedRemoteReport, _AllureReport_logPublishError, _AllureReport_applyPublishLinksToSummaries, _AllureReport_cloneSummariesByPluginId, _AllureReport_writeSummaryFiles, _AllureReport_writeTestResultRegistry, _AllureReport_getRootRemoteReportFiles, _AllureReport_writeQualityGateFiles, _AllureReport_finishArtifactsManifest, _AllureReport_generateRootSummary, _AllureReport_finishGeneratePerfSpan, _AllureReport_finishPerfMetrics, _AllureReport_eachPlugin, _AllureReport_getPluginState;
 import console from "node:console";
 import { randomUUID } from "node:crypto";
 import { once } from "node:events";
 import { createReadStream, createWriteStream, existsSync, readFileSync } from "node:fs";
 import { lstat, mkdtemp, readdir, realpath, rename, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { basename, dirname, join, resolve, sep } from "node:path";
+import { basename, dirname, join, resolve } from "node:path";
 import { promisify } from "node:util";
 import { detect } from "@allurereport/ci";
 import { createProgressLogger } from "@allurereport/cli-commons";
@@ -35,8 +35,9 @@ import { DefaultPluginState, PluginFiles } from "./plugin.js";
 import { QualityGate } from "./qualityGate/index.js";
 import { writeKnownIssues } from "./resolutions.js";
 import { DefaultAllureStore } from "./store/store.js";
+import { ARTIFACTS_MANIFEST_FILENAME, createReportArtifact, deduplicateDumpInputs, } from "./utils/artifacts.js";
 import { environmentIdentityById, environmentIdentityByName } from "./utils/environment.js";
-import { measurePerf, PERF_METRIC_NAMES, PERF_METRIC_PREFIXES, startPerfSpan, writePerfMetrics } from "./utils/perf.js";
+import { getPerfMetricsResults, isPerfMetricsEnabled, measurePerf, PERF_METRIC_NAMES, PERF_METRIC_PREFIXES, perfMetricsFileName, startPerfSpan, writePerfMetrics, } from "./utils/perf.js";
 import { RealtimeChannel } from "./utils/realtimeChannel.js";
 import { RealtimeUpdateScheduler } from "./utils/realtimeUpdateScheduler.js";
 import { resolveDumpAttachmentPath, UnsafeDumpPathError } from "./utils/safeDumpPath.js";
@@ -45,6 +46,12 @@ const INIT_REQUIRED_ERROR_MESSAGE = "report is not initialised. Call the start()
 const DEFAULT_READ_CONCURRENCY = 64;
 const MAX_READ_CONCURRENCY = 256;
 const TEST_RESULTS_REGISTRY_FILENAME = "test-results.json";
+const QUALITY_GATE_RESULTS_FILENAME = "quality-gate.json";
+const ROOT_INTEGRATION_FILENAMES = new Set([
+    TEST_RESULTS_REGISTRY_FILENAME,
+    QUALITY_GATE_RESULTS_FILENAME,
+    ARTIFACTS_MANIFEST_FILENAME,
+]);
 const readConcurrency = () => {
     const parsed = Number.parseInt(process.env.ALLURE_READ_CONCURRENCY ?? "", 10);
     if (!Number.isFinite(parsed)) {
@@ -92,6 +99,7 @@ export class AllureReport {
         _AllureReport_globalAttachments.set(this, void 0);
         _AllureReport_knownIssuesPath.set(this, void 0);
         _AllureReport_dumpTempDirs.set(this, []);
+        _AllureReport_cwd.set(this, void 0);
         _AllureReport_state.set(this, void 0);
         _AllureReport_executionStage.set(this, "init");
         _AllureReport_historyDataPoint.set(this, void 0);
@@ -99,8 +107,28 @@ export class AllureReport {
         _AllureReport_testResultsRegistryPath.set(this, void 0);
         _AllureReport_summariesByPluginId.set(this, new Map());
         _AllureReport_publishedRemoteHrefs.set(this, new Set());
+        _AllureReport_artifactFilesByPath.set(this, new Map());
         _AllureReport_published.set(this, false);
         _AllureReport_endGeneratePerfSpan.set(this, void 0);
+        _AllureReport_createHistoryDataPoint.set(this, async () => {
+            const allTrs = await __classPrivateFieldGet(this, _AllureReport_store, "f").allTestResults();
+            const allTcs = await __classPrivateFieldGet(this, _AllureReport_store, "f").allTestCases();
+            return createHistory(this.reportUuid, this.reportName, allTcs, allTrs, this.reportUrl, await __classPrivateFieldGet(this, _AllureReport_store, "f").allMetrics());
+        });
+        _AllureReport_ingestSelfPerfMetrics.set(this, async () => {
+            if (!isPerfMetricsEnabled()) {
+                return;
+            }
+            const results = getPerfMetricsResults();
+            if (results.length === 0) {
+                return;
+            }
+            const originalFileName = perfMetricsFileName(this.reportUuid);
+            await __classPrivateFieldGet(this, _AllureReport_store, "f").visitMetrics(results, {
+                readerId: "api",
+                metadata: { originalFileName },
+            });
+        });
         _AllureReport_publish.set(this, async () => {
             if (__classPrivateFieldGet(this, _AllureReport_published, "f")) {
                 return;
@@ -110,12 +138,13 @@ export class AllureReport {
             }
             let historyPoint = __classPrivateFieldGet(this, _AllureReport_historyDataPoint, "f");
             if (!historyPoint) {
-                const allTrs = await __classPrivateFieldGet(this, _AllureReport_store, "f").allTestResults();
-                const allTcs = await __classPrivateFieldGet(this, _AllureReport_store, "f").allTestCases();
-                historyPoint = createHistory(this.reportUuid, this.reportName, allTcs, allTrs, this.reportUrl);
+                historyPoint = await __classPrivateFieldGet(this, _AllureReport_createHistoryDataPoint, "f").call(this);
                 __classPrivateFieldSet(this, _AllureReport_historyDataPoint, historyPoint, "f");
             }
             await __classPrivateFieldGet(this, _AllureReport_writeTestResultRegistry, "f").call(this);
+            if (__classPrivateFieldGet(this, _AllureReport_qualityGate, "f")) {
+                await __classPrivateFieldGet(this, _AllureReport_writeQualityGateFiles, "f").call(this);
+            }
             await __classPrivateFieldGet(this, _AllureReport_writeSummaryFiles, "f").call(this);
             await __classPrivateFieldGet(this, _AllureReport_generateRootSummary, "f").call(this);
             if (__classPrivateFieldGet(this, _AllureReport_realTime, "f") || !__classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f")) {
@@ -131,8 +160,9 @@ export class AllureReport {
             const linksByPluginId = {};
             const summariesSnapshot = __classPrivateFieldGet(this, _AllureReport_cloneSummariesByPluginId, "f").call(this);
             const uploadProgressMessage = reportsToPublish.length === 1 ? `Publishing "${reportsToPublish[0].pluginId}" report` : "Publishing reports";
+            const rootRemoteReportFiles = __classPrivateFieldGet(this, _AllureReport_getRootRemoteReportFiles, "f").call(this);
             const totalFilesToUpload = reportsToPublish.reduce((acc, report) => acc + Object.keys(report.files).length, 0) +
-                (__classPrivateFieldGet(this, _AllureReport_testResultsRegistryPath, "f") ? 1 : 0);
+                Object.keys(rootRemoteReportFiles).length;
             let summariesMutated = false;
             let reportCreated = false;
             let publishErrorMessage = "Report upload has failed, the report won't be published";
@@ -167,11 +197,11 @@ export class AllureReport {
                         linksByPluginId[report.pluginId] = uploadResult.indexHref;
                     }
                 }
-                if (__classPrivateFieldGet(this, _AllureReport_testResultsRegistryPath, "f")) {
+                if (Object.keys(rootRemoteReportFiles).length > 0) {
                     publishErrorMessage = "Test results registry upload has failed, the report won't be published";
                     await client.uploadReport({
                         reportUuid: this.reportUuid,
-                        files: { [TEST_RESULTS_REGISTRY_FILENAME]: __classPrivateFieldGet(this, _AllureReport_testResultsRegistryPath, "f") },
+                        files: rootRemoteReportFiles,
                         onProgress: incrementUploadProgress,
                     });
                 }
@@ -292,9 +322,15 @@ export class AllureReport {
             return __classPrivateFieldGet(this, _AllureReport_qualityGate, "f").validate({
                 trs: trs.filter(Boolean),
                 state,
+                metrics: await __classPrivateFieldGet(this, _AllureReport_store, "f").allMetrics(),
+                previousHistory: (await __classPrivateFieldGet(this, _AllureReport_store, "f").allHistoryDataPoints()).filter(({ uuid }) => uuid !== this.reportUuid),
                 environment: qualityGateEnvironment,
             });
         };
+        _AllureReport_getCwd.set(this, () => {
+            __classPrivateFieldSet(this, _AllureReport_cwd, __classPrivateFieldGet(this, _AllureReport_cwd, "f") ?? resolve(process.cwd()), "f");
+            return __classPrivateFieldGet(this, _AllureReport_cwd, "f");
+        });
         this.start = async () => {
             await __classPrivateFieldGet(this, _AllureReport_store, "f").readHistory();
             if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") === "running") {
@@ -305,22 +341,17 @@ export class AllureReport {
             }
             __classPrivateFieldSet(this, _AllureReport_executionStage, "running", "f");
             __classPrivateFieldSet(this, _AllureReport_endGeneratePerfSpan, startPerfSpan(PERF_METRIC_NAMES.generateTotal), "f");
-            const cwd = resolve(process.cwd());
-            const cwdWithSep = cwd.endsWith(sep) ? cwd : `${cwd}${sep}`;
             if (__classPrivateFieldGet(this, _AllureReport_globalAttachments, "f")?.length) {
+                const cwd = __classPrivateFieldGet(this, _AllureReport_getCwd, "f").call(this);
                 const matchedFiles = new Set();
                 for (const pattern of __classPrivateFieldGet(this, _AllureReport_globalAttachments, "f")) {
                     const files = await glob(pattern, { cwd, nodir: true, absolute: true });
-                    files.forEach((filePath) => matchedFiles.add(filePath));
+                    files.forEach((filePath) => matchedFiles.add(resolve(cwd, filePath)));
                 }
-                for (const filePath of matchedFiles) {
-                    const absoluteFilePath = resolve(filePath);
-                    const isInsideCwd = absoluteFilePath === cwd || absoluteFilePath.startsWith(cwdWithSep);
-                    if (!isInsideCwd) {
-                        continue;
-                    }
+                for (const absoluteFilePath of matchedFiles) {
                     const originalFileName = basename(absoluteFilePath);
                     __classPrivateFieldGet(this, _AllureReport_realtimeChannel, "f").dispatcher.sendGlobalAttachment(new PathResultFile(absoluteFilePath, originalFileName), originalFileName);
+                    __classPrivateFieldGet(this, _AllureReport_recordArtifact, "f").call(this, absoluteFilePath, originalFileName);
                 }
             }
             await __classPrivateFieldGet(this, _AllureReport_eachPlugin, "f").call(this, true, async (plugin, context) => {
@@ -387,7 +418,7 @@ export class AllureReport {
             const addJsonDumpEntry = async (entryName, value) => {
                 await addRequiredDumpEntry(Buffer.from(JSON.stringify(value)), entryName);
             };
-            const dumpJsonEntries = ({ testResults, testCases, fixtures, attachments, environments, reportVariables, checkResults = {}, globalAttachmentIds = [], globalErrors = [], indexAttachmentByTestResult = {}, indexTestResultByHistoryId = {}, indexTestResultByTestCase = {}, indexTestResultByResolutionIssue = {}, indexAttachmentByFixture = {}, indexFixturesByTestResult = {}, resolutionIssues = {}, qualityGateResults = [], testResultIdsIngestOrder = [], }) => [
+            const dumpJsonEntries = ({ testResults, testCases, fixtures, attachments, environments, reportVariables, checkResults = {}, globalAttachmentIds = [], globalErrors = [], indexAttachmentByTestResult = {}, indexTestResultByHistoryId = {}, indexTestResultByTestCase = {}, indexTestResultByResolutionIssue = {}, indexAttachmentByFixture = {}, indexFixturesByTestResult = {}, resolutionIssues = {}, qualityGateResults = [], testResultIdsIngestOrder = [], metrics = [], }) => [
                 [AllureStoreDumpFiles.TestResults, testResults],
                 [AllureStoreDumpFiles.TestCases, testCases],
                 [AllureStoreDumpFiles.Fixtures, fixtures],
@@ -406,6 +437,7 @@ export class AllureReport {
                 [AllureStoreDumpFiles.IndexFixturesByTestResult, indexFixturesByTestResult],
                 [AllureStoreDumpFiles.QualityGateResults, qualityGateResults],
                 [AllureStoreDumpFiles.TestResultIngestOrder, testResultIdsIngestOrder],
+                [AllureStoreDumpFiles.Metrics, metrics],
             ];
             let dumpError;
             dumpArchive.pipe(dumpArchiveWriteStream);
@@ -473,10 +505,18 @@ export class AllureReport {
         };
         this.restoreState = async (dumps) => {
             __classPrivateFieldGet(this, _AllureReport_store, "f").resetIngestOrder();
-            await __classPrivateFieldGet(this, _AllureReport_restoreStateDumps, "f").call(this, dumps);
+            await __classPrivateFieldGet(this, _AllureReport_restoreStateDumps, "f").call(this, dumps.map((path) => ({ artifactPath: path, path })));
         };
+        _AllureReport_recordArtifact.set(this, (filePath, name = basename(filePath)) => {
+            const artifact = createReportArtifact(filePath, __classPrivateFieldGet(this, _AllureReport_getCwd, "f").call(this), name);
+            if (!__classPrivateFieldGet(this, _AllureReport_artifactFilesByPath, "f").has(artifact.path)) {
+                __classPrivateFieldGet(this, _AllureReport_artifactFilesByPath, "f").set(artifact.path, artifact);
+            }
+        });
         _AllureReport_restoreStateDumps.set(this, async (dumps) => measurePerf(PERF_METRIC_NAMES.restoreStateTotal, async () => {
-            for (const dump of dumps) {
+            let restoredCount = 0;
+            for (const { artifactPath, path: dump, recordArtifact = true } of deduplicateDumpInputs(dumps, __classPrivateFieldGet(this, _AllureReport_getCwd, "f").call(this))) {
+                const artifactFilePath = artifactPath ?? dump;
                 await measurePerf(PERF_METRIC_NAMES.restoreStateDump, async () => {
                     if (!existsSync(dump)) {
                         console.error(`Failed to restore state from "${dump}", continuing without it`);
@@ -505,14 +545,24 @@ export class AllureReport {
                                     entryName.toLowerCase().endsWith(".zip"));
                                 if (nestedDumpEntries.length > 0) {
                                     const nestedDumpsTempDir = await mkdtemp(join(tmpdir(), `${basename(dump, ".zip")}-nested-`));
-                                    const nestedDumpPaths = [];
+                                    const nestedDumps = [];
                                     __classPrivateFieldGet(this, _AllureReport_dumpTempDirs, "f").push(nestedDumpsTempDir);
                                     for (const [entryName] of nestedDumpEntries) {
-                                        const nestedDumpPath = join(nestedDumpsTempDir, `${nestedDumpPaths.length}-${basename(entryName)}`);
+                                        const nestedDumpPath = join(nestedDumpsTempDir, `${nestedDumps.length}-${basename(entryName)}`);
                                         await writeFile(nestedDumpPath, await dumpArchive.entryData(entryName));
-                                        nestedDumpPaths.push(nestedDumpPath);
+                                        nestedDumps.push({
+                                            artifactPath: artifactFilePath,
+                                            path: nestedDumpPath,
+                                            recordArtifact: false,
+                                        });
+                                    }
+                                    const nestedRestoredCount = await __classPrivateFieldGet(this, _AllureReport_restoreStateDumps, "f").call(this, nestedDumps);
+                                    if (nestedRestoredCount > 0) {
+                                        restoredCount += 1;
+                                        if (recordArtifact) {
+                                            __classPrivateFieldGet(this, _AllureReport_recordArtifact, "f").call(this, artifactFilePath);
+                                        }
                                     }
-                                    await __classPrivateFieldGet(this, _AllureReport_restoreStateDumps, "f").call(this, nestedDumpPaths);
                                     return;
                                 }
                             }
@@ -534,6 +584,7 @@ export class AllureReport {
                             const resolutionIssuesEntry = await optionalEntryData(AllureStoreDumpFiles.ResolutionIssues);
                             const qualityGateResultsEntry = await requiredEntryData(AllureStoreDumpFiles.QualityGateResults);
                             const testResultIngestOrderEntry = await optionalEntryData(AllureStoreDumpFiles.TestResultIngestOrder);
+                            const metricsEntry = await optionalEntryData(AllureStoreDumpFiles.Metrics);
                             const attachmentsLinks = JSON.parse(attachmentsEntry.toString("utf8"));
                             const attachmentsEntries = dumpEntriesList.reduce((acc, [entryName, entry]) => {
                                 switch (entryName) {
@@ -555,6 +606,7 @@ export class AllureReport {
                                     case AllureStoreDumpFiles.IndexFixturesByTestResult:
                                     case AllureStoreDumpFiles.QualityGateResults:
                                     case AllureStoreDumpFiles.TestResultIngestOrder:
+                                    case AllureStoreDumpFiles.Metrics:
                                         return acc;
                                     default:
                                         if (entry.isDirectory || !attachmentsLinks[entryName] || attachmentsLinks[entryName].missed) {
@@ -588,6 +640,7 @@ export class AllureReport {
                                 testResultIdsIngestOrder: testResultIngestOrderEntry
                                     ? JSON.parse(testResultIngestOrderEntry.toString("utf8"))
                                     : [],
+                                metrics: metricsEntry ? JSON.parse(metricsEntry.toString("utf8")) : [],
                             };
                             const dumpTempDir = await mkdtemp(join(tmpdir(), basename(dump, ".zip")));
                             const resultsAttachments = {};
@@ -614,6 +667,10 @@ export class AllureReport {
                             });
                             await measurePerf(PERF_METRIC_NAMES.restoreStateStoreRestore, async () => __classPrivateFieldGet(this, _AllureReport_store, "f").restoreState(dumpState, resultsAttachments));
                             console.info(`Successfully restored state from "${dump}"`);
+                            restoredCount += 1;
+                            if (recordArtifact) {
+                                __classPrivateFieldGet(this, _AllureReport_recordArtifact, "f").call(this, artifactFilePath);
+                            }
                         }
                         catch (err) {
                             restoreError = err;
@@ -637,6 +694,7 @@ export class AllureReport {
                     }
                 });
             }
+            return restoredCount;
         }));
         _AllureReport_getReportsToPublish.set(this, async () => {
             const reports = [];
@@ -709,6 +767,25 @@ export class AllureReport {
             const registry = createTestResultRegistry(testResults);
             __classPrivateFieldSet(this, _AllureReport_testResultsRegistryPath, await __classPrivateFieldGet(this, _AllureReport_reportFiles, "f").addFile(TEST_RESULTS_REGISTRY_FILENAME, Buffer.from(JSON.stringify(registry))), "f");
         });
+        _AllureReport_getRootRemoteReportFiles.set(this, () => ({
+            ...(__classPrivateFieldGet(this, _AllureReport_testResultsRegistryPath, "f") ? { [TEST_RESULTS_REGISTRY_FILENAME]: __classPrivateFieldGet(this, _AllureReport_testResultsRegistryPath, "f") } : {}),
+        }));
+        _AllureReport_writeQualityGateFiles.set(this, async () => {
+            const qualityGateResults = await __classPrivateFieldGet(this, _AllureReport_store, "f").qualityGateResults();
+            await __classPrivateFieldGet(this, _AllureReport_reportFiles, "f").addFile(QUALITY_GATE_RESULTS_FILENAME, Buffer.from(JSON.stringify(qualityGateResults)));
+        });
+        _AllureReport_finishArtifactsManifest.set(this, async () => {
+            if (__classPrivateFieldGet(this, _AllureReport_artifactFilesByPath, "f").size === 0) {
+                return;
+            }
+            const manifest = [...__classPrivateFieldGet(this, _AllureReport_artifactFilesByPath, "f").values()];
+            try {
+                await writeFile(join(__classPrivateFieldGet(this, _AllureReport_output, "f"), ARTIFACTS_MANIFEST_FILENAME), JSON.stringify(manifest));
+            }
+            catch (err) {
+                console.error("Failed to write Allure artifacts manifest", err);
+            }
+        });
         _AllureReport_generateRootSummary.set(this, async () => {
             const summaries = [...__classPrivateFieldGet(this, _AllureReport_summariesByPluginId, "f").values()].map(clonePluginSummary);
             if (summaries.length > 1) {
@@ -724,9 +801,6 @@ export class AllureReport {
                 throw new Error(INIT_REQUIRED_ERROR_MESSAGE);
             }
             try {
-                const testResults = await __classPrivateFieldGet(this, _AllureReport_store, "f").allTestResults();
-                const testCases = await __classPrivateFieldGet(this, _AllureReport_store, "f").allTestCases();
-                __classPrivateFieldSet(this, _AllureReport_historyDataPoint, createHistory(this.reportUuid, this.reportName, testCases, testResults, this.reportUrl), "f");
                 __classPrivateFieldGet(this, _AllureReport_realtimeChannel, "f").close();
                 try {
                     await __classPrivateFieldGet(this, _AllureReport_realtimeUpdateScheduler, "f").close();
@@ -747,6 +821,8 @@ export class AllureReport {
                     });
                 });
                 __classPrivateFieldGet(this, _AllureReport_finishGeneratePerfSpan, "f").call(this);
+                await __classPrivateFieldGet(this, _AllureReport_ingestSelfPerfMetrics, "f").call(this);
+                __classPrivateFieldSet(this, _AllureReport_historyDataPoint, await __classPrivateFieldGet(this, _AllureReport_createHistoryDataPoint, "f").call(this), "f");
                 await __classPrivateFieldGet(this, _AllureReport_eachPlugin, "f").call(this, false, async (plugin, context) => {
                     const summary = await plugin?.info?.(context, __classPrivateFieldGet(this, _AllureReport_store, "f"));
                     if (!summary) {
@@ -781,7 +857,7 @@ export class AllureReport {
                     const reportPath = join(__classPrivateFieldGet(this, _AllureReport_output, "f"), outputDirectoryEntries[0].file);
                     const reportContent = await readdir(reportPath);
                     for (const entry of reportContent) {
-                        if (entry === TEST_RESULTS_REGISTRY_FILENAME) {
+                        if (ROOT_INTEGRATION_FILENAMES.has(entry)) {
                             continue;
                         }
                         const currentFilePath = join(reportPath, entry);
@@ -790,6 +866,7 @@ export class AllureReport {
                     }
                     await rm(reportPath, { recursive: true });
                 }
+                await __classPrivateFieldGet(this, _AllureReport_finishArtifactsManifest, "f").call(this);
                 for (const dir of __classPrivateFieldGet(this, _AllureReport_dumpTempDirs, "f")) {
                     try {
                         await rm(dir, { recursive: true });
@@ -818,11 +895,6 @@ export class AllureReport {
                         console.info(`- ${href}`);
                     });
                 }
-                if (!__classPrivateFieldGet(this, _AllureReport_qualityGate, "f")) {
-                    return;
-                }
-                const qualityGateResults = await __classPrivateFieldGet(this, _AllureReport_store, "f").qualityGateResultsByEnv();
-                await writeFile(join(__classPrivateFieldGet(this, _AllureReport_output, "f"), "quality-gate.json"), JSON.stringify(qualityGateResults));
             }
             finally {
                 await __classPrivateFieldGet(this, _AllureReport_finishPerfMetrics, "f").call(this);
@@ -835,7 +907,7 @@ export class AllureReport {
         _AllureReport_finishPerfMetrics.set(this, async () => {
             __classPrivateFieldGet(this, _AllureReport_finishGeneratePerfSpan, "f").call(this);
             try {
-                await writePerfMetrics(__classPrivateFieldGet(this, _AllureReport_output, "f"));
+                await writePerfMetrics(__classPrivateFieldGet(this, _AllureReport_output, "f"), perfMetricsFileName(this.reportUuid));
             }
             catch (err) {
                 console.error("Failed to write Allure performance metrics", err);
@@ -893,7 +965,7 @@ export class AllureReport {
                 }
             }
         });
-        const { name, readers = [allure1, allure2, cucumberjson, junitXml, attachments], plugins = [], resolutions, reportFiles, realTime, historyPath, historyLimit, appendHistory, defaultLabels = {}, variables = {}, environment, allowedEnvironments, environments, output, hideLabels, qualityGate, dump, categories, allureService, globalAttachments, } = opts;
+        const { name, readers = [allure1, allure2, cucumberjson, junitXml, attachments], plugins = [], resolutions, reportFiles, realTime, historyPath, historyLimit, appendHistory, defaultLabels = {}, variables = {}, environment, allowedEnvironments, environments, output, hideLabels, qualityGate, performance, dump, categories, allureService, globalAttachments, cwd, } = opts;
         const allureServiceAccessToken = allureService?.accessToken;
         if (allureServiceAccessToken) {
             const allureServiceClientConfig = {
@@ -907,6 +979,7 @@ export class AllureReport {
                     : undefined, "f");
         }
         this.reportUuid = randomUUID();
+        __classPrivateFieldSet(this, _AllureReport_cwd, cwd ? resolve(cwd) : undefined, "f");
         __classPrivateFieldSet(this, _AllureReport_ci, detect(), "f");
         const reportTitleSuffix = __classPrivateFieldGet(this, _AllureReport_ci, "f")?.pullRequestName ?? __classPrivateFieldGet(this, _AllureReport_ci, "f")?.jobRunName;
         this.reportName = [name, reportTitleSuffix].filter(Boolean).join(" – ");
@@ -946,6 +1019,7 @@ export class AllureReport {
             defaultLabels,
             environment,
             allowedEnvironments,
+            performance,
         }), "f");
         __classPrivateFieldSet(this, _AllureReport_readers, [...readers], "f");
         __classPrivateFieldSet(this, _AllureReport_plugins, [...plugins], "f");
@@ -965,6 +1039,6 @@ export class AllureReport {
         return __classPrivateFieldGet(this, _AllureReport_realtimeChannel, "f").dispatcher;
     }
 }
-_AllureReport_ci = new WeakMap(), _AllureReport_store = new WeakMap(), _AllureReport_readers = new WeakMap(), _AllureReport_plugins = new WeakMap(), _AllureReport_reportFiles = new WeakMap(), _AllureReport_realtimeChannel = new WeakMap(), _AllureReport_realtimeUpdateScheduler = new WeakMap(), _AllureReport_realTime = new WeakMap(), _AllureReport_hideLabels = new WeakMap(), _AllureReport_output = new WeakMap(), _AllureReport_history = new WeakMap(), _AllureReport_appendHistory = new WeakMap(), _AllureReport_allureServiceClient = new WeakMap(), _AllureReport_qualityGate = new WeakMap(), _AllureReport_dump = new WeakMap(), _AllureReport_categories = new WeakMap(), _AllureReport_environments = new WeakMap(), _AllureReport_globalAttachments = new WeakMap(), _AllureReport_knownIssuesPath = new WeakMap(), _AllureReport_dumpTempDirs = new WeakMap(), _AllureReport_state = new WeakMap(), _AllureReport_executionStage = new WeakMap(), _AllureReport_historyDataPoint = new WeakMap(), _AllureReport_summaryPath = new WeakMap(), _AllureReport_testResultsRegistryPath = new WeakMap(), _AllureReport_summariesByPluginId = new WeakMap(), _AllureReport_publishedRemoteHrefs = new WeakMap(), _AllureReport_published = new WeakMap(), _AllureReport_endGeneratePerfSpan = new WeakMap(), _AllureReport_publish = new WeakMap(), _AllureReport_runRealtimeUpdate = new WeakMap(), _AllureReport_restoreStateDumps = new WeakMap(), _AllureReport_getReportsToPublish = new WeakMap(), _AllureReport_cleanupFailedRemoteReport = new WeakMap(), _AllureReport_logPublishError = new WeakMap(), _AllureReport_applyPublishLinksToSummaries = new WeakMap(), _AllureReport_cloneSummariesByPluginId = new WeakMap(), _AllureReport_writeSummaryFiles = new WeakMap(), _AllureReport_writeTestResultRegistry = new WeakMap(), _AllureReport_generateRootSummary = new WeakMap(), _AllureReport_finishGeneratePerfSpan = new WeakMap(), _AllureReport_finishPerfMetrics = new WeakMap(), _AllureReport_eachPlugin = new WeakMap(), _AllureReport_instances = new WeakSet(), _AllureReport_getPluginState = function _AllureReport_getPluginState(init, id) {
+_AllureReport_ci = new WeakMap(), _AllureReport_store = new WeakMap(), _AllureReport_readers = new WeakMap(), _AllureReport_plugins = new WeakMap(), _AllureReport_reportFiles = new WeakMap(), _AllureReport_realtimeChannel = new WeakMap(), _AllureReport_realtimeUpdateScheduler = new WeakMap(), _AllureReport_realTime = new WeakMap(), _AllureReport_hideLabels = new WeakMap(), _AllureReport_output = new WeakMap(), _AllureReport_history = new WeakMap(), _AllureReport_appendHistory = new WeakMap(), _AllureReport_allureServiceClient = new WeakMap(), _AllureReport_qualityGate = new WeakMap(), _AllureReport_dump = new WeakMap(), _AllureReport_categories = new WeakMap(), _AllureReport_environments = new WeakMap(), _AllureReport_globalAttachments = new WeakMap(), _AllureReport_knownIssuesPath = new WeakMap(), _AllureReport_dumpTempDirs = new WeakMap(), _AllureReport_cwd = new WeakMap(), _AllureReport_state = new WeakMap(), _AllureReport_executionStage = new WeakMap(), _AllureReport_historyDataPoint = new WeakMap(), _AllureReport_summaryPath = new WeakMap(), _AllureReport_testResultsRegistryPath = new WeakMap(), _AllureReport_summariesByPluginId = new WeakMap(), _AllureReport_publishedRemoteHrefs = new WeakMap(), _AllureReport_artifactFilesByPath = new WeakMap(), _AllureReport_published = new WeakMap(), _AllureReport_endGeneratePerfSpan = new WeakMap(), _AllureReport_createHistoryDataPoint = new WeakMap(), _AllureReport_ingestSelfPerfMetrics = new WeakMap(), _AllureReport_publish = new WeakMap(), _AllureReport_getCwd = new WeakMap(), _AllureReport_runRealtimeUpdate = new WeakMap(), _AllureReport_recordArtifact = new WeakMap(), _AllureReport_restoreStateDumps = new WeakMap(), _AllureReport_getReportsToPublish = new WeakMap(), _AllureReport_cleanupFailedRemoteReport = new WeakMap(), _AllureReport_logPublishError = new WeakMap(), _AllureReport_applyPublishLinksToSummaries = new WeakMap(), _AllureReport_cloneSummariesByPluginId = new WeakMap(), _AllureReport_writeSummaryFiles = new WeakMap(), _AllureReport_writeTestResultRegistry = new WeakMap(), _AllureReport_getRootRemoteReportFiles = new WeakMap(), _AllureReport_writeQualityGateFiles = new WeakMap(), _AllureReport_finishArtifactsManifest = new WeakMap(), _AllureReport_generateRootSummary = new WeakMap(), _AllureReport_finishGeneratePerfSpan = new WeakMap(), _AllureReport_finishPerfMetrics = new WeakMap(), _AllureReport_eachPlugin = new WeakMap(), _AllureReport_instances = new WeakSet(), _AllureReport_getPluginState = function _AllureReport_getPluginState(init, id) {
     return init ? new DefaultPluginState({}) : __classPrivateFieldGet(this, _AllureReport_state, "f")?.[id];
 };

package/dist/store/store.d.ts

@@ -1,4 +1,4 @@
-import { type AllureCheckResult, type AllureHistory, type AttachmentLink, type DefaultLabelsConfig, type EnvironmentIdentity, type EnvironmentsConfig, type GlobalAttachmentLink, type HistoryDataPoint, type HistoryTestResult, type ResolutionIssue, type ResolutionsConfig, type ReportVariables, type Statistic, type TestCase, type TestEnvGroup, type TestError, type TestFixtureResult, type TestResult } from "@allurereport/core-api";
+import { type AllureCheckResult, type AllureHistory, type AllurePerformanceResult, type AttachmentLink, type DefaultLabelsConfig, type EnvironmentIdentity, type EnvironmentsConfig, type GlobalAttachmentLink, type HistoryDataPoint, type HistoryTestResult, type ResolutionIssue, type ResolutionsConfig, type MetricSample, type PerformanceConfig, type ReportVariables, type Statistic, type TestCase, type TestEnvGroup, type TestError, type TestFixtureResult, type TestResult } from "@allurereport/core-api";
 import { type AllureStore, type AllureStoreDump, type ExitCode, type PluginGlobalError, type QualityGateValidationResult, type RealtimeEventsDispatcher, type RealtimeSubscriber, type ResultFile, type TestResultFilter } from "@allurereport/plugin-api";
 import type { RawFixtureResult, RawGlobals, RawMetadata, RawTestResult, ReaderContext, ResultsVisitor } from "@allurereport/reader-api";
 export declare const mapToObject: <K extends string | number | symbol, T = any>(map: Map<K, T>) => Record<K, T>;
@@ -21,6 +21,7 @@ export declare class DefaultAllureStore implements AllureStore, ResultsVisitor {
         allowedEnvironments?: string[];
         environmentsConfig?: EnvironmentsConfig;
         reportVariables?: ReportVariables;
+        performance?: PerformanceConfig;
     });
     readHistory(): Promise<HistoryDataPoint[]>;
     appendHistory(history: HistoryDataPoint): Promise<void>;
@@ -35,6 +36,7 @@ export declare class DefaultAllureStore implements AllureStore, ResultsVisitor {
     allGlobalAttachments(): Promise<GlobalAttachmentLink[]>;
     allGlobalAttachmentsByEnv(): Promise<Record<string, GlobalAttachmentLink[]>>;
     visitCheckResult(result: AllureCheckResult): Promise<void>;
+    visitMetrics(metrics: AllurePerformanceResult[], context?: ReaderContext): Promise<void>;
     visitTestResult(raw: RawTestResult, context: ReaderContext): Promise<void>;
     visitTestFixtureResult(result: RawFixtureResult, context: ReaderContext): Promise<void>;
     visitAttachmentFile(resultFile: ResultFile): Promise<void>;
@@ -57,6 +59,7 @@ export declare class DefaultAllureStore implements AllureStore, ResultsVisitor {
     allResolutionIssues(): Promise<ResolutionIssue[]>;
     resolutionIssueByTestResultId(trId: string): Promise<ResolutionIssue | undefined>;
     testResultsByResolutionIssueId(resolutionIssueId: string): Promise<TestResult[]>;
+    allMetrics(): Promise<MetricSample[]>;
     allNewTestResults(filter?: TestResultFilter, history?: HistoryDataPoint[]): Promise<TestResult[]>;
     testCaseById(tcId: string): Promise<TestCase | undefined>;
     testResultById(trId: string): Promise<TestResult | undefined>;

package/dist/store/store.js

@@ -9,9 +9,9 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _DefaultAllureStore_instances, _DefaultAllureStore_testResults, _DefaultAllureStore_environmentDisplayNames, _DefaultAllureStore_environmentNameToId, _DefaultAllureStore_attachments, _DefaultAllureStore_attachmentContents, _DefaultAllureStore_testCases, _DefaultAllureStore_metadata, _DefaultAllureStore_history, _DefaultAllureStore_resolutionsConfig, _DefaultAllureStore_resolutionIssues, _DefaultAllureStore_testResultIdsByResolutionIssueId, _DefaultAllureStore_resolutionIssueIdByTestResultId, _DefaultAllureStore_fixtures, _DefaultAllureStore_defaultLabels, _DefaultAllureStore_environment, _DefaultAllureStore_environmentsConfig, _DefaultAllureStore_reportVariables, _DefaultAllureStore_realtimeDispatcher, _DefaultAllureStore_realtimeSubscriber, _DefaultAllureStore_allowedEnvironmentIds, _DefaultAllureStore_retrySubstore, _DefaultAllureStore_testResultIdsByEnvironmentId, _DefaultAllureStore_cachedEnvironmentEntries, _DefaultAllureStore_globalAttachmentIds, _DefaultAllureStore_globalAttachmentIdsByEnv, _DefaultAllureStore_globalErrors, _DefaultAllureStore_globalErrorsByEnv, _DefaultAllureStore_globalExitCode, _DefaultAllureStore_checkResultsById, _DefaultAllureStore_qualityGateResults, _DefaultAllureStore_historyPoints, _DefaultAllureStore_environments, _DefaultAllureStore_mergeEnvironmentIdentity, _DefaultAllureStore_environmentIdForLookup, _DefaultAllureStore_addEnvironments, _DefaultAllureStore_environmentIdByName, _DefaultAllureStore_setTestResultEnvironmentId, _DefaultAllureStore_assertAllowedEnvironmentId, _DefaultAllureStore_assertAllowedStoredEnvironment, _DefaultAllureStore_environmentIdByTestResult, _DefaultAllureStore_assignRetryHash, _DefaultAllureStore_classifyResolution, _DefaultAllureStore_associateResolutionIssue, _DefaultAllureStore_removeResolutionIssueAssociation, _DefaultAllureStore_rebuildRetrySubstore, _DefaultAllureStore_resolveGlobalEnvironmentIdentity, _DefaultAllureStore_globalAttachmentId, _DefaultAllureStore_indexGlobalError, _DefaultAllureStore_addGlobalError, _DefaultAllureStore_indexGlobalAttachment, _DefaultAllureStore_addGlobalAttachment, _DefaultAllureStore_restoreAttachmentContent, _DefaultAllureStore_relinkRestoredAttachmentSteps, _DefaultAllureStore_retriesByTr, _DefaultAllureStore_historyByTr;
+var _DefaultAllureStore_instances, _DefaultAllureStore_testResults, _DefaultAllureStore_environmentDisplayNames, _DefaultAllureStore_environmentNameToId, _DefaultAllureStore_attachments, _DefaultAllureStore_attachmentContents, _DefaultAllureStore_testCases, _DefaultAllureStore_metadata, _DefaultAllureStore_history, _DefaultAllureStore_resolutionsConfig, _DefaultAllureStore_resolutionIssues, _DefaultAllureStore_testResultIdsByResolutionIssueId, _DefaultAllureStore_resolutionIssueIdByTestResultId, _DefaultAllureStore_fixtures, _DefaultAllureStore_defaultLabels, _DefaultAllureStore_environment, _DefaultAllureStore_environmentsConfig, _DefaultAllureStore_reportVariables, _DefaultAllureStore_realtimeDispatcher, _DefaultAllureStore_realtimeSubscriber, _DefaultAllureStore_allowedEnvironmentIds, _DefaultAllureStore_retrySubstore, _DefaultAllureStore_testResultIdsByEnvironmentId, _DefaultAllureStore_cachedEnvironmentEntries, _DefaultAllureStore_globalAttachmentIds, _DefaultAllureStore_globalAttachmentIdsByEnv, _DefaultAllureStore_globalErrors, _DefaultAllureStore_globalErrorsByEnv, _DefaultAllureStore_globalExitCode, _DefaultAllureStore_checkResultsById, _DefaultAllureStore_qualityGateResults, _DefaultAllureStore_metrics, _DefaultAllureStore_performance, _DefaultAllureStore_historyPoints, _DefaultAllureStore_environments, _DefaultAllureStore_mergeEnvironmentIdentity, _DefaultAllureStore_environmentIdForLookup, _DefaultAllureStore_addEnvironments, _DefaultAllureStore_environmentIdByName, _DefaultAllureStore_setTestResultEnvironmentId, _DefaultAllureStore_assertAllowedEnvironmentId, _DefaultAllureStore_assertAllowedStoredEnvironment, _DefaultAllureStore_environmentIdByTestResult, _DefaultAllureStore_assignRetryHash, _DefaultAllureStore_classifyResolution, _DefaultAllureStore_associateResolutionIssue, _DefaultAllureStore_removeResolutionIssueAssociation, _DefaultAllureStore_rebuildRetrySubstore, _DefaultAllureStore_resolveGlobalEnvironmentIdentity, _DefaultAllureStore_globalAttachmentId, _DefaultAllureStore_indexGlobalError, _DefaultAllureStore_addGlobalError, _DefaultAllureStore_indexGlobalAttachment, _DefaultAllureStore_addGlobalAttachment, _DefaultAllureStore_restoreAttachmentContent, _DefaultAllureStore_relinkRestoredAttachmentSteps, _DefaultAllureStore_retriesByTr, _DefaultAllureStore_historyByTr;
 import { extname } from "node:path";
-import { DEFAULT_ENVIRONMENT, DEFAULT_ENVIRONMENT_IDENTITY, compareBy, createDictionary, getHistoryIdCandidates, getWorstStatus, normalizeHistoryDataPoint, ordinal, reverse, selectHistoryTestResults, validateEnvironmentId, validateEnvironmentName, } from "@allurereport/core-api";
+import { DEFAULT_ENVIRONMENT, DEFAULT_ENVIRONMENT_IDENTITY, compareBy, createDictionary, getHistoryIdCandidates, getWorstStatus, normalizeHistoryDataPoint, ordinal, reverse, resolveMetricSamples, selectHistoryTestResults, validateEnvironmentId, validateEnvironmentName, } from "@allurereport/core-api";
 import { md5, } from "@allurereport/plugin-api";
 import { getResolutionByRules, isIgnoredFailure } from "../resolutions.js";
 import { environmentIdentityById, normalizeEnvironmentDescriptorMap, resolveEnvironmentIdentity, resolveStoredEnvironmentIdentity, validateAllowedEnvironmentId, } from "../utils/environment.js";
@@ -92,9 +92,11 @@ export class DefaultAllureStore {
         _DefaultAllureStore_globalExitCode.set(this, void 0);
         _DefaultAllureStore_checkResultsById.set(this, new Map());
         _DefaultAllureStore_qualityGateResults.set(this, []);
+        _DefaultAllureStore_metrics.set(this, []);
+        _DefaultAllureStore_performance.set(this, {});
         _DefaultAllureStore_historyPoints.set(this, []);
         _DefaultAllureStore_environments.set(this, []);
-        const { history, resolutionsConfig, realtimeDispatcher, realtimeSubscriber, defaultLabels = {}, environment, allowedEnvironments, environmentsConfig = {}, reportVariables = {}, } = params ?? {};
+        const { history, resolutionsConfig, realtimeDispatcher, realtimeSubscriber, defaultLabels = {}, environment, allowedEnvironments, environmentsConfig = {}, reportVariables = {}, performance = {}, } = params ?? {};
         const errors = [];
         const { normalized: normalizedEnvironmentsConfig, identities, errors: configErrors, } = normalizeEnvironmentDescriptorMap(environmentsConfig, "environmentsConfig");
         errors.push(...configErrors);
@@ -120,6 +122,7 @@ export class DefaultAllureStore {
         __classPrivateFieldSet(this, _DefaultAllureStore_fixtures, new Map(), "f");
         __classPrivateFieldSet(this, _DefaultAllureStore_history, history, "f");
         __classPrivateFieldSet(this, _DefaultAllureStore_resolutionsConfig, resolutionsConfig, "f");
+        __classPrivateFieldSet(this, _DefaultAllureStore_performance, performance, "f");
         __classPrivateFieldSet(this, _DefaultAllureStore_realtimeDispatcher, realtimeDispatcher, "f");
         __classPrivateFieldSet(this, _DefaultAllureStore_realtimeSubscriber, realtimeSubscriber, "f");
         __classPrivateFieldSet(this, _DefaultAllureStore_defaultLabels, defaultLabels, "f");
@@ -290,6 +293,13 @@ export class DefaultAllureStore {
     async visitCheckResult(result) {
         await this.addCheckResult(result);
     }
+    async visitMetrics(metrics, context = { readerId: "api" }) {
+        const source = context.metadata?.originalFileName;
+        __classPrivateFieldGet(this, _DefaultAllureStore_metrics, "f").push(...resolveMetricSamples(metrics.map((metric) => ({
+            ...metric,
+            ...(source ? { source } : {}),
+        })), __classPrivateFieldGet(this, _DefaultAllureStore_performance, "f")));
+    }
     async visitTestResult(raw, context) {
         const attachmentLinks = [];
         const testResult = testResultRawToState({
@@ -529,6 +539,9 @@ export class DefaultAllureStore {
             .map((testResultId) => __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f").get(testResultId))
             .filter(Boolean);
     }
+    async allMetrics() {
+        return [...__classPrivateFieldGet(this, _DefaultAllureStore_metrics, "f")];
+    }
     async allNewTestResults(filter, history) {
         if (!__classPrivateFieldGet(this, _DefaultAllureStore_history, "f") && !history) {
             return [];
@@ -673,6 +686,20 @@ export class DefaultAllureStore {
     }
     async testsStatistic(filter) {
         const statistic = { total: 0 };
+        const incrementResolution = (tr) => {
+            if (tr.resolution === "issue") {
+                statistic.resolutions ?? (statistic.resolutions = {});
+                statistic.resolutions.issues = (statistic.resolutions.issues ?? 0) + 1;
+            }
+            if (tr.resolution === "muted") {
+                statistic.resolutions ?? (statistic.resolutions = {});
+                statistic.resolutions.muted = (statistic.resolutions.muted ?? 0) + 1;
+            }
+            if (tr.resolution === "accepted") {
+                statistic.resolutions ?? (statistic.resolutions = {});
+                statistic.resolutions.accepted = (statistic.resolutions.accepted ?? 0) + 1;
+            }
+        };
         for (const [, tr] of __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f")) {
             if (tr.isRetry) {
                 continue;
@@ -691,6 +718,7 @@ export class DefaultAllureStore {
             if (tr.transition === "new") {
                 statistic.new = (statistic.new ?? 0) + 1;
             }
+            incrementResolution(tr);
             if (!statistic[tr.status]) {
                 statistic[tr.status] = 0;
             }
@@ -811,6 +839,7 @@ export class DefaultAllureStore {
             indexFixturesByTestResult: {},
             resolutionIssues: mapToObject(__classPrivateFieldGet(this, _DefaultAllureStore_resolutionIssues, "f")),
             qualityGateResults: __classPrivateFieldGet(this, _DefaultAllureStore_qualityGateResults, "f"),
+            metrics: __classPrivateFieldGet(this, _DefaultAllureStore_metrics, "f"),
             testResultIdsIngestOrder: __classPrivateFieldGet(this, _DefaultAllureStore_retrySubstore, "f").ingestOrderIdsForDump(),
         };
         this.indexAttachmentByFixture.forEach((link, fxId) => {
@@ -834,7 +863,7 @@ export class DefaultAllureStore {
         return storeDump;
     }
     async restoreState(stateDump, attachmentsContents = {}) {
-        const { testResults, attachments, testCases, fixtures, reportVariables, environments, globalAttachmentIds = [], globalErrors = [], checkResults, indexAttachmentByTestResult = {}, indexTestResultByHistoryId = {}, indexTestResultByTestCase = {}, indexTestResultByResolutionIssue = {}, indexAttachmentByFixture = {}, indexFixturesByTestResult = {}, resolutionIssues = {}, qualityGateResults = [], testResultIdsIngestOrder = [], } = stateDump;
+        const { testResults, attachments, testCases, fixtures, reportVariables, environments, globalAttachmentIds = [], globalErrors = [], checkResults, indexAttachmentByTestResult = {}, indexTestResultByHistoryId = {}, indexTestResultByTestCase = {}, indexTestResultByResolutionIssue = {}, indexAttachmentByFixture = {}, indexFixturesByTestResult = {}, resolutionIssues = {}, qualityGateResults = [], metrics = [], testResultIdsIngestOrder = [], } = stateDump;
         const storedEnvironmentAliases = environments.flatMap((environmentValue) => {
             if (typeof environmentValue === "string") {
                 return [{ id: environmentValue, name: environmentValue }];
@@ -1018,9 +1047,10 @@ export class DefaultAllureStore {
             });
             __classPrivateFieldGet(this, _DefaultAllureStore_qualityGateResults, "f").push(result);
         });
+        __classPrivateFieldGet(this, _DefaultAllureStore_metrics, "f").push(...metrics);
     }
 }
-_DefaultAllureStore_testResults = new WeakMap(), _DefaultAllureStore_environmentDisplayNames = new WeakMap(), _DefaultAllureStore_environmentNameToId = new WeakMap(), _DefaultAllureStore_attachments = new WeakMap(), _DefaultAllureStore_attachmentContents = new WeakMap(), _DefaultAllureStore_testCases = new WeakMap(), _DefaultAllureStore_metadata = new WeakMap(), _DefaultAllureStore_history = new WeakMap(), _DefaultAllureStore_resolutionsConfig = new WeakMap(), _DefaultAllureStore_resolutionIssues = new WeakMap(), _DefaultAllureStore_testResultIdsByResolutionIssueId = new WeakMap(), _DefaultAllureStore_resolutionIssueIdByTestResultId = new WeakMap(), _DefaultAllureStore_fixtures = new WeakMap(), _DefaultAllureStore_defaultLabels = new WeakMap(), _DefaultAllureStore_environment = new WeakMap(), _DefaultAllureStore_environmentsConfig = new WeakMap(), _DefaultAllureStore_reportVariables = new WeakMap(), _DefaultAllureStore_realtimeDispatcher = new WeakMap(), _DefaultAllureStore_realtimeSubscriber = new WeakMap(), _DefaultAllureStore_allowedEnvironmentIds = new WeakMap(), _DefaultAllureStore_retrySubstore = new WeakMap(), _DefaultAllureStore_testResultIdsByEnvironmentId = new WeakMap(), _DefaultAllureStore_cachedEnvironmentEntries = new WeakMap(), _DefaultAllureStore_globalAttachmentIds = new WeakMap(), _DefaultAllureStore_globalAttachmentIdsByEnv = new WeakMap(), _DefaultAllureStore_globalErrors = new WeakMap(), _DefaultAllureStore_globalErrorsByEnv = new WeakMap(), _DefaultAllureStore_globalExitCode = new WeakMap(), _DefaultAllureStore_checkResultsById = new WeakMap(), _DefaultAllureStore_qualityGateResults = new WeakMap(), _DefaultAllureStore_historyPoints = new WeakMap(), _DefaultAllureStore_environments = new WeakMap(), _DefaultAllureStore_instances = new WeakSet(), _DefaultAllureStore_mergeEnvironmentIdentity = function _DefaultAllureStore_mergeEnvironmentIdentity(existingEnvironment, incomingEnvironment) {
+_DefaultAllureStore_testResults = new WeakMap(), _DefaultAllureStore_environmentDisplayNames = new WeakMap(), _DefaultAllureStore_environmentNameToId = new WeakMap(), _DefaultAllureStore_attachments = new WeakMap(), _DefaultAllureStore_attachmentContents = new WeakMap(), _DefaultAllureStore_testCases = new WeakMap(), _DefaultAllureStore_metadata = new WeakMap(), _DefaultAllureStore_history = new WeakMap(), _DefaultAllureStore_resolutionsConfig = new WeakMap(), _DefaultAllureStore_resolutionIssues = new WeakMap(), _DefaultAllureStore_testResultIdsByResolutionIssueId = new WeakMap(), _DefaultAllureStore_resolutionIssueIdByTestResultId = new WeakMap(), _DefaultAllureStore_fixtures = new WeakMap(), _DefaultAllureStore_defaultLabels = new WeakMap(), _DefaultAllureStore_environment = new WeakMap(), _DefaultAllureStore_environmentsConfig = new WeakMap(), _DefaultAllureStore_reportVariables = new WeakMap(), _DefaultAllureStore_realtimeDispatcher = new WeakMap(), _DefaultAllureStore_realtimeSubscriber = new WeakMap(), _DefaultAllureStore_allowedEnvironmentIds = new WeakMap(), _DefaultAllureStore_retrySubstore = new WeakMap(), _DefaultAllureStore_testResultIdsByEnvironmentId = new WeakMap(), _DefaultAllureStore_cachedEnvironmentEntries = new WeakMap(), _DefaultAllureStore_globalAttachmentIds = new WeakMap(), _DefaultAllureStore_globalAttachmentIdsByEnv = new WeakMap(), _DefaultAllureStore_globalErrors = new WeakMap(), _DefaultAllureStore_globalErrorsByEnv = new WeakMap(), _DefaultAllureStore_globalExitCode = new WeakMap(), _DefaultAllureStore_checkResultsById = new WeakMap(), _DefaultAllureStore_qualityGateResults = new WeakMap(), _DefaultAllureStore_metrics = new WeakMap(), _DefaultAllureStore_performance = new WeakMap(), _DefaultAllureStore_historyPoints = new WeakMap(), _DefaultAllureStore_environments = new WeakMap(), _DefaultAllureStore_instances = new WeakSet(), _DefaultAllureStore_mergeEnvironmentIdentity = function _DefaultAllureStore_mergeEnvironmentIdentity(existingEnvironment, incomingEnvironment) {
     const configuredEnvironment = environmentIdentityById(__classPrivateFieldGet(this, _DefaultAllureStore_environmentsConfig, "f"), incomingEnvironment.id);
     if (configuredEnvironment) {
         return configuredEnvironment;
@@ -1125,6 +1155,7 @@ _DefaultAllureStore_testResults = new WeakMap(), _DefaultAllureStore_environment
 }, _DefaultAllureStore_classifyResolution = function _DefaultAllureStore_classifyResolution(testResult) {
     const rule = getResolutionByRules(testResult, __classPrivateFieldGet(this, _DefaultAllureStore_resolutionsConfig, "f"));
     testResult.resolution = rule?.resolution;
+    testResult.resolutionComment = rule?.comment;
     __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_removeResolutionIssueAssociation).call(this, testResult.id);
     if (rule?.resolution !== "issue") {
         return;

package/dist/utils/artifacts.d.ts

@@ -0,0 +1,14 @@
+export declare const ARTIFACTS_MANIFEST_FILENAME = "artifacts.json";
+export type ReportArtifact = {
+    name: string;
+    path: string;
+};
+export type ReportArtifactsManifest = ReportArtifact[];
+export type RestoreStateDumpInput = {
+    artifactPath?: string;
+    path: string;
+    recordArtifact?: boolean;
+};
+export declare const normalizeArtifactPath: (filePath: string, cwd: string) => string;
+export declare const createReportArtifact: (filePath: string, cwd: string, name?: string) => ReportArtifact;
+export declare const deduplicateDumpInputs: (dumps: RestoreStateDumpInput[], cwd: string) => RestoreStateDumpInput[];

package/dist/utils/artifacts.js

@@ -0,0 +1,35 @@
+import { realpathSync } from "node:fs";
+import { basename, relative, resolve, sep } from "node:path";
+export const ARTIFACTS_MANIFEST_FILENAME = "artifacts.json";
+const existingRealPath = (filePath) => {
+    try {
+        return realpathSync(filePath);
+    }
+    catch {
+        return filePath;
+    }
+};
+export const normalizeArtifactPath = (filePath, cwd) => {
+    const path = relative(resolve(cwd), resolve(cwd, filePath)).split(sep).join("/");
+    return path || ".";
+};
+export const createReportArtifact = (filePath, cwd, name = basename(filePath)) => ({
+    name,
+    path: normalizeArtifactPath(filePath, cwd),
+});
+export const deduplicateDumpInputs = (dumps, cwd) => {
+    const seen = new Set();
+    return dumps.reduce((acc, dump) => {
+        const absolutePath = resolve(cwd, dump.path);
+        const dedupeKey = existingRealPath(absolutePath);
+        if (seen.has(dedupeKey)) {
+            return acc;
+        }
+        seen.add(dedupeKey);
+        acc.push({
+            ...dump,
+            path: absolutePath,
+        });
+        return acc;
+    }, []);
+};

package/dist/utils/perf.d.ts

@@ -1,4 +1,6 @@
-export declare const PERF_METRICS_FILE = "allure-perf-metrics.json";
+import type { AllurePerformanceResult } from "@allurereport/core-api";
+export declare const PERF_METRICS_FILE = "performance.json";
+export declare const perfMetricsFileName: (reportUuid: string) => string;
 export type PerfMetricSpan = {
     name: string;
     startTimeMs: number;
@@ -12,14 +14,8 @@ export type PerfMetricSummary = {
     maxMs: number;
     avgMs: number;
 };
-export type PerfMetricsPayload = {
-    version: 1;
-    generatedAt: string;
-    timeOriginMs: number;
-    spans: PerfMetricSpan[];
-    summary: PerfMetricSummary[];
-};
 export declare const PERF_METRIC_NAMES: {
+    readonly allureTotal: "allure.total";
     readonly restoreStateTotal: "restoreState.total";
     readonly restoreStateDump: "restoreState.dump";
     readonly restoreStateAttachments: "restoreState.attachments";
@@ -37,6 +33,6 @@ export declare const PERF_METRIC_PREFIXES: {
 export declare const isPerfMetricsEnabled: () => boolean;
 export declare const startPerfSpan: (name: string) => (() => void);
 export declare const measurePerf: <T>(name: string, fn: () => Promise<T>) => Promise<T>;
-export declare const getPerfMetricsPayload: () => PerfMetricsPayload;
-export declare const writePerfMetrics: (output: string) => Promise<boolean>;
+export declare const getPerfMetricsResults: () => AllurePerformanceResult[];
+export declare const writePerfMetrics: (output: string, fileName?: string) => Promise<boolean>;
 export declare const resetPerfMetrics: () => void;

package/dist/utils/perf.js

@@ -1,7 +1,9 @@
+import { randomUUID } from "node:crypto";
 import { mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { performance } from "node:perf_hooks";
-export const PERF_METRICS_FILE = "allure-perf-metrics.json";
+export const PERF_METRICS_FILE = "performance.json";
+export const perfMetricsFileName = (reportUuid) => `${reportUuid}-perf.json`;
 const MARK_PREFIX = "allure:perf:";
 const ENABLED_VALUES = new Set(["1", "true", "yes", "on"]);
 const SPANS = [];
@@ -10,6 +12,7 @@ const MEASURES = new Set();
 let sequence = 0;
 const round = (value) => Number(value.toFixed(3));
 export const PERF_METRIC_NAMES = {
+    allureTotal: "allure.total",
     restoreStateTotal: "restoreState.total",
     restoreStateDump: "restoreState.dump",
     restoreStateAttachments: "restoreState.attachments",
@@ -24,6 +27,22 @@ export const PERF_METRIC_PREFIXES = {
     generatePluginDone: "generate.plugin.done.",
     publishUploadPlugin: "publish.upload.plugin.",
 };
+const getCoveredDurationSummary = () => {
+    if (SPANS.length === 0) {
+        return undefined;
+    }
+    const startTimeMs = Math.min(...SPANS.map(({ startTimeMs }) => startTimeMs));
+    const endTimeMs = Math.max(...SPANS.map(({ startTimeMs, durationMs }) => startTimeMs + durationMs));
+    const durationMs = round(endTimeMs - startTimeMs);
+    return {
+        name: PERF_METRIC_NAMES.allureTotal,
+        count: 1,
+        totalMs: durationMs,
+        minMs: durationMs,
+        maxMs: durationMs,
+        avgMs: durationMs,
+    };
+};
 export const isPerfMetricsEnabled = () => ENABLED_VALUES.has((process.env.ALLURE_PERF_METRICS ?? "").toLowerCase());
 export const startPerfSpan = (name) => {
     if (!isPerfMetricsEnabled()) {
@@ -72,39 +91,33 @@ export const measurePerf = async (name, fn) => {
         end();
     }
 };
-export const getPerfMetricsPayload = () => {
-    const byName = new Map();
-    for (const span of SPANS) {
-        const current = byName.get(span.name) ?? [];
-        current.push(span);
-        byName.set(span.name, current);
+export const getPerfMetricsResults = () => {
+    const totalSummary = getCoveredDurationSummary();
+    const results = SPANS.map((span) => ({
+        id: randomUUID(),
+        key: span.name,
+        value: span.durationMs,
+        start: round(performance.timeOrigin + span.startTimeMs),
+        stop: round(performance.timeOrigin + span.startTimeMs + span.durationMs),
+    }));
+    if (totalSummary) {
+        results.unshift({
+            id: randomUUID(),
+            key: PERF_METRIC_NAMES.allureTotal,
+            value: totalSummary.avgMs,
+            start: round(performance.timeOrigin + Math.min(...SPANS.map(({ startTimeMs }) => startTimeMs))),
+            stop: round(performance.timeOrigin + Math.max(...SPANS.map(({ startTimeMs, durationMs }) => startTimeMs + durationMs))),
+        });
     }
-    return {
-        version: 1,
-        generatedAt: new Date().toISOString(),
-        timeOriginMs: round(performance.timeOrigin),
-        spans: [...SPANS],
-        summary: [...byName.entries()].map(([name, group]) => {
-            const durations = group.map(({ durationMs }) => durationMs);
-            const totalMs = durations.reduce((acc, duration) => acc + duration, 0);
-            return {
-                name,
-                count: group.length,
-                totalMs: round(totalMs),
-                minMs: round(Math.min(...durations)),
-                maxMs: round(Math.max(...durations)),
-                avgMs: round(totalMs / group.length),
-            };
-        }),
-    };
+    return results;
 };
-export const writePerfMetrics = async (output) => {
+export const writePerfMetrics = async (output, fileName = PERF_METRICS_FILE) => {
     if (!isPerfMetricsEnabled()) {
         return false;
     }
-    const payload = getPerfMetricsPayload();
+    const results = getPerfMetricsResults();
     await mkdir(output, { recursive: true });
-    await writeFile(join(output, PERF_METRICS_FILE), `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+    await writeFile(join(output, fileName), `${JSON.stringify(results, null, 2)}\n`, "utf8");
     resetPerfMetrics();
     return true;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/core",
-  "version": "3.16.1",
+  "version": "3.17.0",
   "description": "Collection of generic Allure utilities used across the entire project",
   "keywords": [
     "allure"
@@ -25,26 +25,26 @@
     "lint:fix": "oxlint --import-plugin --fix src test features stories"
   },
   "dependencies": {
-    "@allurereport/ci": "3.16.1",
-    "@allurereport/cli-commons": "3.16.1",
-    "@allurereport/core-api": "3.16.1",
-    "@allurereport/plugin-agent": "3.16.1",
-    "@allurereport/plugin-allure2": "3.16.1",
-    "@allurereport/plugin-api": "3.16.1",
-    "@allurereport/plugin-awesome": "3.16.1",
-    "@allurereport/plugin-classic": "3.16.1",
-    "@allurereport/plugin-csv": "3.16.1",
-    "@allurereport/plugin-dashboard": "3.16.1",
-    "@allurereport/plugin-jira": "3.16.1",
-    "@allurereport/plugin-log": "3.16.1",
-    "@allurereport/plugin-progress": "3.16.1",
-    "@allurereport/plugin-slack": "3.16.1",
-    "@allurereport/plugin-testops": "3.16.1",
-    "@allurereport/plugin-testplan": "3.16.1",
-    "@allurereport/reader": "3.16.1",
-    "@allurereport/reader-api": "3.16.1",
-    "@allurereport/service": "3.16.1",
-    "@allurereport/summary": "3.16.1",
+    "@allurereport/ci": "3.17.0",
+    "@allurereport/cli-commons": "3.17.0",
+    "@allurereport/core-api": "3.17.0",
+    "@allurereport/plugin-agent": "3.17.0",
+    "@allurereport/plugin-allure2": "3.17.0",
+    "@allurereport/plugin-api": "3.17.0",
+    "@allurereport/plugin-awesome": "3.17.0",
+    "@allurereport/plugin-classic": "3.17.0",
+    "@allurereport/plugin-csv": "3.17.0",
+    "@allurereport/plugin-dashboard": "3.17.0",
+    "@allurereport/plugin-jira": "3.17.0",
+    "@allurereport/plugin-log": "3.17.0",
+    "@allurereport/plugin-progress": "3.17.0",
+    "@allurereport/plugin-slack": "3.17.0",
+    "@allurereport/plugin-testops": "3.17.0",
+    "@allurereport/plugin-testplan": "3.17.0",
+    "@allurereport/reader": "3.17.0",
+    "@allurereport/reader-api": "3.17.0",
+    "@allurereport/service": "3.17.0",
+    "@allurereport/summary": "3.17.0",
     "glob": "^13.0.6",
     "handlebars": "^4.7.9",
     "jiti": "^2.5.1",