@allurereport/core 3.19.0 → 3.20.0

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, metricMaxRule, metricMinRule, metricMaxDeltaRule, metricMaxDeltaPercentRule, convertQualityGateResultsToTestErrors, filterFailedQualityGateResults, stringifyQualityGateResults, } from "./qualityGate/index.js";
+export { QualityGateState, qualityGateDefaultRules, maxFailuresRule, minTestsCountRule, newTestsRule, successRateRule, maxDurationRule, allTestsContainEnvRule, environmentsTestedRule, metricMaxRule, metricMinRule, metricMaxDeltaRule, metricMaxDeltaPercentRule, convertQualityGateResultsToTestErrors, filterFailedQualityGateResults, 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, metricMaxRule, metricMinRule, metricMaxDeltaRule, metricMaxDeltaPercentRule, convertQualityGateResultsToTestErrors, filterFailedQualityGateResults, stringifyQualityGateResults, } from "./qualityGate/index.js";
+export { QualityGateState, qualityGateDefaultRules, maxFailuresRule, minTestsCountRule, newTestsRule, successRateRule, maxDurationRule, allTestsContainEnvRule, environmentsTestedRule, metricMaxRule, metricMinRule, metricMaxDeltaRule, metricMaxDeltaPercentRule, convertQualityGateResultsToTestErrors, filterFailedQualityGateResults, stringifyQualityGateResults, } from "./qualityGate/index.js";

package/dist/qualityGate/rules.d.ts

@@ -7,6 +7,7 @@ type MetricRuleConfig = {
 };
 export declare const maxFailuresRule: QualityGateRule<number>;
 export declare const minTestsCountRule: QualityGateRule<number>;
+export declare const newTestsRule: QualityGateRule<boolean, number>;
 export declare const successRateRule: QualityGateRule<number>;
 export declare const maxDurationRule: QualityGateRule<number>;
 export declare const allTestsContainEnvRule: QualityGateRule<string, number>;
@@ -15,5 +16,5 @@ 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 declare const qualityGateDefaultRules: (QualityGateRule<number> | QualityGateRule<boolean, number> | QualityGateRule<string, number> | QualityGateRule<string[]> | QualityGateRule<MetricRuleConfig>)[];
 export {};

package/dist/qualityGate/rules.js

@@ -106,6 +106,25 @@ export const minTestsCountRule = {
         };
     },
 };
