@allurereport/core 3.9.0 → 3.10.0

package/dist/report.js

@@ -9,7 +9,7 @@ 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_allureServiceClient, _AllureReport_qualityGate, _AllureReport_dump, _AllureReport_categories, _AllureReport_environments, _AllureReport_globalAttachments, _AllureReport_dumpTempDirs, _AllureReport_state, _AllureReport_executionStage, _AllureReport_historyDataPoint, _AllureReport_summaryPath, _AllureReport_summariesByPluginId, _AllureReport_publishedRemoteHrefs, _AllureReport_published, _AllureReport_publish, _AllureReport_runRealtimeUpdate, _AllureReport_getReportsToPublish, _AllureReport_cleanupFailedRemoteReport, _AllureReport_logPublishError, _AllureReport_applyPublishLinksToSummaries, _AllureReport_cloneSummariesByPluginId, _AllureReport_writeSummaryFiles, _AllureReport_generateRootSummary, _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_allureServiceClient, _AllureReport_qualityGate, _AllureReport_dump, _AllureReport_categories, _AllureReport_environments, _AllureReport_globalAttachments, _AllureReport_dumpTempDirs, _AllureReport_state, _AllureReport_executionStage, _AllureReport_historyDataPoint, _AllureReport_summaryPath, _AllureReport_summariesByPluginId, _AllureReport_publishedRemoteHrefs, _AllureReport_published, _AllureReport_endGeneratePerfSpan, _AllureReport_publish, _AllureReport_runRealtimeUpdate, _AllureReport_getReportsToPublish, _AllureReport_cleanupFailedRemoteReport, _AllureReport_logPublishError, _AllureReport_applyPublishLinksToSummaries, _AllureReport_cloneSummariesByPluginId, _AllureReport_writeSummaryFiles, _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";
@@ -35,6 +35,7 @@ import { QualityGate } from "./qualityGate/index.js";
 import { DefaultAllureStore } from "./store/store.js";
 import { createUploadProgressBarCounter } from "./utils/cli.js";
 import { environmentIdentityById, environmentIdentityByName } from "./utils/environment.js";
