@allurereport/core 3.8.0 → 3.8.1

package/dist/report.js

@@ -44,6 +44,7 @@ const remoteReportParams = (ci) => {
     const branch = ci?.jobRunBranch;
     return repo && branch ? { repo, branch } : {};
 };
+const errorDetails = (err) => (err instanceof Error ? (err.stack ?? err.message) : String(err));
 export class AllureReport {
     constructor(opts) {
         _AllureReport_instances.add(this);
@@ -300,125 +301,152 @@ export class AllureReport {
         this.restoreState = async (dumps) => {
             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;
                 }
-                const dumpArchive = new ZipReadStream.async({
-                    file: dump,
-                });
                 try {
-                    const dumpEntries = await dumpArchive.entries();
-                    const dumpEntriesList = Object.entries(dumpEntries);
-                    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);
+                                continue;
                             }
-                            await this.restoreState(nestedDumpPaths);
-                            continue;
                         }
-                    }
-                    const testResultsEntry = await dumpArchive.entryData(AllureStoreDumpFiles.TestResults);
-                    const testCasesEntry = await dumpArchive.entryData(AllureStoreDumpFiles.TestCases);
-                    const fixturesEntry = await dumpArchive.entryData(AllureStoreDumpFiles.Fixtures);
-                    const attachmentsEntry = await dumpArchive.entryData(AllureStoreDumpFiles.Attachments);
-                    const checkResultsEntry = await optionalEntryData(AllureStoreDumpFiles.CheckResults);
-                    const environmentsEntry = await dumpArchive.entryData(AllureStoreDumpFiles.Environments);
-                    const reportVariablesEntry = await dumpArchive.entryData(AllureStoreDumpFiles.ReportVariables);
-                    const globalAttachmentsEntry = await dumpArchive.entryData(AllureStoreDumpFiles.GlobalAttachments);
-                    const globalErrorsEntry = await dumpArchive.entryData(AllureStoreDumpFiles.GlobalErrors);
-                    const indexAttachmentsEntry = await dumpArchive.entryData(AllureStoreDumpFiles.IndexAttachmentsByTestResults);
-                    const indexTestResultsByHistoryId = await dumpArchive.entryData(AllureStoreDumpFiles.IndexTestResultsByHistoryId);
-                    const indexTestResultsByTestCaseEntry = await dumpArchive.entryData(AllureStoreDumpFiles.IndexTestResultsByTestCase);
-                    const indexLatestEnvTestResultsByHistoryIdEntry = await dumpArchive.entryData(AllureStoreDumpFiles.IndexLatestEnvTestResultsByHistoryId);
-                    const indexAttachmentsByFixtureEntry = await dumpArchive.entryData(AllureStoreDumpFiles.IndexAttachmentsByFixture);
-                    const indexFixturesByTestResultEntry = await dumpArchive.entryData(AllureStoreDumpFiles.IndexFixturesByTestResult);
-                    const indexKnownByHistoryIdEntry = await dumpArchive.entryData(AllureStoreDumpFiles.IndexKnownByHistoryId);
-                    const qualityGateResultsEntry = await dumpArchive.entryData(AllureStoreDumpFiles.QualityGateResults);
-                    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.IndexLatestEnvTestResultsByHistoryId:
-                            case AllureStoreDumpFiles.IndexAttachmentsByFixture:
-                            case AllureStoreDumpFiles.IndexFixturesByTestResult:
-                            case AllureStoreDumpFiles.IndexKnownByHistoryId:
-                            case AllureStoreDumpFiles.QualityGateResults:
-                                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 indexLatestEnvTestResultsByHistoryIdEntry = await requiredEntryData(AllureStoreDumpFiles.IndexLatestEnvTestResultsByHistoryId);
+                        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 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.IndexLatestEnvTestResultsByHistoryId:
+                                case AllureStoreDumpFiles.IndexAttachmentsByFixture:
+                                case AllureStoreDumpFiles.IndexFixturesByTestResult:
+                                case AllureStoreDumpFiles.IndexKnownByHistoryId:
+                                case AllureStoreDumpFiles.QualityGateResults:
                                     return acc;
-                                }
-                                return Object.assign(acc, {
-                                    [entryName]: entry,
-                                });
+                                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")),
+                            indexLatestEnvTestResultByHistoryId: JSON.parse(indexLatestEnvTestResultsByHistoryIdEntry.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")),
+                        };
+                        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);
+                            }
                         }