+export const newTestsRule = {
+    rule: "newTests",
+    message: ({ actual, expected }) => expected
+        ? `No new tests were found; expected at least one new test`
+        : `The number of new tests ${bold(String(actual))} does not match the expected policy`,
+    successMessage: ({ actual }) => `New tests were found: ${bold(String(actual))}`,
+    validate: async ({ trs, expected, state }) => {
+        const previous = numberStateValue(state.getResult());
+        const newTrs = trs.filter((tr) => tr.transition === "new");
+        const testResults = newTrs.map((tr) => tr.id);
+        const actual = previous + newTrs.length;
+        state.setResult(actual, testResults);
+        return {
+            success: !expected || actual > 0,
+            actual,
+            testResults,
+        };
+    },
+};
 export const successRateRule = {
     rule: "successRate",
     message: ({ actual, expected }) => `Success rate ${bold(formatQualityGateNumber(actual))} is less, than expected ${bold(formatQualityGateNumber(expected))}`,
@@ -237,6 +256,7 @@ export const metricMaxDeltaPercentRule = {
 export const qualityGateDefaultRules = [
     maxFailuresRule,
     minTestsCountRule,
+    newTestsRule,
     successRateRule,
     maxDurationRule,
     allTestsContainEnvRule,

package/dist/report.js

@@ -14,7 +14,7 @@ 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 { lstat, mkdtemp, readdir, rename, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
 import { promisify } from "node:util";
@@ -22,7 +22,7 @@ import { detect } from "@allurereport/ci";
 import { createProgressLogger } from "@allurereport/cli-commons";
 import { normalizeCategoriesConfig, parseIntegerConfigValue } from "@allurereport/core-api";
 import { AllureStoreDumpFiles, createTestResultRegistry, } from "@allurereport/plugin-api";
-import { allure1, allure2, attachments, cucumberjson, junitXml, readXcResultBundle } from "@allurereport/reader";
+import { allure1, allure2, attachments, cucumberjson, cucumberMessages, junitXml, readXcResultBundle, } from "@allurereport/reader";
 import { PathResultFile } from "@allurereport/reader-api";
 import { AllureRemoteHistory, AllureServiceClient, AllureTestOpsClient, KnownError, UnknownError, } from "@allurereport/service";
 import { generateSummary } from "@allurereport/summary";
@@ -37,7 +37,7 @@ 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 { getPerfMetricsResults, isPerfMetricsEnabled, measurePerf, PERF_METRIC_NAMES, PERF_METRIC_PREFIXES, perfMetricsFileName, startPerfSpan, writePerfMetrics, } from "./utils/perf.js";
+import { getPerfMetricsResults, incrementPerfCounter, isPerfMetricsEnabled, measurePerfAggregate, 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";
@@ -53,6 +53,11 @@ const ROOT_INTEGRATION_FILENAMES = new Set([
     QUALITY_GATE_RESULTS_FILENAME,
     ARTIFACTS_MANIFEST_FILENAME,
 ]);
+const WORKLOAD_PERF_METRIC = {
+    group: "workload",
+    groupTitle: "Workload",
+    better: "neutral",
+};
 const readConcurrency = () => {
     const parsed = Number.parseInt(process.env.ALLURE_READ_CONCURRENCY ?? "", 10);
     if (!Number.isFinite(parsed)) {
@@ -76,9 +81,7 @@ const getExecutorReportUrl = (executor) => {
         return undefined;
     }
     try {
-        const navUrl = new URL(reportUrl);
-        navUrl.pathname = navUrl.pathname.endsWith("/") ? navUrl.pathname : `${navUrl.pathname}/`;
-        return navUrl.toString();
+        return new URL(reportUrl).toString();
     }
     catch {
         return undefined;
@@ -298,19 +301,23 @@ export class AllureReport {
                 throw new Error(INIT_REQUIRED_ERROR_MESSAGE);
             }
             const resultsDirPath = resolve(resultsDir);
-            if (await readXcResultBundle(__classPrivateFieldGet(this, _AllureReport_store, "f"), resultsDirPath)) {
+            if (await measurePerf(PERF_METRIC_NAMES.generateReadResultsXcresultCheck, () => readXcResultBundle(__classPrivateFieldGet(this, _AllureReport_store, "f"), resultsDirPath))) {
                 __classPrivateFieldGet(this, _AllureReport_store, "f").updateHistoryFlags();
                 return;
             }
             try {
-                const entries = (await readdir(resultsDirPath, { withFileTypes: true }))
+                const entries = await measurePerf(PERF_METRIC_NAMES.generateReadResultsReaddir, async () => (await readdir(resultsDirPath, { withFileTypes: true }))
                     .filter((dirent) => dirent.isFile() && !dirent.name.endsWith(".tmp"))
-                    .sort((a, b) => a.name.localeCompare(b.name));
+                    .sort((a, b) => a.name.localeCompare(b.name)));
                 const limit = pLimit(readConcurrency());
+                incrementPerfCounter(PERF_METRIC_NAMES.generateReadResultsFiles, entries.length, {
+                    ...WORKLOAD_PERF_METRIC,
+                    title: "Input files",
+                    unit: "files",
+                });
                 await Promise.all(entries.map((dirent) => limit(async () => {
                     try {
-                        const path = await realpath(join(resultsDirPath, dirent.name));
-                        await this.readResult(new PathResultFile(path, dirent.name));
+                        await this.readResult(new PathResultFile(join(resultsDirPath, dirent.name), dirent.name));
                     }
                     catch (e) {
                         console.error(`can't read result file ${dirent.name}`, e);
@@ -338,7 +345,7 @@ export class AllureReport {
                     if (reader.matches && !(await reader.matches(data))) {
                         continue;
                     }
-                    const processed = await reader.read(__classPrivateFieldGet(this, _AllureReport_store, "f"), data);
+                    const processed = await measurePerfAggregate(PERF_METRIC_NAMES.generateReadResultsReaderRead, () => reader.read(__classPrivateFieldGet(this, _AllureReport_store, "f"), data));
                     if (processed) {
                         return;
                     }
@@ -457,7 +464,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 = {}, indexTestResultByRetryHash = {}, indexTestResultByTestCase = {}, indexTestResultByResolutionIssue = {}, indexAttachmentByFixture = {}, indexFixturesByTestResult = {}, resolutionIssues = {}, qualityGateResults = [], testResultIdsIngestOrder = [], metrics = [], }) => [
+            const dumpJsonEntries = ({ testResults, testCases, fixtures, attachments, environments, reportVariables, metadata = {}, checkResults = {}, globalAttachmentIds = [], globalErrors = [], indexAttachmentByTestResult = {}, indexTestResultByRetryHash = {}, indexTestResultByTestCase = {}, indexTestResultByResolutionIssue = {}, indexAttachmentByFixture = {}, indexFixturesByTestResult = {}, resolutionIssues = {}, qualityGateResults = [], testResultIdsIngestOrder = [], metrics = [], }) => [
                 [AllureStoreDumpFiles.TestResults, testResults],
                 [AllureStoreDumpFiles.TestCases, testCases],
                 [AllureStoreDumpFiles.Fixtures, fixtures],
@@ -465,6 +472,7 @@ export class AllureReport {
                 [AllureStoreDumpFiles.CheckResults, checkResults],
                 [AllureStoreDumpFiles.Environments, environments],
                 [AllureStoreDumpFiles.ReportVariables, reportVariables],
+                [AllureStoreDumpFiles.Metadata, metadata],
                 [AllureStoreDumpFiles.ResolutionIssues, resolutionIssues],
                 [AllureStoreDumpFiles.GlobalAttachments, globalAttachmentIds],
                 [AllureStoreDumpFiles.GlobalErrors, globalErrors],
@@ -613,6 +621,7 @@ export class AllureReport {
                             const checkResultsEntry = await optionalEntryData(AllureStoreDumpFiles.CheckResults);
                             const environmentsEntry = await requiredEntryData(AllureStoreDumpFiles.Environments);
                             const reportVariablesEntry = await requiredEntryData(AllureStoreDumpFiles.ReportVariables);
+                            const metadataEntry = await optionalEntryData(AllureStoreDumpFiles.Metadata);
                             const globalAttachmentsEntry = await requiredEntryData(AllureStoreDumpFiles.GlobalAttachments);
                             const globalErrorsEntry = await requiredEntryData(AllureStoreDumpFiles.GlobalErrors);
                             const indexAttachmentsEntry = await requiredEntryData(AllureStoreDumpFiles.IndexAttachmentsByTestResults);
@@ -633,6 +642,7 @@ export class AllureReport {
                                     case AllureStoreDumpFiles.Fixtures:
                                     case AllureStoreDumpFiles.Environments:
                                     case AllureStoreDumpFiles.ReportVariables:
+                                    case AllureStoreDumpFiles.Metadata:
                                     case AllureStoreDumpFiles.ResolutionIssues:
                                     case AllureStoreDumpFiles.GlobalAttachments:
                                     case AllureStoreDumpFiles.GlobalErrors:
@@ -663,6 +673,7 @@ export class AllureReport {
                                 checkResults: checkResultsEntry ? JSON.parse(checkResultsEntry.toString("utf8")) : [],
                                 environments: JSON.parse(environmentsEntry.toString("utf8")),
                                 reportVariables: JSON.parse(reportVariablesEntry.toString("utf8")),
+                                metadata: metadataEntry ? JSON.parse(metadataEntry.toString("utf8")) : {},
                                 globalAttachmentIds: JSON.parse(globalAttachmentsEntry.toString("utf8")),
                                 globalErrors: JSON.parse(globalErrorsEntry.toString("utf8")),
                                 indexAttachmentByTestResult: JSON.parse(indexAttachmentsEntry.toString("utf8")),
@@ -978,6 +989,11 @@ export class AllureReport {
                     await pluginState.set("files", {});
                 }
                 const pluginFiles = new PluginFiles(__classPrivateFieldGet(this, _AllureReport_reportFiles, "f"), id, async (key, filepath) => {
+                    incrementPerfCounter(`${PERF_METRIC_PREFIXES.generatePlugin}${id}.generatedFiles`, 1, {
+                        ...WORKLOAD_PERF_METRIC,
+                        title: `Generated ${id} files`,
+                        unit: "files",
+                    });
                     const currentPluginState = __classPrivateFieldGet(this, _AllureReport_instances, "m", _AllureReport_getPluginState).call(this, false, id);
                     const files = await currentPluginState?.get("files");
                     if (!files) {
@@ -994,6 +1010,14 @@ export class AllureReport {
                     hideLabels: __classPrivateFieldGet(this, _AllureReport_hideLabels, "f"),
                     state: pluginState,
                     reportFiles: pluginFiles,
+                    ...(isPerfMetricsEnabled()
+                        ? {
+                            perf: {
+                                measure: (name, fn) => measurePerf(`${PERF_METRIC_PREFIXES.generatePlugin}${id}.${name}`, fn),
+                                count: (name, value, metadata) => incrementPerfCounter(`${PERF_METRIC_PREFIXES.generatePlugin}${id}.${name}`, value, metadata),
+                            },
+                        }
+                        : {}),
                     reportUrl: this.reportUrl,
                     realTime: !!__classPrivateFieldGet(this, _AllureReport_realTime, "f"),
                     output: __classPrivateFieldGet(this, _AllureReport_output, "f"),
@@ -1013,7 +1037,7 @@ export class AllureReport {
                 }
             }
         });
-        const { name, readers = [allure1, allure2, cucumberjson, junitXml, attachments], plugins = [], resolutions, reportFiles, realTime, historyPath, historyBaseUrl, historyLimit, flakyDetection, appendHistory, defaultLabels = {}, variables = {}, environment, allowedEnvironments, environments, output, hideLabels, qualityGate, performance, dump, categories, allureService, globalAttachments, cwd, } = opts;
+        const { name, readers = [allure1, allure2, cucumberjson, cucumberMessages, junitXml, attachments], plugins = [], resolutions, reportFiles, realTime, historyPath, historyBaseUrl, historyLimit, flakyDetection, appendHistory, defaultLabels = {}, variables = {}, environment, allowedEnvironments, environments, output, hideLabels, qualityGate, performance, dump, categories, allureService, globalAttachments, cwd, } = opts;
         const allureServiceAccessToken = allureService?.accessToken;
         if (allureServiceAccessToken) {
             const allureServiceClientConfig = {

package/dist/resolutions.d.ts

@@ -1,4 +1,4 @@
-import type { ResolutionRule, ResolutionsConfig, TestResult } from "@allurereport/core-api";
+import type { IssueResolutionRule, ResolutionIssue, ResolutionRule, ResolutionsConfig, TestResult } from "@allurereport/core-api";
 import type { AllureStore } from "@allurereport/plugin-api";
 export declare const DEFAULT_KNOWN_ISSUES_PATH = "known-issues.json";
 export declare const validateResolutionsConfig: (config?: ResolutionsConfig) => void;
@@ -12,5 +12,6 @@ export declare const KNOWN_FROM_RESULT_RESOLUTION: {
 };
 export declare const getResolutionByRules: (testResult: TestResult, config?: ResolutionsConfig) => ResolutionRule | undefined;
 export declare const isIgnoredFailure: (testResult: TestResult) => boolean;
+export declare const createResolutionIssue: (rule: IssueResolutionRule, config?: ResolutionsConfig) => ResolutionIssue;
 export declare const resolveExactIssuesFilePath: (pathOrDir: string | undefined, label: string) => Promise<string | undefined>;
 export declare const writeKnownIssues: (store: AllureStore, knownIssuesPath?: string) => Promise<void>;

package/dist/resolutions.js

@@ -52,7 +52,7 @@ const validateIssueUrl = (rule, template, errors) => {
     }
     let url;
     try {
-        url = new URL(template.urlTemplate.replace("%s", encodeURIComponent(rule.issue.id)));
+        url = new URL(template.urlTemplate.replace("%s", () => encodeURIComponent(rule.issue.id)));
     }
     catch {
         errors.push(`resolutions.links.${rule.issue.type}.urlTemplate must resolve to an absolute URL`);
@@ -155,6 +155,21 @@ export const getResolutionByRules = (testResult, config) => {
     return undefined;
 };
 export const isIgnoredFailure = (testResult) => testResult.resolution === "muted" || testResult.resolution === "accepted";
+export const createResolutionIssue = (rule, config) => {
+    const template = config?.links?.[rule.issue.type];
+    const issue = { ...rule.issue, comment: rule.comment };
+    if (!template) {
+        return issue;
+    }
+    return {
+        ...issue,
+        link: {
+            name: template.nameTemplate?.replace("%s", () => rule.issue.id) ?? rule.issue.id,
+            url: template.urlTemplate.replace("%s", () => encodeURIComponent(rule.issue.id)),
+            type: rule.issue.type,
+        },
+    };
+};
 export const resolveExactIssuesFilePath = async (pathOrDir, label) => {
     if (!pathOrDir)
         return undefined;

package/dist/store/retrySubstore.js

@@ -48,15 +48,18 @@ export class RetrySubstore {
         });
     }
     retriesByTr(testResult) {
-        if (!testResult.retryHash || testResult.isRetry) {
+        if (!testResult.retryHash) {
             return NO_RETRIES;
         }
         const attempts = __classPrivateFieldGet(this, _RetrySubstore_testResultsByRetryHash, "f").get(testResult.retryHash) ?? [];
+        if (attempts.length <= 1) {
+            return NO_RETRIES;
+        }
         const index = attempts.findIndex((attempt) => attempt.id === testResult.id);
-        if (index !== 0) {
+        if (index === -1) {
             return NO_RETRIES;
         }
-        return attempts.slice(1);
+        return attempts.filter((attempt) => attempt.id !== testResult.id);
     }
     reset() {
         __classPrivateFieldGet(this, _RetrySubstore_testResultsByRetryHash, "f").clear();

package/dist/store/store.js

@@ -13,10 +13,11 @@ var _DefaultAllureStore_instances, _DefaultAllureStore_testResults, _DefaultAllu
 import { extname } from "node:path";
 import { DEFAULT_ENVIRONMENT, DEFAULT_ENVIRONMENT_IDENTITY, calculateEnvironmentHash, calculateParametersHash, calculateRetryHash, calculateTestCaseHash, compareBy, createDictionary, fallbackTestCaseIdLabelName, getWorstStatus, createHistoryTestResultLookup, normalizeHistoryDataPoint, ordinal, reverse, resolveMetricSamples, validateEnvironmentId, validateEnvironmentName, } from "@allurereport/core-api";
 import { md5, } from "@allurereport/plugin-api";
-import { getResolutionByRules, isIgnoredFailure } from "../resolutions.js";
+import { createResolutionIssue, getResolutionByRules, isIgnoredFailure } from "../resolutions.js";
 import { environmentIdentityById, normalizeEnvironmentDescriptorMap, resolveEnvironmentIdentity, resolveStoredEnvironmentIdentity, validateAllowedEnvironmentId, } from "../utils/environment.js";
 import { createFlakyDetector } from "../utils/flaky.js";
 import { getStatusTransition } from "../utils/new.js";
+import { measurePerfAggregateSync, PERF_METRIC_NAMES } from "../utils/perf.js";
 import { testFixtureResultRawToState, testResultRawToState } from "./convert.js";
 import { RetrySubstore } from "./retrySubstore.js";
 const index = (indexMap, key, ...items) => {
@@ -348,58 +349,71 @@ export class DefaultAllureStore {
     }
     async visitTestResult(raw, context) {
         const attachmentLinks = [];
-        const testResult = testResultRawToState({
+        const testResult = measurePerfAggregateSync(PERF_METRIC_NAMES.storeVisitTestResultConvert, () => testResultRawToState({
             testCases: __classPrivateFieldGet(this, _DefaultAllureStore_testCases, "f"),
             attachments: __classPrivateFieldGet(this, _DefaultAllureStore_attachments, "f"),
             visitAttachmentLink: (link) => attachmentLinks.push(link),
-        }, raw, context);
-        const defaultLabelsNames = Object.keys(__classPrivateFieldGet(this, _DefaultAllureStore_defaultLabels, "f"));
-        if (defaultLabelsNames.length) {
-            defaultLabelsNames.forEach((labelName) => {
-                if (!testResult.labels.find((label) => label.name === labelName)) {
-                    const defaultLabelValue = __classPrivateFieldGet(this, _DefaultAllureStore_defaultLabels, "f")[labelName];
-                    [].concat(defaultLabelValue).forEach((labelValue) => {
-                        testResult.labels.push({
-                            name: labelName,
-                            value: labelValue,
+        }, raw, context));
+        measurePerfAggregateSync(PERF_METRIC_NAMES.storeVisitTestResultDefaultLabels, () => {
+            const defaultLabelsNames = Object.keys(__classPrivateFieldGet(this, _DefaultAllureStore_defaultLabels, "f"));
+            if (defaultLabelsNames.length) {
+                defaultLabelsNames.forEach((labelName) => {
+                    if (!testResult.labels.find((label) => label.name === labelName)) {
+                        const defaultLabelValue = __classPrivateFieldGet(this, _DefaultAllureStore_defaultLabels, "f")[labelName];
+                        [].concat(defaultLabelValue).forEach((labelValue) => {
+                            testResult.labels.push({
+                                name: labelName,
+                                value: labelValue,
+                            });
                         });
-                    });
-                }
+                    }
+                });
+            }
+        });
+        const environmentIdentity = measurePerfAggregateSync(PERF_METRIC_NAMES.storeVisitTestResultEnvironment, () => {
+            const environmentMatcherLabels = testResult.labels.filter(({ name }) => name !== "ALLURE_ID" && name !== fallbackTestCaseIdLabelName);
+            const environmentMatch = __classPrivateFieldGet(this, _DefaultAllureStore_environment, "f")
+                ? undefined
+                : Object.entries(__classPrivateFieldGet(this, _DefaultAllureStore_environmentsConfig, "f")).find(([, { matcher }]) => matcher({ labels: environmentMatcherLabels }));
+            const namedEnvironmentIdentity = __classPrivateFieldGet(this, _DefaultAllureStore_environment, "f") ??
+                (environmentMatch
+                    ? {
+                        id: environmentMatch[0],
+                        name: environmentMatch[1].name ?? environmentMatch[0],
+                    }
+                    : undefined);
+            const identity = namedEnvironmentIdentity ?? DEFAULT_ENVIRONMENT_IDENTITY;
+            testResult.environment = identity.id;
+            __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_addEnvironments).call(this, [identity]);
+            return identity;
+        });
+        measurePerfAggregateSync(PERF_METRIC_NAMES.storeVisitTestResultRetry, () => {
+            testResult.environmentHash = calculateEnvironmentHash(environmentIdentity.id);
+            testResult.retryHash = calculateRetryHash({
+                testCaseHash: testResult.testCaseHash,
+                parametersHash: testResult.parametersHash,
+                environmentHash: testResult.environmentHash,
             });
-        }
-        const environmentMatcherLabels = testResult.labels.filter(({ name }) => name !== "ALLURE_ID" && name !== fallbackTestCaseIdLabelName);
-        const environmentMatch = __classPrivateFieldGet(this, _DefaultAllureStore_environment, "f")
-            ? undefined
-            : Object.entries(__classPrivateFieldGet(this, _DefaultAllureStore_environmentsConfig, "f")).find(([, { matcher }]) => matcher({ labels: environmentMatcherLabels }));
-        const namedEnvironmentIdentity = __classPrivateFieldGet(this, _DefaultAllureStore_environment, "f") ??
-            (environmentMatch
-                ? {
-                    id: environmentMatch[0],
-                    name: environmentMatch[1].name ?? environmentMatch[0],
-                }
-                : undefined);
-        const environmentIdentity = namedEnvironmentIdentity ?? DEFAULT_ENVIRONMENT_IDENTITY;
-        testResult.environment = environmentIdentity.id;
-        __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_addEnvironments).call(this, [environmentIdentity]);
-        testResult.environmentHash = calculateEnvironmentHash(environmentIdentity.id);
-        testResult.retryHash = calculateRetryHash({
-            testCaseHash: testResult.testCaseHash,
-            parametersHash: testResult.parametersHash,
-            environmentHash: testResult.environmentHash,
         });
         if (__classPrivateFieldGet(this, _DefaultAllureStore_history, "f")) {
-            const lookup = createHistoryTestResultLookup([testResult]);
-            __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_applyHistoryFlags).call(this, testResult, __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_historyFor).call(this, testResult, lookup));
+            measurePerfAggregateSync(PERF_METRIC_NAMES.storeVisitTestResultHistory, () => {
+                const lookup = createHistoryTestResultLookup([testResult]);
+                __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_applyHistoryFlags).call(this, testResult, __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_historyFor).call(this, testResult, lookup));
+            });
         }
-        __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_classifyResolution).call(this, testResult);
-        __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f").set(testResult.id, testResult);
-        __classPrivateFieldSet(this, _DefaultAllureStore_historyLookup, undefined, "f");
-        __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_setTestResultEnvironmentId).call(this, testResult, environmentIdentity.id);
-        __classPrivateFieldGet(this, _DefaultAllureStore_retrySubstore, "f").recordIngestOrder(testResult.id);
-        __classPrivateFieldGet(this, _DefaultAllureStore_retrySubstore, "f").upsert(testResult);
-        index(this.indexTestResultByTestCase, testResult.testCase?.id, testResult);
-        index(this.indexTestResultByRetryHash, testResult.retryHash, testResult);
-        index(this.indexAttachmentByTestResult, testResult.id, ...attachmentLinks);
+        measurePerfAggregateSync(PERF_METRIC_NAMES.storeVisitTestResultResolution, () => {
+            __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_classifyResolution).call(this, testResult);
+        });
+        measurePerfAggregateSync(PERF_METRIC_NAMES.storeVisitTestResultIndexes, () => {
+            __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f").set(testResult.id, testResult);
+            __classPrivateFieldSet(this, _DefaultAllureStore_historyLookup, undefined, "f");
+            __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_setTestResultEnvironmentId).call(this, testResult, environmentIdentity.id);
+            __classPrivateFieldGet(this, _DefaultAllureStore_retrySubstore, "f").recordIngestOrder(testResult.id);
+            __classPrivateFieldGet(this, _DefaultAllureStore_retrySubstore, "f").upsert(testResult);
+            index(this.indexTestResultByTestCase, testResult.testCase?.id, testResult);
+            index(this.indexTestResultByRetryHash, testResult.retryHash, testResult);
+            index(this.indexAttachmentByTestResult, testResult.id, ...attachmentLinks);
+        });
         __classPrivateFieldGet(this, _DefaultAllureStore_realtimeDispatcher, "f")?.sendTestResult(testResult.id);
     }
     async visitTestFixtureResult(result, context) {
@@ -416,28 +430,31 @@ export class DefaultAllureStore {
         __classPrivateFieldGet(this, _DefaultAllureStore_realtimeDispatcher, "f")?.sendTestFixtureResult(testFixtureResult.id);
     }
     async visitAttachmentFile(resultFile) {
-        const originalFileName = resultFile.getOriginalFileName();
-        const id = md5(originalFileName);
-        __classPrivateFieldGet(this, _DefaultAllureStore_attachmentContents, "f").set(id, resultFile);
-        const maybeLink = __classPrivateFieldGet(this, _DefaultAllureStore_attachments, "f").get(id);
-        if (maybeLink) {
-            const link = maybeLink;
-            link.missed = false;
-            link.ext = link.ext === undefined || link.ext === "" ? resultFile.getExtension() : link.ext;
-            link.contentType = link.contentType ?? resultFile.getContentType();
-            link.contentLength = resultFile.getContentLength();
-        }
-        else {
-            __classPrivateFieldGet(this, _DefaultAllureStore_attachments, "f").set(id, {
-                used: false,
-                missed: false,
-                id,
-                originalFileName,
-                ext: resultFile.getExtension(),
-                contentType: resultFile.getContentType(),
-                contentLength: resultFile.getContentLength(),
-            });
-        }
+        const { id, originalFileName } = measurePerfAggregateSync(PERF_METRIC_NAMES.storeVisitAttachmentFileMetadata, () => {
+            const originalFileName = resultFile.getOriginalFileName();
+            const id = md5(originalFileName);
+            __classPrivateFieldGet(this, _DefaultAllureStore_attachmentContents, "f").set(id, resultFile);
+            const maybeLink = __classPrivateFieldGet(this, _DefaultAllureStore_attachments, "f").get(id);
+            if (maybeLink) {
+                const link = maybeLink;
+                link.missed = false;
+                link.ext = link.ext === undefined || link.ext === "" ? resultFile.getExtension() : link.ext;
+                link.contentType = link.contentType ?? resultFile.getContentType();
+                link.contentLength = resultFile.getContentLength();
+            }
+            else {
+                __classPrivateFieldGet(this, _DefaultAllureStore_attachments, "f").set(id, {
+                    used: false,
+                    missed: false,
+                    id,
+                    originalFileName,
+                    ext: resultFile.getExtension(),
+                    contentType: resultFile.getContentType(),
+                    contentLength: resultFile.getContentLength(),
+                });
+            }
+            return { id, originalFileName };
+        });
         for (const globalAttachmentId of [...__classPrivateFieldGet(this, _DefaultAllureStore_globalAttachmentIds, "f"), ...__classPrivateFieldGet(this, _DefaultAllureStore_processGlobalAttachmentIds, "f")]) {
             const globalAttachment = __classPrivateFieldGet(this, _DefaultAllureStore_attachments, "f").get(globalAttachmentId);
             if (!globalAttachment || globalAttachment.originalFileName !== originalFileName) {
@@ -874,6 +891,7 @@ export class DefaultAllureStore {
             fixtures: mapToObject(__classPrivateFieldGet(this, _DefaultAllureStore_fixtures, "f")),
             environments: __classPrivateFieldGet(this, _DefaultAllureStore_environments, "f"),
             reportVariables: __classPrivateFieldGet(this, _DefaultAllureStore_reportVariables, "f"),
+            metadata: mapToObject(__classPrivateFieldGet(this, _DefaultAllureStore_metadata, "f")),
             globalAttachmentIds: [...__classPrivateFieldGet(this, _DefaultAllureStore_globalAttachmentIds, "f"), ...__classPrivateFieldGet(this, _DefaultAllureStore_processGlobalAttachmentIds, "f")],
             globalErrors: [...__classPrivateFieldGet(this, _DefaultAllureStore_globalErrors, "f"), ...__classPrivateFieldGet(this, _DefaultAllureStore_processGlobalErrors, "f")],
             checkResults: mapToObject(__classPrivateFieldGet(this, _DefaultAllureStore_checkResultsById, "f")),
@@ -910,7 +928,7 @@ export class DefaultAllureStore {
     }
     async restoreState(stateDump, attachmentsContents = {}) {
         __classPrivateFieldSet(this, _DefaultAllureStore_historyLookup, undefined, "f");
-        const { testResults, attachments, testCases, fixtures, reportVariables, environments, globalAttachmentIds = [], globalErrors = [], checkResults, indexAttachmentByTestResult = {}, indexAttachmentByFixture = {}, indexFixturesByTestResult = {}, qualityGateResults = [], metrics = [], testResultIdsIngestOrder = [], } = stateDump;
+        const { testResults, attachments, testCases, fixtures, reportVariables, metadata = {}, environments, globalAttachmentIds = [], globalErrors = [], checkResults, indexAttachmentByTestResult = {}, indexAttachmentByFixture = {}, indexFixturesByTestResult = {}, qualityGateResults = [], metrics = [], testResultIdsIngestOrder = [], } = stateDump;
         __classPrivateFieldGet(this, _DefaultAllureStore_resolutionIssues, "f").clear();
         __classPrivateFieldGet(this, _DefaultAllureStore_testResultIdsByResolutionIssueId, "f").clear();
         __classPrivateFieldGet(this, _DefaultAllureStore_resolutionIssueIdByTestResultId, "f").clear();
@@ -1021,6 +1039,7 @@ export class DefaultAllureStore {
             __classPrivateFieldGet(this, _DefaultAllureStore_globalErrors, "f").push(__classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_indexGlobalError).call(this, error));
         });
         Object.assign(__classPrivateFieldGet(this, _DefaultAllureStore_reportVariables, "f"), reportVariables);
+        updateMapWithRecord(__classPrivateFieldGet(this, _DefaultAllureStore_metadata, "f"), metadata);
         Object.entries(indexAttachmentByTestResult).forEach(([trId, links]) => {
             const attachmentsLinks = links.map((id) => __classPrivateFieldGet(this, _DefaultAllureStore_attachments, "f").get(id)).filter(Boolean);
             if (attachmentsLinks.length === 0) {
@@ -1176,7 +1195,7 @@ _DefaultAllureStore_testResults = new WeakMap(), _DefaultAllureStore_attachments
     testResult.resolution = rule.resolution;
     testResult.resolutionComment = rule.comment;
     if (rule.resolution === "issue") {
-        __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_associateResolutionIssue).call(this, { ...rule.issue, comment: rule.comment }, testResult.id);
+        __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_associateResolutionIssue).call(this, createResolutionIssue(rule, __classPrivateFieldGet(this, _DefaultAllureStore_resolutionsConfig, "f")), testResult.id);
     }
 }, _DefaultAllureStore_associateResolutionIssue = function _DefaultAllureStore_associateResolutionIssue(resolutionIssue, testResultId) {
     __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_removeResolutionIssueAssociation).call(this, testResultId);

package/dist/utils/perf.d.ts

@@ -1,18 +1,12 @@
 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;
-    durationMs: number;
-};
-export type PerfMetricSummary = {
-    name: string;
-    count: number;
-    totalMs: number;
-    minMs: number;
-    maxMs: number;
-    avgMs: number;
+type PerfMetricMetadata = {
+    title?: string;
+    unit?: string;
+    group?: string;
+    groupTitle?: string;
+    better?: "neutral";
 };
 export declare const PERF_METRIC_NAMES: {
     readonly allureTotal: "allure.total";
@@ -22,17 +16,34 @@ export declare const PERF_METRIC_NAMES: {
     readonly restoreStateStoreRestore: "restoreState.storeRestore";
     readonly generateTotal: "generate.total";
     readonly generateReadResults: "generate.readResults";
+    readonly generateReadResultsXcresultCheck: "generate.readResults.xcresultCheck";
+    readonly generateReadResultsReaddir: "generate.readResults.readdir";
+    readonly generateReadResultsFiles: "generate.readResults.files";
+    readonly generateReadResultsReaderRead: "generate.readResults.reader.read";
     readonly generatePluginsDone: "generate.plugins.done";
+    readonly storeVisitTestResultConvert: "store.visitTestResult.convert";
+    readonly storeVisitTestResultDefaultLabels: "store.visitTestResult.defaultLabels";
+    readonly storeVisitTestResultEnvironment: "store.visitTestResult.environment";
+    readonly storeVisitTestResultRetry: "store.visitTestResult.retry";
+    readonly storeVisitTestResultHistory: "store.visitTestResult.history";
+    readonly storeVisitTestResultResolution: "store.visitTestResult.resolution";
+    readonly storeVisitTestResultIndexes: "store.visitTestResult.indexes";
+    readonly storeVisitAttachmentFileMetadata: "store.visitAttachmentFile.metadata";
     readonly publishUploadTotal: "publish.upload.total";
     readonly summaryGenerate: "summary.generate";
 };
 export declare const PERF_METRIC_PREFIXES: {
+    readonly generatePlugin: "generate.plugin.";
     readonly generatePluginDone: "generate.plugin.done.";
     readonly publishUploadPlugin: "publish.upload.plugin.";
 };
 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 measurePerfAggregate: <T>(name: string, fn: () => Promise<T>) => Promise<T>;
+export declare const measurePerfAggregateSync: <T>(name: string, fn: () => T) => T;
+export declare const incrementPerfCounter: (name: string, value?: number, metadata?: PerfMetricMetadata) => void;
 export declare const getPerfMetricsResults: () => AllurePerformanceResult[];
 export declare const writePerfMetrics: (output: string, fileName?: string) => Promise<boolean>;
 export declare const resetPerfMetrics: () => void;
+export {};

package/dist/utils/perf.js

@@ -7,6 +7,8 @@ export const perfMetricsFileName = (reportUuid) => `${reportUuid}-perf.json`;
 const MARK_PREFIX = "allure:perf:";
 const ENABLED_VALUES = new Set(["1", "true", "yes", "on"]);
 const SPANS = [];
+const AGGREGATES = new Map();
+const COUNTERS = new Map();
 const MARKS = new Set();
 const MEASURES = new Set();
 let sequence = 0;
@@ -19,28 +21,45 @@ export const PERF_METRIC_NAMES = {
     restoreStateStoreRestore: "restoreState.storeRestore",
     generateTotal: "generate.total",
     generateReadResults: "generate.readResults",
+    generateReadResultsXcresultCheck: "generate.readResults.xcresultCheck",
+    generateReadResultsReaddir: "generate.readResults.readdir",
+    generateReadResultsFiles: "generate.readResults.files",
+    generateReadResultsReaderRead: "generate.readResults.reader.read",
     generatePluginsDone: "generate.plugins.done",
+    storeVisitTestResultConvert: "store.visitTestResult.convert",
+    storeVisitTestResultDefaultLabels: "store.visitTestResult.defaultLabels",
+    storeVisitTestResultEnvironment: "store.visitTestResult.environment",
+    storeVisitTestResultRetry: "store.visitTestResult.retry",
+    storeVisitTestResultHistory: "store.visitTestResult.history",
+    storeVisitTestResultResolution: "store.visitTestResult.resolution",
+    storeVisitTestResultIndexes: "store.visitTestResult.indexes",
+    storeVisitAttachmentFileMetadata: "store.visitAttachmentFile.metadata",
     publishUploadTotal: "publish.upload.total",
     summaryGenerate: "summary.generate",
 };
 export const PERF_METRIC_PREFIXES = {
+    generatePlugin: "generate.plugin.",
     generatePluginDone: "generate.plugin.done.",
     publishUploadPlugin: "publish.upload.plugin.",
 };
-const getCoveredDurationSummary = () => {
-    if (SPANS.length === 0) {
+const getCoveredTiming = () => {
+    const timings = [
+        ...SPANS.map(({ startTimeMs, durationMs }) => ({
+            startTimeMs,
+            stopTimeMs: startTimeMs + durationMs,
+        })),
+        ...AGGREGATES.values(),
+        ...COUNTERS.values(),
+    ];
+    if (timings.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);
+    const startTimeMs = Math.min(...timings.map(({ startTimeMs }) => startTimeMs));
+    const stopTimeMs = Math.max(...timings.map(({ stopTimeMs }) => stopTimeMs));
     return {
-        name: PERF_METRIC_NAMES.allureTotal,
-        count: 1,
-        totalMs: durationMs,
-        minMs: durationMs,
-        maxMs: durationMs,
-        avgMs: durationMs,
+        startTimeMs,
+        stopTimeMs,
+        durationMs: round(stopTimeMs - startTimeMs),
     };
 };
 export const isPerfMetricsEnabled = () => ENABLED_VALUES.has((process.env.ALLURE_PERF_METRICS ?? "").toLowerCase());
@@ -91,8 +110,80 @@ export const measurePerf = async (name, fn) => {
         end();
     }
 };
+const recordPerfTiming = (name, durationMs, startTimeMs) => {
+    if (!isPerfMetricsEnabled()) {
+        return;
+    }
+    const current = AGGREGATES.get(name);
+    if (!current) {
+        AGGREGATES.set(name, {
+            name,
+            count: 1,
+            totalMs: durationMs,
+            startTimeMs,
+            stopTimeMs: startTimeMs + durationMs,
+        });
+        return;
+    }
+    current.count += 1;
+    current.totalMs += durationMs;
+    current.startTimeMs = Math.min(current.startTimeMs, startTimeMs);
+    current.stopTimeMs = Math.max(current.stopTimeMs, startTimeMs + durationMs);
+};
+export const measurePerfAggregate = async (name, fn) => {
+    if (!isPerfMetricsEnabled()) {
+        return fn();
+    }
+    const startTimeMs = performance.now();
+    try {
+        return await fn();
+    }
+    finally {
+        recordPerfTiming(name, performance.now() - startTimeMs, startTimeMs);
+    }
+};
+export const measurePerfAggregateSync = (name, fn) => {
+    if (!isPerfMetricsEnabled()) {
+        return fn();
+    }
+    const startTimeMs = performance.now();
+    try {
+        return fn();
+    }
+    finally {
+        recordPerfTiming(name, performance.now() - startTimeMs, startTimeMs);
+    }
+};
+export const incrementPerfCounter = (name, value = 1, metadata) => {
+    if (!isPerfMetricsEnabled()) {
+        return;
+    }
+    const timeMs = performance.now();
+    const current = COUNTERS.get(name);
+    if (!current) {
+        COUNTERS.set(name, {
+            name,
+            value,
+            startTimeMs: timeMs,
+            stopTimeMs: timeMs,
+            ...(metadata ? { metadata } : {}),
+        });
+        return;
+    }
+    current.value += value;
+    current.stopTimeMs = timeMs;
+    current.metadata ?? (current.metadata = metadata);
+};
+const metricResult = (key, value, startTimeMs, stopTimeMs, metadata) => ({
+    id: randomUUID(),
+    key,
+    value: round(value),
+    start: round(performance.timeOrigin + startTimeMs),
+    stop: round(performance.timeOrigin + stopTimeMs),
+    ...metadata,
+});
 export const getPerfMetricsResults = () => {
-    const totalSummary = getCoveredDurationSummary();
+    const coveredTiming = getCoveredTiming();
     const results = SPANS.map((span) => ({
         id: randomUUID(),
         key: span.name,
@@ -100,15 +191,21 @@ export const getPerfMetricsResults = () => {
         start: round(performance.timeOrigin + span.startTimeMs),
         stop: round(performance.timeOrigin + span.startTimeMs + span.durationMs),
     }));
-    if (totalSummary) {
+    if (coveredTiming) {
         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))),
+            value: coveredTiming.durationMs,
+            start: round(performance.timeOrigin + coveredTiming.startTimeMs),
+            stop: round(performance.timeOrigin + coveredTiming.stopTimeMs),
         });
     }
+    for (const aggregate of AGGREGATES.values()) {
+        results.push(metricResult(`${aggregate.name}.totalMs`, aggregate.totalMs, aggregate.startTimeMs, aggregate.stopTimeMs), metricResult(`${aggregate.name}.avgMs`, aggregate.totalMs / aggregate.count, aggregate.startTimeMs, aggregate.stopTimeMs));
+    }
+    for (const counter of COUNTERS.values()) {
+        results.push(metricResult(counter.name, counter.value, counter.startTimeMs, counter.stopTimeMs, counter.metadata));
+    }
     return results;
 };
 export const writePerfMetrics = async (output, fileName = PERF_METRICS_FILE) => {
@@ -123,6 +220,8 @@ export const writePerfMetrics = async (output, fileName = PERF_METRICS_FILE) =>
 };
 export const resetPerfMetrics = () => {
     SPANS.length = 0;
+    AGGREGATES.clear();
+    COUNTERS.clear();
     sequence = 0;
     for (const mark of MARKS) {
         performance.clearMarks(mark);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/core",
-  "version": "3.19.0",
+  "version": "3.20.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.19.0",
-    "@allurereport/cli-commons": "3.19.0",
-    "@allurereport/core-api": "3.19.0",
-    "@allurereport/plugin-agent": "3.19.0",
-    "@allurereport/plugin-allure2": "3.19.0",
-    "@allurereport/plugin-api": "3.19.0",
-    "@allurereport/plugin-awesome": "3.19.0",
-    "@allurereport/plugin-classic": "3.19.0",
-    "@allurereport/plugin-csv": "3.19.0",
-    "@allurereport/plugin-dashboard": "3.19.0",
-    "@allurereport/plugin-jira": "3.19.0",
-    "@allurereport/plugin-log": "3.19.0",
-    "@allurereport/plugin-progress": "3.19.0",
-    "@allurereport/plugin-slack": "3.19.0",
-    "@allurereport/plugin-testops": "3.19.0",
-    "@allurereport/plugin-testplan": "3.19.0",
-    "@allurereport/reader": "3.19.0",
-    "@allurereport/reader-api": "3.19.0",
-    "@allurereport/service": "3.19.0",
-    "@allurereport/summary": "3.19.0",
+    "@allurereport/ci": "3.20.0",
+    "@allurereport/cli-commons": "3.20.0",
+    "@allurereport/core-api": "3.20.0",
+    "@allurereport/plugin-agent": "3.20.0",
+    "@allurereport/plugin-allure2": "3.20.0",
+    "@allurereport/plugin-api": "3.20.0",
+    "@allurereport/plugin-awesome": "3.20.0",
+    "@allurereport/plugin-classic": "3.20.0",
+    "@allurereport/plugin-csv": "3.20.0",
+    "@allurereport/plugin-dashboard": "3.20.0",
+    "@allurereport/plugin-jira": "3.20.0",
+    "@allurereport/plugin-log": "3.20.0",
+    "@allurereport/plugin-progress": "3.20.0",
+    "@allurereport/plugin-slack": "3.20.0",
+    "@allurereport/plugin-testops": "3.20.0",
+    "@allurereport/plugin-testplan": "3.20.0",
+    "@allurereport/reader": "3.20.0",
+    "@allurereport/reader-api": "3.20.0",
+    "@allurereport/service": "3.20.0",
+    "@allurereport/summary": "3.20.0",
     "glob": "^13.0.6",
     "handlebars": "^4.7.9",
     "jiti": "^2.5.1",
@@ -58,7 +58,7 @@
     "@types/node": "^20",
     "@types/zip-stream": "^7.0.0",
     "@vitest/runner": "^2",
-    "@vitest/snapshot": "^2.1.9",
+    "@vitest/snapshot": "^5.0.1",
     "allure-js-commons": "^3",
     "allure-vitest": "^3",
     "rimraf": "^6",