+import { measurePerf, PERF_METRIC_NAMES, PERF_METRIC_PREFIXES, 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";
@@ -94,6 +95,7 @@ export class AllureReport {
         _AllureReport_summariesByPluginId.set(this, new Map());
         _AllureReport_publishedRemoteHrefs.set(this, new Set());
         _AllureReport_published.set(this, false);
+        _AllureReport_endGeneratePerfSpan.set(this, void 0);
         _AllureReport_publish.set(this, async () => {
             if (__classPrivateFieldGet(this, _AllureReport_published, "f")) {
                 return;
@@ -126,6 +128,7 @@ export class AllureReport {
             let summariesMutated = false;
             let reportCreated = false;
             let publishErrorMessage = "Report upload has failed, the report won't be published";
+            const endPublishPerfSpan = startPerfSpan(PERF_METRIC_NAMES.publishUploadTotal);
             try {
                 await client.createReport({
                     reportUuid: this.reportUuid,
@@ -135,12 +138,12 @@ export class AllureReport {
                 reportCreated = true;
                 for (const report of reportsToPublish) {
                     publishErrorMessage = `Plugin "${report.pluginId}" upload has failed, the plugin won't be published`;
-                    const uploadResult = await client.uploadReport({
+                    const uploadResult = await measurePerf(`${PERF_METRIC_PREFIXES.publishUploadPlugin}${report.pluginId}`, () => client.uploadReport({
                         reportUuid: this.reportUuid,
                         pluginId: report.pluginId,
                         files: Object.fromEntries(Object.entries(report.files).filter(([filename]) => filename !== "summary.json")),
                         onProgress: () => uploadProgressBar.tick(),
-                    });
+                    }));
                     if (uploadResult.indexHref) {
                         linksByPluginId[report.pluginId] = uploadResult.indexHref;
                     }
@@ -199,10 +202,11 @@ export class AllureReport {
                 __classPrivateFieldGet(this, _AllureReport_logPublishError, "f").call(this, publishErrorMessage, err);
             }
             finally {
+                endPublishPerfSpan();
                 uploadProgressBar.terminate();
             }
         });
-        this.readDirectory = async (resultsDir) => {
+        this.readDirectory = async (resultsDir) => measurePerf(PERF_METRIC_NAMES.generateReadResults, async () => {
             if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") !== "running") {
                 throw new Error(initRequired);
             }
@@ -228,13 +232,13 @@ export class AllureReport {
             catch (e) {
                 console.error("can't read directory", e);
             }
-        };
-        this.readFile = async (resultsFile) => {
+        });
+        this.readFile = async (resultsFile) => measurePerf(PERF_METRIC_NAMES.generateReadResults, async () => {
             if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") !== "running") {
                 throw new Error(initRequired);
             }
             await this.readResult(new PathResultFile(resultsFile));
-        };
+        });
         this.readResult = async (data) => {
             if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") !== "running") {
                 throw new Error(initRequired);
@@ -275,6 +279,7 @@ export class AllureReport {
                 throw new Error("the report is already stopped, the restart isn't supported at the moment");
             }
             __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) {
@@ -440,160 +445,164 @@ export class AllureReport {
             }
             await rename(dumpTempPath, dumpPath);
         };
-        this.restoreState = async (dumps) => {
+        this.restoreState = async (dumps) => measurePerf(PERF_METRIC_NAMES.restoreStateTotal, async () => {
             for (const dump of dumps) {
-                if (!existsSync(dump)) {
-                    console.error(`Failed to restore state from "${dump}", continuing without it`);
-                    console.error("Dump file does not exist");
-                    continue;
-                }
-                try {
-                    const dumpArchive = new ZipReadStream.async({
-                        file: dump,
-                    });
-                    let restoreError;
+                await measurePerf(PERF_METRIC_NAMES.restoreStateDump, async () => {
+                    if (!existsSync(dump)) {
+                        console.error(`Failed to restore state from "${dump}", continuing without it`);
+                        console.error("Dump file does not exist");
+                        return;
+                    }
                     try {
-                        const dumpEntries = await dumpArchive.entries();
-                        const dumpEntriesList = Object.entries(dumpEntries);
-                        const requiredEntryData = async (entryName) => {
-                            if (!dumpEntries[entryName]) {
-                                throw new Error(`Missing required dump entry "${entryName}"`);
-                            }
-                            return dumpArchive.entryData(entryName);
-                        };
-                        const optionalEntryData = async (entryName) => dumpEntries[entryName] ? dumpArchive.entryData(entryName) : undefined;
-                        if (!dumpEntries[AllureStoreDumpFiles.TestResults]) {
-                            const nestedDumpEntries = dumpEntriesList.filter(([entryName, entry]) => !entry.isDirectory &&
-                                !entryName.startsWith("__MACOSX/") &&
-                                !basename(entryName).startsWith("._") &&
-                                entryName.toLowerCase().endsWith(".zip"));
-                            if (nestedDumpEntries.length > 0) {
-                                const nestedDumpsTempDir = await mkdtemp(join(tmpdir(), `${basename(dump, ".zip")}-nested-`));
-                                const nestedDumpPaths = [];
-                                __classPrivateFieldGet(this, _AllureReport_dumpTempDirs, "f").push(nestedDumpsTempDir);
-                                for (const [entryName] of nestedDumpEntries) {
-                                    const nestedDumpPath = join(nestedDumpsTempDir, `${nestedDumpPaths.length}-${basename(entryName)}`);
-                                    await writeFile(nestedDumpPath, await dumpArchive.entryData(entryName));
-                                    nestedDumpPaths.push(nestedDumpPath);
+                        const dumpArchive = new ZipReadStream.async({
+                            file: dump,
+                        });
+                        let restoreError;
+                        try {
+                            const dumpEntries = await dumpArchive.entries();
+                            const dumpEntriesList = Object.entries(dumpEntries);
+                            const requiredEntryData = async (entryName) => {
+                                if (!dumpEntries[entryName]) {
+                                    throw new Error(`Missing required dump entry "${entryName}"`);
+                                }
+                                return dumpArchive.entryData(entryName);
+                            };
+                            const optionalEntryData = async (entryName) => dumpEntries[entryName] ? dumpArchive.entryData(entryName) : undefined;
+                            if (!dumpEntries[AllureStoreDumpFiles.TestResults]) {
+                                const nestedDumpEntries = dumpEntriesList.filter(([entryName, entry]) => !entry.isDirectory &&
+                                    !entryName.startsWith("__MACOSX/") &&
+                                    !basename(entryName).startsWith("._") &&
+                                    entryName.toLowerCase().endsWith(".zip"));
+                                if (nestedDumpEntries.length > 0) {
+                                    const nestedDumpsTempDir = await mkdtemp(join(tmpdir(), `${basename(dump, ".zip")}-nested-`));
+                                    const nestedDumpPaths = [];
+                                    __classPrivateFieldGet(this, _AllureReport_dumpTempDirs, "f").push(nestedDumpsTempDir);
+                                    for (const [entryName] of nestedDumpEntries) {
+                                        const nestedDumpPath = join(nestedDumpsTempDir, `${nestedDumpPaths.length}-${basename(entryName)}`);
+                                        await writeFile(nestedDumpPath, await dumpArchive.entryData(entryName));
+                                        nestedDumpPaths.push(nestedDumpPath);
+                                    }
+                                    await this.restoreState(nestedDumpPaths);
+                                    return;
                                 }
-                                await this.restoreState(nestedDumpPaths);
-                                continue;
                             }
-                        }
-                        const testResultsEntry = await requiredEntryData(AllureStoreDumpFiles.TestResults);
-                        const testCasesEntry = await requiredEntryData(AllureStoreDumpFiles.TestCases);
-                        const fixturesEntry = await requiredEntryData(AllureStoreDumpFiles.Fixtures);
-                        const attachmentsEntry = await requiredEntryData(AllureStoreDumpFiles.Attachments);
-                        const checkResultsEntry = await optionalEntryData(AllureStoreDumpFiles.CheckResults);
-                        const environmentsEntry = await requiredEntryData(AllureStoreDumpFiles.Environments);
-                        const reportVariablesEntry = await requiredEntryData(AllureStoreDumpFiles.ReportVariables);
-                        const globalAttachmentsEntry = await requiredEntryData(AllureStoreDumpFiles.GlobalAttachments);
-                        const globalErrorsEntry = await requiredEntryData(AllureStoreDumpFiles.GlobalErrors);
-                        const indexAttachmentsEntry = await requiredEntryData(AllureStoreDumpFiles.IndexAttachmentsByTestResults);
-                        const indexTestResultsByHistoryId = await requiredEntryData(AllureStoreDumpFiles.IndexTestResultsByHistoryId);
-                        const indexTestResultsByTestCaseEntry = await requiredEntryData(AllureStoreDumpFiles.IndexTestResultsByTestCase);
-                        const indexAttachmentsByFixtureEntry = await requiredEntryData(AllureStoreDumpFiles.IndexAttachmentsByFixture);
-                        const indexFixturesByTestResultEntry = await requiredEntryData(AllureStoreDumpFiles.IndexFixturesByTestResult);
-                        const indexKnownByHistoryIdEntry = await requiredEntryData(AllureStoreDumpFiles.IndexKnownByHistoryId);
-                        const qualityGateResultsEntry = await requiredEntryData(AllureStoreDumpFiles.QualityGateResults);
-                        const testResultIngestOrderEntry = await optionalEntryData(AllureStoreDumpFiles.TestResultIngestOrder);
-                        const attachmentsLinks = JSON.parse(attachmentsEntry.toString("utf8"));
-                        const attachmentsEntries = dumpEntriesList.reduce((acc, [entryName, entry]) => {
-                            switch (entryName) {
-                                case AllureStoreDumpFiles.Attachments:
-                                case AllureStoreDumpFiles.CheckResults:
-                                case AllureStoreDumpFiles.TestResults:
-                                case AllureStoreDumpFiles.TestCases:
-                                case AllureStoreDumpFiles.Fixtures:
-                                case AllureStoreDumpFiles.Environments:
-                                case AllureStoreDumpFiles.ReportVariables:
-                                case AllureStoreDumpFiles.GlobalAttachments:
-                                case AllureStoreDumpFiles.GlobalErrors:
-                                case AllureStoreDumpFiles.IndexAttachmentsByTestResults:
-                                case AllureStoreDumpFiles.IndexTestResultsByHistoryId:
-                                case AllureStoreDumpFiles.IndexTestResultsByTestCase:
-                                case AllureStoreDumpFiles.IndexAttachmentsByFixture:
-                                case AllureStoreDumpFiles.IndexFixturesByTestResult:
-                                case AllureStoreDumpFiles.IndexKnownByHistoryId:
-                                case AllureStoreDumpFiles.QualityGateResults:
-                                case AllureStoreDumpFiles.TestResultIngestOrder:
-                                    return acc;
-                                default:
-                                    if (entry.isDirectory || !attachmentsLinks[entryName] || attachmentsLinks[entryName].missed) {
+                            const testResultsEntry = await requiredEntryData(AllureStoreDumpFiles.TestResults);
+                            const testCasesEntry = await requiredEntryData(AllureStoreDumpFiles.TestCases);
+                            const fixturesEntry = await requiredEntryData(AllureStoreDumpFiles.Fixtures);
+                            const attachmentsEntry = await requiredEntryData(AllureStoreDumpFiles.Attachments);
+                            const checkResultsEntry = await optionalEntryData(AllureStoreDumpFiles.CheckResults);
+                            const environmentsEntry = await requiredEntryData(AllureStoreDumpFiles.Environments);
+                            const reportVariablesEntry = await requiredEntryData(AllureStoreDumpFiles.ReportVariables);
+                            const globalAttachmentsEntry = await requiredEntryData(AllureStoreDumpFiles.GlobalAttachments);
+                            const globalErrorsEntry = await requiredEntryData(AllureStoreDumpFiles.GlobalErrors);
+                            const indexAttachmentsEntry = await requiredEntryData(AllureStoreDumpFiles.IndexAttachmentsByTestResults);
+                            const indexTestResultsByHistoryId = await requiredEntryData(AllureStoreDumpFiles.IndexTestResultsByHistoryId);
+                            const indexTestResultsByTestCaseEntry = await requiredEntryData(AllureStoreDumpFiles.IndexTestResultsByTestCase);
+                            const indexAttachmentsByFixtureEntry = await requiredEntryData(AllureStoreDumpFiles.IndexAttachmentsByFixture);
+                            const indexFixturesByTestResultEntry = await requiredEntryData(AllureStoreDumpFiles.IndexFixturesByTestResult);
+                            const indexKnownByHistoryIdEntry = await requiredEntryData(AllureStoreDumpFiles.IndexKnownByHistoryId);
+                            const qualityGateResultsEntry = await requiredEntryData(AllureStoreDumpFiles.QualityGateResults);
+                            const testResultIngestOrderEntry = await optionalEntryData(AllureStoreDumpFiles.TestResultIngestOrder);
+                            const attachmentsLinks = JSON.parse(attachmentsEntry.toString("utf8"));
+                            const attachmentsEntries = dumpEntriesList.reduce((acc, [entryName, entry]) => {
+                                switch (entryName) {
+                                    case AllureStoreDumpFiles.Attachments:
+                                    case AllureStoreDumpFiles.CheckResults:
+                                    case AllureStoreDumpFiles.TestResults:
+                                    case AllureStoreDumpFiles.TestCases:
+                                    case AllureStoreDumpFiles.Fixtures:
+                                    case AllureStoreDumpFiles.Environments:
+                                    case AllureStoreDumpFiles.ReportVariables:
+                                    case AllureStoreDumpFiles.GlobalAttachments:
+                                    case AllureStoreDumpFiles.GlobalErrors:
+                                    case AllureStoreDumpFiles.IndexAttachmentsByTestResults:
+                                    case AllureStoreDumpFiles.IndexTestResultsByHistoryId:
+                                    case AllureStoreDumpFiles.IndexTestResultsByTestCase:
+                                    case AllureStoreDumpFiles.IndexAttachmentsByFixture:
+                                    case AllureStoreDumpFiles.IndexFixturesByTestResult:
+                                    case AllureStoreDumpFiles.IndexKnownByHistoryId:
+                                    case AllureStoreDumpFiles.QualityGateResults:
+                                    case AllureStoreDumpFiles.TestResultIngestOrder:
                                         return acc;
+                                    default:
+                                        if (entry.isDirectory || !attachmentsLinks[entryName] || attachmentsLinks[entryName].missed) {
+                                            return acc;
+                                        }
+                                        return Object.assign(acc, {
+                                            [entryName]: entry,
+                                        });
+                                }
+                            }, {});
+                            const dumpState = {
+                                testResults: JSON.parse(testResultsEntry.toString("utf8")),
+                                testCases: JSON.parse(testCasesEntry.toString("utf8")),
+                                fixtures: JSON.parse(fixturesEntry.toString("utf8")),
+                                attachments: attachmentsLinks,
+                                checkResults: checkResultsEntry ? JSON.parse(checkResultsEntry.toString("utf8")) : [],
+                                environments: JSON.parse(environmentsEntry.toString("utf8")),
+                                reportVariables: JSON.parse(reportVariablesEntry.toString("utf8")),
+                                globalAttachmentIds: JSON.parse(globalAttachmentsEntry.toString("utf8")),
+                                globalErrors: JSON.parse(globalErrorsEntry.toString("utf8")),
+                                indexAttachmentByTestResult: JSON.parse(indexAttachmentsEntry.toString("utf8")),
+                                indexTestResultByHistoryId: JSON.parse(indexTestResultsByHistoryId.toString("utf8")),
+                                indexTestResultByTestCase: JSON.parse(indexTestResultsByTestCaseEntry.toString("utf8")),
+                                indexAttachmentByFixture: JSON.parse(indexAttachmentsByFixtureEntry.toString("utf8")),
+                                indexFixturesByTestResult: JSON.parse(indexFixturesByTestResultEntry.toString("utf8")),
+                                indexKnownByHistoryId: JSON.parse(indexKnownByHistoryIdEntry.toString("utf8")),
+                                qualityGateResults: JSON.parse(qualityGateResultsEntry.toString("utf8")),
+                                testResultIdsIngestOrder: testResultIngestOrderEntry
+                                    ? JSON.parse(testResultIngestOrderEntry.toString("utf8"))
+                                    : [],
+                            };
+                            const dumpTempDir = await mkdtemp(join(tmpdir(), basename(dump, ".zip")));
+                            const resultsAttachments = {};
+                            __classPrivateFieldGet(this, _AllureReport_dumpTempDirs, "f").push(dumpTempDir);
+                            await measurePerf(PERF_METRIC_NAMES.restoreStateAttachments, async () => {
+                                try {
+                                    for (const [attachmentId] of Object.entries(attachmentsEntries)) {
+                                        const attachmentContentEntry = await dumpArchive.entryData(attachmentId);
+                                        const attachmentFilePath = resolveDumpAttachmentPath(dumpTempDir, attachmentId);
+                                        await writeFile(attachmentFilePath, attachmentContentEntry);
+                                        resultsAttachments[attachmentId] = new PathResultFile(attachmentFilePath, attachmentId);
                                     }
-                                    return Object.assign(acc, {
-                                        [entryName]: entry,
-                                    });
-                            }
-                        }, {});
-                        const dumpState = {
-                            testResults: JSON.parse(testResultsEntry.toString("utf8")),
-                            testCases: JSON.parse(testCasesEntry.toString("utf8")),
-                            fixtures: JSON.parse(fixturesEntry.toString("utf8")),
-                            attachments: attachmentsLinks,
-                            checkResults: checkResultsEntry ? JSON.parse(checkResultsEntry.toString("utf8")) : [],
-                            environments: JSON.parse(environmentsEntry.toString("utf8")),
-                            reportVariables: JSON.parse(reportVariablesEntry.toString("utf8")),
-                            globalAttachmentIds: JSON.parse(globalAttachmentsEntry.toString("utf8")),
-                            globalErrors: JSON.parse(globalErrorsEntry.toString("utf8")),
-                            indexAttachmentByTestResult: JSON.parse(indexAttachmentsEntry.toString("utf8")),
-                            indexTestResultByHistoryId: JSON.parse(indexTestResultsByHistoryId.toString("utf8")),
-                            indexTestResultByTestCase: JSON.parse(indexTestResultsByTestCaseEntry.toString("utf8")),
-                            indexAttachmentByFixture: JSON.parse(indexAttachmentsByFixtureEntry.toString("utf8")),
-                            indexFixturesByTestResult: JSON.parse(indexFixturesByTestResultEntry.toString("utf8")),
-                            indexKnownByHistoryId: JSON.parse(indexKnownByHistoryIdEntry.toString("utf8")),
-                            qualityGateResults: JSON.parse(qualityGateResultsEntry.toString("utf8")),
-                            testResultIdsIngestOrder: testResultIngestOrderEntry
-                                ? JSON.parse(testResultIngestOrderEntry.toString("utf8"))
-                                : [],
-                        };
-                        const dumpTempDir = await mkdtemp(join(tmpdir(), basename(dump, ".zip")));
-                        const resultsAttachments = {};
-                        __classPrivateFieldGet(this, _AllureReport_dumpTempDirs, "f").push(dumpTempDir);
-                        try {
-                            for (const [attachmentId] of Object.entries(attachmentsEntries)) {
-                                const attachmentContentEntry = await dumpArchive.entryData(attachmentId);
-                                const attachmentFilePath = resolveDumpAttachmentPath(dumpTempDir, attachmentId);
-                                await writeFile(attachmentFilePath, attachmentContentEntry);
-                                resultsAttachments[attachmentId] = new PathResultFile(attachmentFilePath, attachmentId);
-                            }
+                                }
+                                catch (err) {
+                                    if (err instanceof UnsafeDumpPathError) {
+                                        console.error(`Cannot restore dump from "${dump}": the archive lists attachment paths that would write outside the extract directory (unsafe zip paths such as "../" or absolute names).`);
+                                        console.error(err.message);
+                                        console.error("Only use dump archives produced by this tool; do not load untrusted or third-party --dump zip files.");
+                                        throw err;
+                                    }
+                                    console.error(`Can't restore attachment contents from "${dump}", continuing without them`);
+                                    console.error(errorDetails(err));
+                                }
+                            });
+                            await measurePerf(PERF_METRIC_NAMES.restoreStateStoreRestore, async () => __classPrivateFieldGet(this, _AllureReport_store, "f").restoreState(dumpState, resultsAttachments));
+                            console.info(`Successfully restored state from "${dump}"`);
                         }
                         catch (err) {
-                            if (err instanceof UnsafeDumpPathError) {
-                                console.error(`Cannot restore dump from "${dump}": the archive lists attachment paths that would write outside the extract directory (unsafe zip paths such as "../" or absolute names).`);
-                                console.error(err.message);
-                                console.error("Only use dump archives produced by this tool; do not load untrusted or third-party --dump zip files.");
-                                throw err;
+                            restoreError = err;
+                            throw err;
+                        }
+                        finally {
+                            try {
+                                await dumpArchive.close();
+                            }
+                            catch (err) {
+                                if (!restoreError) {
+                                    console.error(`Failed to close dump archive "${dump}"`);
+                                    console.error(errorDetails(err));
+                                }
                             }
-                            console.error(`Can't restore attachment contents from "${dump}", continuing without them`);
-                            console.error(errorDetails(err));
                         }
-                        await __classPrivateFieldGet(this, _AllureReport_store, "f").restoreState(dumpState, resultsAttachments);
-                        console.info(`Successfully restored state from "${dump}"`);
                     }
                     catch (err) {
-                        restoreError = err;
-                        throw err;
+                        console.error(`Failed to restore state from "${dump}", continuing without it`);
+                        console.error(errorDetails(err));
                     }
-                    finally {
-                        try {
-                            await dumpArchive.close();
-                        }
-                        catch (err) {
-                            if (!restoreError) {
-                                console.error(`Failed to close dump archive "${dump}"`);
-                                console.error(errorDetails(err));
-                            }
-                        }
-                    }
-                }
-                catch (err) {
-                    console.error(`Failed to restore state from "${dump}", continuing without it`);
-                    console.error(errorDetails(err));
-                }
+                });
             }
-        };
+        });
         _AllureReport_getReportsToPublish.set(this, async () => {
             const reports = [];
             for (const { enabled, id, options } of __classPrivateFieldGet(this, _AllureReport_plugins, "f")) {
@@ -663,7 +672,7 @@ export class AllureReport {
         _AllureReport_generateRootSummary.set(this, async () => {
             const summaries = [...__classPrivateFieldGet(this, _AllureReport_summariesByPluginId, "f").values()].map(clonePluginSummary);
             if (summaries.length > 1) {
-                __classPrivateFieldSet(this, _AllureReport_summaryPath, await generateSummary(__classPrivateFieldGet(this, _AllureReport_output, "f"), summaries), "f");
+                __classPrivateFieldSet(this, _AllureReport_summaryPath, await measurePerf(PERF_METRIC_NAMES.summaryGenerate, async () => generateSummary(__classPrivateFieldGet(this, _AllureReport_output, "f"), summaries)), "f");
             }
             else {
                 __classPrivateFieldSet(this, _AllureReport_summaryPath, undefined, "f");
@@ -674,96 +683,119 @@ export class AllureReport {
             if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") !== "running") {
                 throw new Error(initRequired);
             }
-            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();
-            }
-            catch (e) {
-                console.error("realtime update failed during shutdown", e);
-            }
-            __classPrivateFieldSet(this, _AllureReport_executionStage, "done", "f");
-            if (__classPrivateFieldGet(this, _AllureReport_dump, "f")) {
-                await this.dumpState();
-                return;
-            }
-            await __classPrivateFieldGet(this, _AllureReport_eachPlugin, "f").call(this, false, async (plugin, context) => {
-                await plugin.done?.(context, __classPrivateFieldGet(this, _AllureReport_store, "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) {
+                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();
+                }
+                catch (e) {
+                    console.error("realtime update failed during shutdown", e);
+                }
+                __classPrivateFieldSet(this, _AllureReport_executionStage, "done", "f");
+                if (__classPrivateFieldGet(this, _AllureReport_dump, "f")) {
+                    await this.dumpState();
                     return;
                 }
-                summary.pluginId = context.id;
-                summary.pullRequestHref = __classPrivateFieldGet(this, _AllureReport_ci, "f")?.pullRequestUrl;
-                summary.jobHref = __classPrivateFieldGet(this, _AllureReport_ci, "f")?.jobRunUrl;
-                summaries.push({
-                    ...summary,
-                    href: `${context.id}/`,
+                await measurePerf(PERF_METRIC_NAMES.generatePluginsDone, async () => {
+                    await __classPrivateFieldGet(this, _AllureReport_eachPlugin, "f").call(this, false, async (plugin, context) => {
+                        await measurePerf(`${PERF_METRIC_PREFIXES.generatePluginDone}${context.id}`, async () => {
+                            await plugin.done?.(context, __classPrivateFieldGet(this, _AllureReport_store, "f"));
+                        });
+                    });
                 });
-            });
-            __classPrivateFieldSet(this, _AllureReport_summariesByPluginId, new Map(summaries
-                .filter((summary) => !!summary.pluginId)
-                .map((summary) => [summary.pluginId, summary])), "f");
-            await __classPrivateFieldGet(this, _AllureReport_publish, "f").call(this);
-            let outputDirFiles = [];
-            try {
-                outputDirFiles = await readdir(__classPrivateFieldGet(this, _AllureReport_output, "f"));
-            }
-            catch { }
-            if (outputDirFiles.length === 0) {
-                return;
-            }
-            const reportPath = join(__classPrivateFieldGet(this, _AllureReport_output, "f"), outputDirFiles[0]);
-            const reportStats = await lstat(reportPath);
-            const outputEntriesStats = await Promise.all(outputDirFiles.map((file) => lstat(join(__classPrivateFieldGet(this, _AllureReport_output, "f"), file))));
-            const outputDirectoryEntries = outputEntriesStats.filter((entry) => entry.isDirectory());
-            if (reportStats.isDirectory() && outputDirectoryEntries.length === 1) {
-                const reportContent = await readdir(reportPath);
-                for (const entry of reportContent) {
-                    const currentFilePath = join(reportPath, entry);
-                    const newFilePath = resolve(dirname(currentFilePath), "..", entry);
-                    await rename(currentFilePath, newFilePath);
-                }
-                await rm(reportPath, { recursive: true });
-            }
-            for (const dir of __classPrivateFieldGet(this, _AllureReport_dumpTempDirs, "f")) {
+                __classPrivateFieldGet(this, _AllureReport_finishGeneratePerfSpan, "f").call(this);
+                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) {
+                        return;
+                    }
+                    summary.pluginId = context.id;
+                    summary.pullRequestHref = __classPrivateFieldGet(this, _AllureReport_ci, "f")?.pullRequestUrl;
+                    summary.jobHref = __classPrivateFieldGet(this, _AllureReport_ci, "f")?.jobRunUrl;
+                    summaries.push({
+                        ...summary,
+                        href: `${context.id}/`,
+                    });
+                });
+                __classPrivateFieldSet(this, _AllureReport_summariesByPluginId, new Map(summaries
+                    .filter((summary) => !!summary.pluginId)
+                    .map((summary) => [summary.pluginId, summary])), "f");
+                await __classPrivateFieldGet(this, _AllureReport_publish, "f").call(this);
+                let outputDirFiles = [];
                 try {
-                    await rm(dir, { recursive: true });
+                    outputDirFiles = await readdir(__classPrivateFieldGet(this, _AllureReport_output, "f"));
                 }
                 catch { }
-            }
-            if (__classPrivateFieldGet(this, _AllureReport_history, "f")) {
-                try {
-                    await __classPrivateFieldGet(this, _AllureReport_store, "f").appendHistory(__classPrivateFieldGet(this, _AllureReport_historyDataPoint, "f"));
+                if (outputDirFiles.length === 0) {
+                    return;
                 }
-                catch (err) {
-                    if (err instanceof KnownError) {
-                        console.error("Failed to append history", err.message);
+                const reportPath = join(__classPrivateFieldGet(this, _AllureReport_output, "f"), outputDirFiles[0]);
+                const reportStats = await lstat(reportPath);
+                const outputEntriesStats = await Promise.all(outputDirFiles.map((file) => lstat(join(__classPrivateFieldGet(this, _AllureReport_output, "f"), file))));
+                const outputDirectoryEntries = outputEntriesStats.filter((entry) => entry.isDirectory());
+                if (reportStats.isDirectory() && outputDirectoryEntries.length === 1) {
+                    const reportContent = await readdir(reportPath);
+                    for (const entry of reportContent) {
+                        const currentFilePath = join(reportPath, entry);
+                        const newFilePath = resolve(dirname(currentFilePath), "..", entry);
+                        await rename(currentFilePath, newFilePath);
                     }
-                    else if (err instanceof UnknownError) {
-                        console.error("Failed to append history due to unexpected error", err.message);
+                    await rm(reportPath, { recursive: true });
+                }
+                for (const dir of __classPrivateFieldGet(this, _AllureReport_dumpTempDirs, "f")) {
+                    try {
+                        await rm(dir, { recursive: true });
                     }
-                    else {
-                        throw err;
+                    catch { }
+                }
+                if (__classPrivateFieldGet(this, _AllureReport_history, "f")) {
+                    try {
+                        await __classPrivateFieldGet(this, _AllureReport_store, "f").appendHistory(__classPrivateFieldGet(this, _AllureReport_historyDataPoint, "f"));
+                    }
+                    catch (err) {
+                        if (err instanceof KnownError) {
+                            console.error("Failed to append history", err.message);
+                        }
+                        else if (err instanceof UnknownError) {
+                            console.error("Failed to append history due to unexpected error", err.message);
+                        }
+                        else {
+                            throw err;
+                        }
                     }
                 }
+                if (__classPrivateFieldGet(this, _AllureReport_publishedRemoteHrefs, "f").size > 0) {
+                    console.info("Next reports have been published:");
+                    __classPrivateFieldGet(this, _AllureReport_publishedRemoteHrefs, "f").forEach((href) => {
+                        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));
             }
-            if (__classPrivateFieldGet(this, _AllureReport_publishedRemoteHrefs, "f").size > 0) {
-                console.info("Next reports have been published:");
-                __classPrivateFieldGet(this, _AllureReport_publishedRemoteHrefs, "f").forEach((href) => {
-                    console.info(`- ${href}`);
-                });
-            }
-            if (!__classPrivateFieldGet(this, _AllureReport_qualityGate, "f")) {
-                return;
+            finally {
+                await __classPrivateFieldGet(this, _AllureReport_finishPerfMetrics, "f").call(this);
             }
-            const qualityGateResults = await __classPrivateFieldGet(this, _AllureReport_store, "f").qualityGateResultsByEnv();
-            await writeFile(join(__classPrivateFieldGet(this, _AllureReport_output, "f"), "quality-gate.json"), JSON.stringify(qualityGateResults));
         };
+        _AllureReport_finishGeneratePerfSpan.set(this, () => {
+            __classPrivateFieldGet(this, _AllureReport_endGeneratePerfSpan, "f")?.call(this);
+            __classPrivateFieldSet(this, _AllureReport_endGeneratePerfSpan, undefined, "f");
+        });
+        _AllureReport_finishPerfMetrics.set(this, async () => {
+            __classPrivateFieldGet(this, _AllureReport_finishGeneratePerfSpan, "f").call(this);
+            try {
+                await writePerfMetrics(__classPrivateFieldGet(this, _AllureReport_output, "f"));
+            }
+            catch (err) {
+                console.error("Failed to write Allure performance metrics", err);
+            }
+        });
         _AllureReport_eachPlugin.set(this, async (initState, consumer) => {
             if (initState) {
                 __classPrivateFieldSet(this, _AllureReport_state, {}, "f");
@@ -886,6 +918,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_allureServiceClient = new WeakMap(), _AllureReport_qualityGate = new WeakMap(), _AllureReport_dump = new WeakMap(), _AllureReport_categories = new WeakMap(), _AllureReport_environments = new WeakMap(), _AllureReport_globalAttachments = new WeakMap(), _AllureReport_dumpTempDirs = new WeakMap(), _AllureReport_state = new WeakMap(), _AllureReport_executionStage = new WeakMap(), _AllureReport_historyDataPoint = new WeakMap(), _AllureReport_summaryPath = new WeakMap(), _AllureReport_summariesByPluginId = new WeakMap(), _AllureReport_publishedRemoteHrefs = new WeakMap(), _AllureReport_published = new WeakMap(), _AllureReport_publish = new WeakMap(), _AllureReport_runRealtimeUpdate = 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_generateRootSummary = 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_allureServiceClient = new WeakMap(), _AllureReport_qualityGate = new WeakMap(), _AllureReport_dump = new WeakMap(), _AllureReport_categories = new WeakMap(), _AllureReport_environments = new WeakMap(), _AllureReport_globalAttachments = new WeakMap(), _AllureReport_dumpTempDirs = new WeakMap(), _AllureReport_state = new WeakMap(), _AllureReport_executionStage = new WeakMap(), _AllureReport_historyDataPoint = new WeakMap(), _AllureReport_summaryPath = 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_getReportsToPublish = new WeakMap(), _AllureReport_cleanupFailedRemoteReport = new WeakMap(), _AllureReport_logPublishError = new WeakMap(), _AllureReport_applyPublishLinksToSummaries = new WeakMap(), _AllureReport_cloneSummariesByPluginId = new WeakMap(), _AllureReport_writeSummaryFiles = 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/utils/perf.d.ts

@@ -0,0 +1,42 @@
+export declare const PERF_METRICS_FILE = "allure-perf-metrics.json";
+export type PerfMetricSpan = {
+    name: string;
+    startTimeMs: number;
+    durationMs: number;
+};
+export type PerfMetricSummary = {
+    name: string;
+    count: number;
+    totalMs: number;
+    minMs: number;
+    maxMs: number;
+    avgMs: number;
+};
+export type PerfMetricsPayload = {
+    version: 1;
+    generatedAt: string;
+    timeOriginMs: number;
+    spans: PerfMetricSpan[];
+    summary: PerfMetricSummary[];
+};
+export declare const PERF_METRIC_NAMES: {
+    readonly restoreStateTotal: "restoreState.total";
+    readonly restoreStateDump: "restoreState.dump";
+    readonly restoreStateAttachments: "restoreState.attachments";
+    readonly restoreStateStoreRestore: "restoreState.storeRestore";
+    readonly generateTotal: "generate.total";
+    readonly generateReadResults: "generate.readResults";
+    readonly generatePluginsDone: "generate.plugins.done";
+    readonly publishUploadTotal: "publish.upload.total";
+    readonly summaryGenerate: "summary.generate";
+};
+export declare const PERF_METRIC_PREFIXES: {
+    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 getPerfMetricsPayload: () => PerfMetricsPayload;
+export declare const writePerfMetrics: (output: string) => Promise<boolean>;
+export declare const resetPerfMetrics: () => void;

package/dist/utils/perf.js

@@ -0,0 +1,122 @@
+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";
+const MARK_PREFIX = "allure:perf:";
+const ENABLED_VALUES = new Set(["1", "true", "yes", "on"]);
+const SPANS = [];
+const MARKS = new Set();
+const MEASURES = new Set();
+let sequence = 0;
+const round = (value) => Number(value.toFixed(3));
+export const PERF_METRIC_NAMES = {
+    restoreStateTotal: "restoreState.total",
+    restoreStateDump: "restoreState.dump",
+    restoreStateAttachments: "restoreState.attachments",
+    restoreStateStoreRestore: "restoreState.storeRestore",
+    generateTotal: "generate.total",
+    generateReadResults: "generate.readResults",
+    generatePluginsDone: "generate.plugins.done",
+    publishUploadTotal: "publish.upload.total",
+    summaryGenerate: "summary.generate",
+};
+export const PERF_METRIC_PREFIXES = {
+    generatePluginDone: "generate.plugin.done.",
+    publishUploadPlugin: "publish.upload.plugin.",
+};
+export const isPerfMetricsEnabled = () => ENABLED_VALUES.has((process.env.ALLURE_PERF_METRICS ?? "").toLowerCase());
+export const startPerfSpan = (name) => {
+    if (!isPerfMetricsEnabled()) {
+        return () => { };
+    }
+    const id = `${MARK_PREFIX}${sequence++}:${name}`;
+    const startMark = `${id}:start`;
+    const endMark = `${id}:end`;
+    let ended = false;
+    MARKS.add(startMark);
+    MARKS.add(endMark);
+    MEASURES.add(id);
+    performance.mark(startMark);
+    return () => {
+        if (ended) {
+            return;
+        }
+        ended = true;
+        performance.mark(endMark);
+        performance.measure(id, startMark, endMark);
+        const entry = performance.getEntriesByName(id, "measure").at(-1);
+        if (entry) {
+            SPANS.push({
+                name,
+                startTimeMs: round(entry.startTime),
+                durationMs: round(entry.duration),
+            });
+        }
+        performance.clearMarks(startMark);
+        performance.clearMarks(endMark);
+        performance.clearMeasures(id);
+        MARKS.delete(startMark);
+        MARKS.delete(endMark);
+        MEASURES.delete(id);
+    };
+};
+export const measurePerf = async (name, fn) => {
+    if (!isPerfMetricsEnabled()) {
+        return fn();
+    }
+    const end = startPerfSpan(name);
+    try {
+        return await fn();
+    }
+    finally {
+        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);
+    }
+    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),
+            };
+        }),
+    };
+};
+export const writePerfMetrics = async (output) => {
+    if (!isPerfMetricsEnabled()) {
+        return false;
+    }
+    const payload = getPerfMetricsPayload();
+    await mkdir(output, { recursive: true });
+    await writeFile(join(output, PERF_METRICS_FILE), `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+    resetPerfMetrics();
+    return true;
+};
+export const resetPerfMetrics = () => {
+    SPANS.length = 0;
+    sequence = 0;
+    for (const mark of MARKS) {
+        performance.clearMarks(mark);
+    }
+    for (const measure of MEASURES) {
+        performance.clearMeasures(measure);
+    }
+    MARKS.clear();
+    MEASURES.clear();
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/core",
-  "version": "3.9.0",
+  "version": "3.10.0",
   "description": "Collection of generic Allure utilities used across the entire project",
   "keywords": [
     "allure"
@@ -25,25 +25,25 @@
     "lint:fix": "oxlint --import-plugin --fix src test features stories"
   },
   "dependencies": {
-    "@allurereport/ci": "3.9.0",
-    "@allurereport/core-api": "3.9.0",
-    "@allurereport/plugin-agent": "3.9.0",
-    "@allurereport/plugin-allure2": "3.9.0",
-    "@allurereport/plugin-api": "3.9.0",
-    "@allurereport/plugin-awesome": "3.9.0",
-    "@allurereport/plugin-classic": "3.9.0",
-    "@allurereport/plugin-csv": "3.9.0",
-    "@allurereport/plugin-dashboard": "3.9.0",
-    "@allurereport/plugin-jira": "3.9.0",
-    "@allurereport/plugin-log": "3.9.0",
-    "@allurereport/plugin-progress": "3.9.0",
-    "@allurereport/plugin-slack": "3.9.0",
-    "@allurereport/plugin-testops": "3.9.0",
-    "@allurereport/plugin-testplan": "3.9.0",
-    "@allurereport/reader": "3.9.0",
-    "@allurereport/reader-api": "3.9.0",
-    "@allurereport/service": "3.9.0",
-    "@allurereport/summary": "3.9.0",
+    "@allurereport/ci": "3.10.0",
+    "@allurereport/core-api": "3.10.0",
+    "@allurereport/plugin-agent": "3.10.0",
+    "@allurereport/plugin-allure2": "3.10.0",
+    "@allurereport/plugin-api": "3.10.0",
+    "@allurereport/plugin-awesome": "3.10.0",
+    "@allurereport/plugin-classic": "3.10.0",
+    "@allurereport/plugin-csv": "3.10.0",
+    "@allurereport/plugin-dashboard": "3.10.0",
+    "@allurereport/plugin-jira": "3.10.0",
+    "@allurereport/plugin-log": "3.10.0",
+    "@allurereport/plugin-progress": "3.10.0",
+    "@allurereport/plugin-slack": "3.10.0",
+    "@allurereport/plugin-testops": "3.10.0",
+    "@allurereport/plugin-testplan": "3.10.0",
+    "@allurereport/reader": "3.10.0",
+    "@allurereport/reader-api": "3.10.0",
+    "@allurereport/service": "3.10.0",
+    "@allurereport/summary": "3.10.0",
     "glob": "^13.0.6",
     "handlebars": "^4.7.9",
     "node-stream-zip": "^1.15.0",
@@ -53,15 +53,15 @@
     "zip-stream": "^7.0.2"
   },
   "devDependencies": {
-    "@types/node": "^20.17.9",
+    "@types/node": "^20",
     "@types/zip-stream": "^7.0.0",
-    "@vitest/runner": "^2.1.9",
+    "@vitest/runner": "^2",
     "@vitest/snapshot": "^2.1.9",
-    "allure-js-commons": "^3.3.3",
-    "allure-vitest": "^3.3.3",
-    "rimraf": "^6.0.1",
+    "allure-js-commons": "^3",
+    "allure-vitest": "^3",
+    "rimraf": "^6",
     "tslib": "^2.7.0",
-    "typescript": "^5.6.3",
-    "vitest": "^2.1.9"
+    "typescript": "^5",
+    "vitest": "^4.1.0"
   }
 }