-                    }, {});
-                    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")),
-                        indexLatestEnvTestResultByHistoryId: JSON.parse(indexLatestEnvTestResultsByHistoryIdEntry.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")),
-                    };
-                    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 __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 state from "${dump}", continuing without it`);
-                        console.error(err);
                     }
-                    await __classPrivateFieldGet(this, _AllureReport_store, "f").restoreState(dumpState, resultsAttachments);
-                    console.info(`Successfully restored state from "${dump}"`);
                 }
-                finally {
-                    await dumpArchive.close();
+                catch (err) {
+                    console.error(`Failed to restore state from "${dump}", continuing without it`);
+                    console.error(errorDetails(err));
                 }
             }
         };

package/dist/store/store.js

@@ -11,7 +11,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 };
 var _DefaultAllureStore_instances, _DefaultAllureStore_testResults, _DefaultAllureStore_environmentDisplayNames, _DefaultAllureStore_environmentNameToId, _DefaultAllureStore_attachments, _DefaultAllureStore_attachmentContents, _DefaultAllureStore_testCases, _DefaultAllureStore_metadata, _DefaultAllureStore_history, _DefaultAllureStore_known, _DefaultAllureStore_fixtures, _DefaultAllureStore_defaultLabels, _DefaultAllureStore_environment, _DefaultAllureStore_environmentsConfig, _DefaultAllureStore_reportVariables, _DefaultAllureStore_realtimeDispatcher, _DefaultAllureStore_realtimeSubscriber, _DefaultAllureStore_allowedEnvironmentIds, _DefaultAllureStore_globalAttachmentIds, _DefaultAllureStore_globalAttachmentIdsByEnv, _DefaultAllureStore_globalErrors, _DefaultAllureStore_globalErrorsByEnv, _DefaultAllureStore_globalExitCode, _DefaultAllureStore_checkResults, _DefaultAllureStore_qualityGateResults, _DefaultAllureStore_historyPoints, _DefaultAllureStore_environments, _DefaultAllureStore_mergeEnvironmentIdentity, _DefaultAllureStore_environmentIdForLookup, _DefaultAllureStore_addEnvironments, _DefaultAllureStore_environmentIdByName, _DefaultAllureStore_setTestResultEnvironmentId, _DefaultAllureStore_assertAllowedEnvironmentId, _DefaultAllureStore_assertAllowedStoredEnvironment, _DefaultAllureStore_environmentIdByTestResult, _DefaultAllureStore_resolveGlobalEnvironmentIdentity, _DefaultAllureStore_globalAttachmentId, _DefaultAllureStore_indexGlobalError, _DefaultAllureStore_addGlobalError, _DefaultAllureStore_indexGlobalAttachment, _DefaultAllureStore_addGlobalAttachment, _DefaultAllureStore_restoreAttachmentContent, _DefaultAllureStore_relinkRestoredAttachmentSteps;
 import { extname } from "node:path";
-import { DEFAULT_ENVIRONMENT, DEFAULT_ENVIRONMENT_IDENTITY, compareBy, createDictionary, getHistoryIdCandidates, getWorstStatus, nullsLast, ordinal, reverse, selectHistoryTestResults, validateEnvironmentId, validateEnvironmentName, } from "@allurereport/core-api";
+import { DEFAULT_ENVIRONMENT, DEFAULT_ENVIRONMENT_IDENTITY, compareBy, createDictionary, getHistoryIdCandidates, getWorstStatus, nullsLast, normalizeHistoryDataPoint, ordinal, reverse, selectHistoryTestResults, validateEnvironmentId, validateEnvironmentName, } from "@allurereport/core-api";
 import { md5, } from "@allurereport/plugin-api";
 import { environmentIdentityById, normalizeEnvironmentDescriptorMap, resolveEnvironmentIdentity, resolveStoredEnvironmentIdentity, validateAllowedEnvironmentId, } from "../utils/environment.js";
 import { isFlaky } from "../utils/flaky.js";
@@ -196,7 +196,9 @@ export class DefaultAllureStore {
         if (!__classPrivateFieldGet(this, _DefaultAllureStore_history, "f")) {
             return [];
         }
-        __classPrivateFieldSet(this, _DefaultAllureStore_historyPoints, (await __classPrivateFieldGet(this, _DefaultAllureStore_history, "f").readHistory()) ?? [], "f");
+        __classPrivateFieldSet(this, _DefaultAllureStore_historyPoints, ((await __classPrivateFieldGet(this, _DefaultAllureStore_history, "f").readHistory()) ?? [])
+            .filter((historyPoint) => typeof historyPoint === "object" && historyPoint !== null)
+            .map(normalizeHistoryDataPoint), "f");
         __classPrivateFieldGet(this, _DefaultAllureStore_historyPoints, "f").sort(compareBy("timestamp", reverse(ordinal())));
         return __classPrivateFieldGet(this, _DefaultAllureStore_historyPoints, "f");
     }
@@ -488,7 +490,7 @@ export class DefaultAllureStore {
         }
         return __classPrivateFieldGet(this, _DefaultAllureStore_historyPoints, "f").reduce((result, dp) => {
             const filteredTestResults = [];
-            for (const tr of Object.values(dp.testResults)) {
+            for (const tr of Object.values(dp.testResults ?? {})) {
                 const storedEnvironmentKey = typeof tr.environment === "string" ? tr.environment : undefined;
                 const trEnvId = (storedEnvironmentKey ? __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_environmentIdByName).call(this, storedEnvironmentKey) : undefined) ??
                     resolveStoredEnvironmentIdentity({
@@ -526,7 +528,7 @@ export class DefaultAllureStore {
         if (allHistoryDps.length === 0) {
             return Array.from(__classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f").values());
         }
-        const historicalIds = new Set(allHistoryDps.flatMap((dp) => Object.keys(dp.testResults)));
+        const historicalIds = new Set(allHistoryDps.flatMap((dp) => Object.keys(dp.testResults ?? {})));
         const newTrs = [];
         for (const [, tr] of __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f")) {
             if (tr.hidden) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/core",
-  "version": "3.8.0",
+  "version": "3.8.1",
   "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.8.0",
-    "@allurereport/core-api": "3.8.0",
-    "@allurereport/plugin-agent": "3.8.0",
-    "@allurereport/plugin-allure2": "3.8.0",
-    "@allurereport/plugin-api": "3.8.0",
-    "@allurereport/plugin-awesome": "3.8.0",
-    "@allurereport/plugin-classic": "3.8.0",
-    "@allurereport/plugin-csv": "3.8.0",
-    "@allurereport/plugin-dashboard": "3.8.0",
-    "@allurereport/plugin-jira": "3.8.0",
-    "@allurereport/plugin-log": "3.8.0",
-    "@allurereport/plugin-progress": "3.8.0",
-    "@allurereport/plugin-slack": "3.8.0",
-    "@allurereport/plugin-testops": "3.8.0",
-    "@allurereport/plugin-testplan": "3.8.0",
-    "@allurereport/reader": "3.8.0",
-    "@allurereport/reader-api": "3.8.0",
-    "@allurereport/service": "3.8.0",
-    "@allurereport/summary": "3.8.0",
+    "@allurereport/ci": "3.8.1",
+    "@allurereport/core-api": "3.8.1",
+    "@allurereport/plugin-agent": "3.8.1",
+    "@allurereport/plugin-allure2": "3.8.1",
+    "@allurereport/plugin-api": "3.8.1",
+    "@allurereport/plugin-awesome": "3.8.1",
+    "@allurereport/plugin-classic": "3.8.1",
+    "@allurereport/plugin-csv": "3.8.1",
+    "@allurereport/plugin-dashboard": "3.8.1",
+    "@allurereport/plugin-jira": "3.8.1",
+    "@allurereport/plugin-log": "3.8.1",
+    "@allurereport/plugin-progress": "3.8.1",
+    "@allurereport/plugin-slack": "3.8.1",
+    "@allurereport/plugin-testops": "3.8.1",
+    "@allurereport/plugin-testplan": "3.8.1",
+    "@allurereport/reader": "3.8.1",
+    "@allurereport/reader-api": "3.8.1",
+    "@allurereport/service": "3.8.1",
+    "@allurereport/summary": "3.8.1",
     "glob": "^13.0.6",
     "handlebars": "^4.7.9",
     "node-stream-zip": "^1.15.0",