@allurereport/core 3.0.0-beta.18 → 3.0.0-beta.19

package/dist/api.d.ts

@@ -13,6 +13,8 @@ export interface FullConfig {
     historyPath: string;
     knownIssuesPath: string;
     defaultLabels?: DefaultLabelsConfig;
+    stage?: string;
+    environment?: string;
     environments?: EnvironmentsConfig;
     variables?: ReportVariables;
     reportFiles: ReportFiles;

package/dist/history.js

@@ -16,15 +16,13 @@ const createHistoryItems = (testResults) => {
             stop,
             duration,
             labels,
+            url: "",
             historyId: historyId,
             reportLinks: [],
         };
     })
         .reduce((acc, item) => {
-        acc[item.historyId] = {
-            ...item,
-            url: "",
-        };
+        acc[item.historyId] = item;
         return acc;
     }, {});
 };

package/dist/report.d.ts

@@ -1,5 +1,5 @@
 import type { KnownTestFailure, TestResult } from "@allurereport/core-api";
-import type { ResultFile } from "@allurereport/plugin-api";
+import { type ResultFile } from "@allurereport/plugin-api";
 import type { FullConfig } from "./api.js";
 import { type QualityGateState } from "./qualityGate/index.js";
 import { DefaultAllureStore } from "./store/store.js";
@@ -25,5 +25,7 @@ export declare class AllureReport {
         results: import("@allurereport/plugin-api").QualityGateValidationResult[];
     }>;
     start: () => Promise<void>;
+    dumpState: () => Promise<void>;
+    restoreState: (stages: string[]) => Promise<void>;
     done: () => Promise<void>;
 }

package/dist/report.js

@@ -9,18 +9,23 @@ 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_reportName, _AllureReport_ci, _AllureReport_store, _AllureReport_readers, _AllureReport_plugins, _AllureReport_reportFiles, _AllureReport_eventEmitter, _AllureReport_realtimeSubscriber, _AllureReport_realtimeDispatcher, _AllureReport_realTime, _AllureReport_output, _AllureReport_history, _AllureReport_allureServiceClient, _AllureReport_qualityGate, _AllureReport_state, _AllureReport_stage, _AllureReport_publish_get, _AllureReport_update, _AllureReport_eachPlugin, _AllureReport_getPluginState;
+var _AllureReport_instances, _AllureReport_reportName, _AllureReport_reportVariables, _AllureReport_ci, _AllureReport_store, _AllureReport_readers, _AllureReport_plugins, _AllureReport_reportFiles, _AllureReport_eventEmitter, _AllureReport_realtimeSubscriber, _AllureReport_realtimeDispatcher, _AllureReport_realTime, _AllureReport_output, _AllureReport_history, _AllureReport_allureServiceClient, _AllureReport_qualityGate, _AllureReport_stage, _AllureReport_stageTempDirs, _AllureReport_state, _AllureReport_executionStage, _AllureReport_publish_get, _AllureReport_update, _AllureReport_eachPlugin, _AllureReport_getPluginState;
 import { detect } from "@allurereport/ci";
+import { AllureStoreDumpFiles, } from "@allurereport/plugin-api";
 import { allure1, allure2, attachments, cucumberjson, junitXml, readXcResultBundle } from "@allurereport/reader";
 import { PathResultFile } from "@allurereport/reader-api";
 import { AllureRemoteHistory, AllureServiceClient, KnownError, UnknownError } from "@allurereport/service";
 import { generateSummary } from "@allurereport/summary";
+import ZipReadStream from "node-stream-zip";
 import console from "node:console";
 import { randomUUID } from "node:crypto";
 import { EventEmitter } from "node:events";
-import { readFileSync } from "node:fs";
-import { lstat, opendir, readdir, realpath, rename, rm, writeFile } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
+import { createReadStream, createWriteStream, existsSync, readFileSync } from "node:fs";
+import { lstat, mkdtemp, opendir, readdir, realpath, 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";
+import ZipWriteStream from "zip-stream";
 import { AllureLocalHistory, createHistory } from "./history.js";
 import { DefaultPluginState, PluginFiles } from "./plugin.js";
 import { QualityGate } from "./qualityGate/index.js";
@@ -32,6 +37,7 @@ export class AllureReport {
     constructor(opts) {
         _AllureReport_instances.add(this);
         _AllureReport_reportName.set(this, void 0);
+        _AllureReport_reportVariables.set(this, void 0);
         _AllureReport_ci.set(this, void 0);
         _AllureReport_store.set(this, void 0);
         _AllureReport_readers.set(this, void 0);
@@ -45,10 +51,12 @@ export class AllureReport {
         _AllureReport_history.set(this, void 0);
         _AllureReport_allureServiceClient.set(this, void 0);
         _AllureReport_qualityGate.set(this, void 0);
+        _AllureReport_stage.set(this, void 0);
+        _AllureReport_stageTempDirs.set(this, []);
         _AllureReport_state.set(this, void 0);
-        _AllureReport_stage.set(this, "init");
+        _AllureReport_executionStage.set(this, "init");
         this.readDirectory = async (resultsDir) => {
-            if (__classPrivateFieldGet(this, _AllureReport_stage, "f") !== "running") {
+            if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") !== "running") {
                 throw new Error(initRequired);
             }
             const resultsDirPath = resolve(resultsDir);
@@ -69,13 +77,13 @@ export class AllureReport {
             }
         };
         this.readFile = async (resultsFile) => {
-            if (__classPrivateFieldGet(this, _AllureReport_stage, "f") !== "running") {
+            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_stage, "f") !== "running") {
+            if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") !== "running") {
                 throw new Error(initRequired);
             }
             for (const reader of __classPrivateFieldGet(this, _AllureReport_readers, "f")) {
@@ -98,13 +106,13 @@ export class AllureReport {
         };
         this.start = async () => {
             await __classPrivateFieldGet(this, _AllureReport_store, "f").readHistory();
-            if (__classPrivateFieldGet(this, _AllureReport_stage, "f") === "running") {
+            if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") === "running") {
                 throw new Error("the report is already started");
             }
-            if (__classPrivateFieldGet(this, _AllureReport_stage, "f") === "done") {
+            if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") === "done") {
                 throw new Error("the report is already stopped, the restart isn't supported at the moment");
             }
-            __classPrivateFieldSet(this, _AllureReport_stage, "running", "f");
+            __classPrivateFieldSet(this, _AllureReport_executionStage, "running", "f");
             if (__classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f") && __classPrivateFieldGet(this, _AllureReport_instances, "a", _AllureReport_publish_get)) {
                 const { url } = await __classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f").createReport({
                     reportUuid: this.reportUuid,
@@ -123,21 +131,186 @@ export class AllureReport {
             }
         };
         _AllureReport_update.set(this, async () => {
-            if (__classPrivateFieldGet(this, _AllureReport_stage, "f") !== "running") {
+            if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") !== "running") {
                 return;
             }
             await __classPrivateFieldGet(this, _AllureReport_eachPlugin, "f").call(this, false, async (plugin, context) => {
                 await plugin.update?.(context, __classPrivateFieldGet(this, _AllureReport_store, "f"));
             });
         });
+        this.dumpState = async () => {
+            const { testResults, testCases, fixtures, attachments: attachmentsLinks, environments, globalAttachments = [], globalErrors = [], indexAttachmentByTestResult = {}, indexTestResultByHistoryId = {}, indexTestResultByTestCase = {}, indexLatestEnvTestResultByHistoryId = {}, indexAttachmentByFixture = {}, indexFixturesByTestResult = {}, indexKnownByHistoryId = {}, } = __classPrivateFieldGet(this, _AllureReport_store, "f").dumpState();
+            const allAttachments = await __classPrivateFieldGet(this, _AllureReport_store, "f").allAttachments();
+            const dumpArchive = new ZipWriteStream({
+                zlib: { level: 5 },
+            });
+            const addEntry = promisify(dumpArchive.entry.bind(dumpArchive));
+            const dumpArchiveWriteStream = createWriteStream(`${__classPrivateFieldGet(this, _AllureReport_stage, "f")}.zip`);
+            const promise = new Promise((res, rej) => {
+                dumpArchive.on("error", (err) => rej(err));
+                dumpArchiveWriteStream.on("finish", () => res(void 0));
+                dumpArchiveWriteStream.on("error", (err) => rej(err));
+            });
+            dumpArchive.pipe(dumpArchiveWriteStream);
+            await addEntry(Buffer.from(JSON.stringify(testResults)), {
+                name: AllureStoreDumpFiles.TestResults,
+            });
+            await addEntry(Buffer.from(JSON.stringify(testCases)), {
+                name: AllureStoreDumpFiles.TestCases,
+            });
+            await addEntry(Buffer.from(JSON.stringify(fixtures)), {
+                name: AllureStoreDumpFiles.Fixtures,
+            });
+            await addEntry(Buffer.from(JSON.stringify(attachmentsLinks)), {
+                name: AllureStoreDumpFiles.Attachments,
+            });
+            await addEntry(Buffer.from(JSON.stringify(environments)), {
+                name: AllureStoreDumpFiles.Environments,
+            });
+            await addEntry(Buffer.from(JSON.stringify(__classPrivateFieldGet(this, _AllureReport_reportVariables, "f"))), {
+                name: AllureStoreDumpFiles.ReportVariables,
+            });
+            await addEntry(Buffer.from(JSON.stringify(globalAttachments)), {
+                name: AllureStoreDumpFiles.GlobalAttachments,
+            });
+            await addEntry(Buffer.from(JSON.stringify(globalErrors)), {
+                name: AllureStoreDumpFiles.GlobalErrors,
+            });
+            await addEntry(Buffer.from(JSON.stringify(indexAttachmentByTestResult)), {
+                name: AllureStoreDumpFiles.IndexAttachmentsByTestResults,
+            });
+            await addEntry(Buffer.from(JSON.stringify(indexTestResultByHistoryId)), {
+                name: AllureStoreDumpFiles.IndexTestResultsByHistoryId,
+            });
+            await addEntry(Buffer.from(JSON.stringify(indexTestResultByTestCase)), {
+                name: AllureStoreDumpFiles.IndexTestResultsByTestCase,
+            });
+            await addEntry(Buffer.from(JSON.stringify(indexLatestEnvTestResultByHistoryId)), {
+                name: AllureStoreDumpFiles.IndexLatestEnvTestResultsByHistoryId,
+            });
+            await addEntry(Buffer.from(JSON.stringify(indexAttachmentByFixture)), {
+                name: AllureStoreDumpFiles.IndexAttachmentsByFixture,
+            });
+            await addEntry(Buffer.from(JSON.stringify(indexFixturesByTestResult)), {
+                name: AllureStoreDumpFiles.IndexFixturesByTestResult,
+            });
+            await addEntry(Buffer.from(JSON.stringify(indexKnownByHistoryId)), {
+                name: AllureStoreDumpFiles.IndexKnownByHistoryId,
+            });
+            for (const attachment of allAttachments) {
+                const content = await __classPrivateFieldGet(this, _AllureReport_store, "f").attachmentContentById(attachment.id);
+                if (!content) {
+                    continue;
+                }
+                if (content instanceof PathResultFile) {
+                    await addEntry(createReadStream(content.path), {
+                        name: attachment.id,
+                    });
+                }
+                else {
+                    await addEntry(await content.asBuffer(), {
+                        name: attachment.id,
+                    });
+                }
+            }
+            dumpArchive.finalize();
+            return promise;
+        };
+        this.restoreState = async (stages) => {
+            for (const stage of stages) {
+                if (!existsSync(stage)) {
+                    continue;
+                }
+                const dump = new ZipReadStream.async({
+                    file: stage,
+                });
+                const testResultsEntry = await dump.entryData(AllureStoreDumpFiles.TestResults);
+                const testCasesEntry = await dump.entryData(AllureStoreDumpFiles.TestCases);
+                const fixturesEntry = await dump.entryData(AllureStoreDumpFiles.Fixtures);
+                const attachmentsEntry = await dump.entryData(AllureStoreDumpFiles.Attachments);
+                const environmentsEntry = await dump.entryData(AllureStoreDumpFiles.Environments);
+                const reportVariablesEntry = await dump.entryData(AllureStoreDumpFiles.ReportVariables);
+                const globalAttachmentsEntry = await dump.entryData(AllureStoreDumpFiles.GlobalAttachments);
+                const globalErrorsEntry = await dump.entryData(AllureStoreDumpFiles.GlobalErrors);
+                const indexAttachmentsEntry = await dump.entryData(AllureStoreDumpFiles.IndexAttachmentsByTestResults);
+                const indexTestResultsByHistoryId = await dump.entryData(AllureStoreDumpFiles.IndexTestResultsByHistoryId);
+                const indexTestResultsByTestCaseEntry = await dump.entryData(AllureStoreDumpFiles.IndexTestResultsByTestCase);
+                const indexLatestEnvTestResultsByHistoryIdEntry = await dump.entryData(AllureStoreDumpFiles.IndexLatestEnvTestResultsByHistoryId);
+                const indexAttachmentsByFixtureEntry = await dump.entryData(AllureStoreDumpFiles.IndexAttachmentsByFixture);
+                const indexFixturesByTestResultEntry = await dump.entryData(AllureStoreDumpFiles.IndexFixturesByTestResult);
+                const indexKnownByHistoryIdEntry = await dump.entryData(AllureStoreDumpFiles.IndexKnownByHistoryId);
+                const attachmentsEntries = Object.entries(await dump.entries()).reduce((acc, [entryName, entry]) => {
+                    switch (entryName) {
+                        case AllureStoreDumpFiles.Attachments:
+                        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:
+                            return acc;
+                        default:
+                            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: JSON.parse(attachmentsEntry.toString("utf8")),
+                    environments: JSON.parse(environmentsEntry.toString("utf8")),
+                    reportVariables: JSON.parse(reportVariablesEntry.toString("utf8")),
+                    globalAttachments: 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")),
+                };
+                const stageTempDir = await mkdtemp(join(tmpdir(), basename(stage, ".zip")));
+                const resultsAttachments = {};
+                __classPrivateFieldGet(this, _AllureReport_stageTempDirs, "f").push(stageTempDir);
+                try {
+                    for (const [attachmentId] of Object.entries(attachmentsEntries)) {
+                        const attachmentContentEntry = await dump.entryData(attachmentId);
+                        const attachmentFilePath = join(stageTempDir, attachmentId);
+                        await writeFile(attachmentFilePath, attachmentContentEntry);
+                        resultsAttachments[attachmentId] = new PathResultFile(attachmentFilePath, attachmentId);
+                    }
+                }
+                catch (err) {
+                    console.error(`Can't restore state from "${stage}", continuing without it`);
+                    console.error(err);
+                }
+                await __classPrivateFieldGet(this, _AllureReport_store, "f").restoreState(dumpState, resultsAttachments);
+                console.info(`Successfully restored state from "${stage}"`);
+            }
+        };
         this.done = async () => {
             const summaries = [];
             const remoteHrefs = [];
-            if (__classPrivateFieldGet(this, _AllureReport_stage, "f") !== "running") {
+            if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") !== "running") {
                 throw new Error(initRequired);
             }
             __classPrivateFieldGet(this, _AllureReport_realtimeSubscriber, "f").offAll();
-            __classPrivateFieldSet(this, _AllureReport_stage, "done", "f");
+            __classPrivateFieldSet(this, _AllureReport_executionStage, "done", "f");
+            if (__classPrivateFieldGet(this, _AllureReport_stage, "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"));
                 if (__classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f") && context.publish) {
@@ -200,6 +373,12 @@ export class AllureReport {
                 }
                 await rm(reportPath, { recursive: true });
             }
+            for (const dir of __classPrivateFieldGet(this, _AllureReport_stageTempDirs, "f")) {
+                try {
+                    await rm(dir, { recursive: true });
+                }
+                catch (ignored) { }
+            }
             if (__classPrivateFieldGet(this, _AllureReport_history, "f")) {
                 const testResults = await __classPrivateFieldGet(this, _AllureReport_store, "f").allTestResults();
                 const testCases = await __classPrivateFieldGet(this, _AllureReport_store, "f").allTestCases();
@@ -279,16 +458,18 @@ export class AllureReport {
                 }
             }
         });
-        const { name, readers = [allure1, allure2, cucumberjson, junitXml, attachments], plugins = [], known, reportFiles, realTime, historyPath, defaultLabels = {}, variables = {}, environments, output, qualityGate, allureService: allureServiceConfig, } = opts;
+        const { name, readers = [allure1, allure2, cucumberjson, junitXml, attachments], plugins = [], known, reportFiles, realTime, historyPath, defaultLabels = {}, variables = {}, environment, environments, output, qualityGate, stage, allureService: allureServiceConfig, } = opts;
         __classPrivateFieldSet(this, _AllureReport_allureServiceClient, allureServiceConfig?.url ? new AllureServiceClient(allureServiceConfig) : undefined, "f");
         this.reportUuid = randomUUID();
         __classPrivateFieldSet(this, _AllureReport_ci, detect(), "f");
         const reportTitleSuffix = __classPrivateFieldGet(this, _AllureReport_ci, "f")?.pullRequestName ?? __classPrivateFieldGet(this, _AllureReport_ci, "f")?.jobRunName;
         __classPrivateFieldSet(this, _AllureReport_reportName, [name, reportTitleSuffix].filter(Boolean).join(" – "), "f");
+        __classPrivateFieldSet(this, _AllureReport_reportVariables, variables, "f");
         __classPrivateFieldSet(this, _AllureReport_eventEmitter, new EventEmitter(), "f");
         __classPrivateFieldSet(this, _AllureReport_realtimeDispatcher, new RealtimeEventsDispatcher(__classPrivateFieldGet(this, _AllureReport_eventEmitter, "f")), "f");
         __classPrivateFieldSet(this, _AllureReport_realtimeSubscriber, new RealtimeSubscriber(__classPrivateFieldGet(this, _AllureReport_eventEmitter, "f")), "f");
         __classPrivateFieldSet(this, _AllureReport_realTime, realTime, "f");
+        __classPrivateFieldSet(this, _AllureReport_stage, stage, "f");
         if (__classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f")) {
             __classPrivateFieldSet(this, _AllureReport_history, new AllureRemoteHistory(__classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f")), "f");
         }
@@ -306,6 +487,7 @@ export class AllureReport {
             history: __classPrivateFieldGet(this, _AllureReport_history, "f"),
             known,
             defaultLabels,
+            environment,
         }), "f");
         __classPrivateFieldSet(this, _AllureReport_readers, [...readers], "f");
         __classPrivateFieldSet(this, _AllureReport_plugins, [...plugins], "f");
@@ -328,7 +510,7 @@ export class AllureReport {
         return __classPrivateFieldGet(this, _AllureReport_realtimeDispatcher, "f");
     }
 }
-_AllureReport_reportName = new WeakMap(), _AllureReport_ci = new WeakMap(), _AllureReport_store = new WeakMap(), _AllureReport_readers = new WeakMap(), _AllureReport_plugins = new WeakMap(), _AllureReport_reportFiles = new WeakMap(), _AllureReport_eventEmitter = new WeakMap(), _AllureReport_realtimeSubscriber = new WeakMap(), _AllureReport_realtimeDispatcher = new WeakMap(), _AllureReport_realTime = new WeakMap(), _AllureReport_output = new WeakMap(), _AllureReport_history = new WeakMap(), _AllureReport_allureServiceClient = new WeakMap(), _AllureReport_qualityGate = new WeakMap(), _AllureReport_state = new WeakMap(), _AllureReport_stage = new WeakMap(), _AllureReport_update = new WeakMap(), _AllureReport_eachPlugin = new WeakMap(), _AllureReport_instances = new WeakSet(), _AllureReport_publish_get = function _AllureReport_publish_get() {
+_AllureReport_reportName = new WeakMap(), _AllureReport_reportVariables = new WeakMap(), _AllureReport_ci = new WeakMap(), _AllureReport_store = new WeakMap(), _AllureReport_readers = new WeakMap(), _AllureReport_plugins = new WeakMap(), _AllureReport_reportFiles = new WeakMap(), _AllureReport_eventEmitter = new WeakMap(), _AllureReport_realtimeSubscriber = new WeakMap(), _AllureReport_realtimeDispatcher = new WeakMap(), _AllureReport_realTime = new WeakMap(), _AllureReport_output = new WeakMap(), _AllureReport_history = new WeakMap(), _AllureReport_allureServiceClient = new WeakMap(), _AllureReport_qualityGate = new WeakMap(), _AllureReport_stage = new WeakMap(), _AllureReport_stageTempDirs = new WeakMap(), _AllureReport_state = new WeakMap(), _AllureReport_executionStage = new WeakMap(), _AllureReport_update = new WeakMap(), _AllureReport_eachPlugin = new WeakMap(), _AllureReport_instances = new WeakSet(), _AllureReport_publish_get = function _AllureReport_publish_get() {
     return __classPrivateFieldGet(this, _AllureReport_plugins, "f").some(({ enabled, options }) => enabled && options.publish);
 }, _AllureReport_getPluginState = function _AllureReport_getPluginState(init, id) {
     return init ? new DefaultPluginState({}) : __classPrivateFieldGet(this, _AllureReport_state, "f")?.[id];

package/dist/store/store.d.ts

@@ -1,6 +1,8 @@
 import { type AllureHistory, type AttachmentLink, type DefaultLabelsConfig, type EnvironmentsConfig, type HistoryDataPoint, type HistoryTestResult, type KnownTestFailure, type RepoData, type ReportVariables, type TestCase, type TestEnvGroup, type TestError, type TestFixtureResult, type TestResult } from "@allurereport/core-api";
-import { type AllureStore, type ExitCode, type QualityGateValidationResult, type RealtimeEventsDispatcher, type RealtimeSubscriber, type ResultFile, type TestResultFilter } from "@allurereport/plugin-api";
+import { type AllureStore, type AllureStoreDump, type ExitCode, type QualityGateValidationResult, type RealtimeEventsDispatcher, type RealtimeSubscriber, type ResultFile, type TestResultFilter } from "@allurereport/plugin-api";
 import type { RawFixtureResult, RawMetadata, RawTestResult, ReaderContext, ResultsVisitor } from "@allurereport/reader-api";
+export declare const mapToObject: <K extends string | number | symbol, T = any>(map: Map<K, T>) => Record<K, T>;
+export declare const mergeMapWithRecord: <K extends string | number | symbol, T = any>(map: Map<K, T>, record: Record<K, T>) => Map<K, T>;
 export declare class DefaultAllureStore implements AllureStore, ResultsVisitor {
     #private;
     readonly indexTestResultByTestCase: Map<string, TestResult[]>;
@@ -16,6 +18,7 @@ export declare class DefaultAllureStore implements AllureStore, ResultsVisitor {
         realtimeDispatcher?: RealtimeEventsDispatcher;
         realtimeSubscriber?: RealtimeSubscriber;
         defaultLabels?: DefaultLabelsConfig;
+        environment?: string;
         environmentsConfig?: EnvironmentsConfig;
         reportVariables?: ReportVariables;
     });
@@ -71,4 +74,6 @@ export declare class DefaultAllureStore implements AllureStore, ResultsVisitor {
     envVariables(env: string): Promise<{
         [x: string]: string;
     }>;
+    dumpState(): AllureStoreDump;
+    restoreState(stateDump: AllureStoreDump, attachmentsContents?: Record<string, ResultFile>): Promise<void>;
 }

package/dist/store/store.js

@@ -9,8 +9,8 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _DefaultAllureStore_testResults, _DefaultAllureStore_attachments, _DefaultAllureStore_attachmentContents, _DefaultAllureStore_testCases, _DefaultAllureStore_metadata, _DefaultAllureStore_history, _DefaultAllureStore_known, _DefaultAllureStore_fixtures, _DefaultAllureStore_defaultLabels, _DefaultAllureStore_environmentsConfig, _DefaultAllureStore_reportVariables, _DefaultAllureStore_realtimeDispatcher, _DefaultAllureStore_realtimeSubscriber, _DefaultAllureStore_globalAttachments, _DefaultAllureStore_globalErrors, _DefaultAllureStore_globalExitCode, _DefaultAllureStore_qualityGateResultsByRules, _DefaultAllureStore_historyPoints, _DefaultAllureStore_repoData;
-import { compareBy, getWorstStatus, matchEnvironment, nullsLast, ordinal, reverse, } from "@allurereport/core-api";
+var _DefaultAllureStore_instances, _DefaultAllureStore_testResults, _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_globalAttachments, _DefaultAllureStore_globalErrors, _DefaultAllureStore_globalExitCode, _DefaultAllureStore_qualityGateResultsByRules, _DefaultAllureStore_historyPoints, _DefaultAllureStore_repoData, _DefaultAllureStore_environments, _DefaultAllureStore_addEnvironments;
+import { DEFAULT_ENVIRONMENT, compareBy, getWorstStatus, htrsByTr, matchEnvironment, nullsLast, ordinal, reverse, } from "@allurereport/core-api";
 import { md5, } from "@allurereport/plugin-api";
 import { isFlaky } from "../utils/flaky.js";
 import { getGitBranch, getGitRepoName } from "../utils/git.js";
@@ -26,8 +26,66 @@ const index = (indexMap, key, ...items) => {
         current.push(...items);
     }
 };
+const wasStartedEarlier = (first, second) => first.start === undefined || second.start === undefined || first.start < second.start;
+const hidePreviousAttempt = (state, testResult) => {
+    const { environment, historyId } = testResult;
+    if (environment) {
+        if (!state.has(environment)) {
+            state.set(environment, new Map());
+        }
+        if (historyId) {
+            const historyIdToLastAttemptResult = state.get(environment);
+            const currentLastAttemptResult = historyIdToLastAttemptResult.get(historyId);
+            if (currentLastAttemptResult) {
+                if (wasStartedEarlier(currentLastAttemptResult, testResult)) {
+                    historyIdToLastAttemptResult.set(historyId, testResult);
+                    currentLastAttemptResult.hidden = true;
+                }
+                else {
+                    testResult.hidden = true;
+                }
+            }
+            else {
+                historyIdToLastAttemptResult.set(historyId, testResult);
+            }
+        }
+    }
+};
+export const mapToObject = (map) => {
+    const result = {};
+    map.forEach((value, key) => {
+        result[key] = value;
+    });
+    return result;
+};
+export const mergeMapWithRecord = (map, record) => {
+    Object.entries(record).forEach(([key, value]) => {
+        const existingValue = map.get(key);
+        if (existingValue !== undefined) {
+            if (Array.isArray(existingValue) && Array.isArray(value)) {
+                map.set(key, [...existingValue, ...value]);
+            }
+            else if (typeof existingValue === "object" &&
+                existingValue !== null &&
+                typeof value === "object" &&
+                value !== null &&
+                !Array.isArray(existingValue) &&
+                !Array.isArray(value)) {
+                map.set(key, { ...existingValue, ...value });
+            }
+            else {
+                map.set(key, value);
+            }
+        }
+        else {
+            map.set(key, value);
+        }
+    });
+    return map;
+};
 export class DefaultAllureStore {
     constructor(params) {
+        _DefaultAllureStore_instances.add(this);
         _DefaultAllureStore_testResults.set(this, void 0);
         _DefaultAllureStore_attachments.set(this, void 0);
         _DefaultAllureStore_attachmentContents.set(this, void 0);
@@ -37,11 +95,13 @@ export class DefaultAllureStore {
         _DefaultAllureStore_known.set(this, void 0);
         _DefaultAllureStore_fixtures.set(this, void 0);
         _DefaultAllureStore_defaultLabels.set(this, {});
+        _DefaultAllureStore_environment.set(this, void 0);
         _DefaultAllureStore_environmentsConfig.set(this, {});
         _DefaultAllureStore_reportVariables.set(this, {});
         _DefaultAllureStore_realtimeDispatcher.set(this, void 0);
         _DefaultAllureStore_realtimeSubscriber.set(this, void 0);
         this.indexTestResultByTestCase = new Map();
+        this.indexLatestEnvTestResultByHistoryId = new Map();
         this.indexTestResultByHistoryId = new Map();
         this.indexAttachmentByTestResult = new Map();
         this.indexAttachmentByFixture = new Map();
@@ -53,7 +113,11 @@ export class DefaultAllureStore {
         _DefaultAllureStore_qualityGateResultsByRules.set(this, {});
         _DefaultAllureStore_historyPoints.set(this, []);
         _DefaultAllureStore_repoData.set(this, void 0);
-        const { history, known = [], realtimeDispatcher, realtimeSubscriber, defaultLabels = {}, environmentsConfig = {}, reportVariables = {}, } = params ?? {};
+        _DefaultAllureStore_environments.set(this, []);
+        const { history, known = [], realtimeDispatcher, realtimeSubscriber, defaultLabels = {}, environment, environmentsConfig = {}, reportVariables = {}, } = params ?? {};
+        const environments = Object.keys(environmentsConfig)
+            .concat(environment ?? "")
+            .filter(Boolean);
         __classPrivateFieldSet(this, _DefaultAllureStore_testResults, new Map(), "f");
         __classPrivateFieldSet(this, _DefaultAllureStore_attachments, new Map(), "f");
         __classPrivateFieldSet(this, _DefaultAllureStore_attachmentContents, new Map(), "f");
@@ -67,13 +131,9 @@ export class DefaultAllureStore {
         __classPrivateFieldSet(this, _DefaultAllureStore_realtimeSubscriber, realtimeSubscriber, "f");
         __classPrivateFieldSet(this, _DefaultAllureStore_defaultLabels, defaultLabels, "f");
         __classPrivateFieldSet(this, _DefaultAllureStore_environmentsConfig, environmentsConfig, "f");
+        __classPrivateFieldSet(this, _DefaultAllureStore_environment, environment, "f");
         __classPrivateFieldSet(this, _DefaultAllureStore_reportVariables, reportVariables, "f");
-        this.indexLatestEnvTestResultByHistoryId = new Map();
-        Object.keys(__classPrivateFieldGet(this, _DefaultAllureStore_environmentsConfig, "f"))
-            .concat("default")
-            .forEach((key) => {
-            this.indexLatestEnvTestResultByHistoryId.set(key, new Map());
-        });
+        __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_addEnvironments).call(this, environments);
         __classPrivateFieldGet(this, _DefaultAllureStore_realtimeSubscriber, "f")?.onQualityGateResults(async (results) => {
             results.forEach((result) => {
                 __classPrivateFieldGet(this, _DefaultAllureStore_qualityGateResultsByRules, "f")[result.rule] = result;
@@ -164,28 +224,12 @@ export class DefaultAllureStore {
                 }
             });
         }
-        testResult.environment = matchEnvironment(__classPrivateFieldGet(this, _DefaultAllureStore_environmentsConfig, "f"), testResult);
+        testResult.environment = __classPrivateFieldGet(this, _DefaultAllureStore_environment, "f") || matchEnvironment(__classPrivateFieldGet(this, _DefaultAllureStore_environmentsConfig, "f"), testResult);
         const trHistory = await this.historyByTr(testResult);
         testResult.transition = getStatusTransition(testResult, trHistory);
         testResult.flaky = isFlaky(testResult, trHistory);
         __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f").set(testResult.id, testResult);
-        if (testResult.historyId) {
-            const maybeOther = this.indexLatestEnvTestResultByHistoryId
-                .get(testResult.environment)
-                .get(testResult.historyId);
-            if (maybeOther) {
-                if (maybeOther.start === undefined || testResult.start === undefined || maybeOther.start < testResult.start) {
-                    this.indexLatestEnvTestResultByHistoryId.get(testResult.environment).set(testResult.historyId, testResult);
-                    maybeOther.hidden = true;
-                }
-                else {
-                    testResult.hidden = true;
-                }
-            }
-            else {
-                this.indexLatestEnvTestResultByHistoryId.get(testResult.environment).set(testResult.historyId, testResult);
-            }
-        }
+        hidePreviousAttempt(this.indexLatestEnvTestResultByHistoryId, testResult);
         index(this.indexTestResultByTestCase, testResult.testCase?.id, testResult);
         index(this.indexTestResultByHistoryId, testResult.historyId, testResult);
         index(this.indexAttachmentByTestResult, testResult.id, ...attachmentLinks);
@@ -305,22 +349,7 @@ export class DefaultAllureStore {
         return tr ? this.retriesByTr(tr) : [];
     }
     async historyByTr(tr) {
-        if (!tr?.historyId) {
-            return [];
-        }
-        return [...__classPrivateFieldGet(this, _DefaultAllureStore_historyPoints, "f")]
-            .filter((dp) => !!dp.testResults[tr.historyId])
-            .map((dp) => {
-            if (!dp.url) {
-                return dp.testResults[tr.historyId];
-            }
-            const url = new URL(dp.url);
-            url.hash = tr.id;
-            return {
-                ...dp.testResults[tr.historyId],
-                url: url.toString(),
-            };
-        });
+        return htrsByTr(__classPrivateFieldGet(this, _DefaultAllureStore_historyPoints, "f"), tr);
     }
     async historyByTrId(trId) {
         const tr = await this.testResultById(trId);
@@ -373,7 +402,7 @@ export class DefaultAllureStore {
         return getTestResultsStats(allWithStats, filter);
     }
     async allEnvironments() {
-        return Array.from(new Set(["default", ...Object.keys(__classPrivateFieldGet(this, _DefaultAllureStore_environmentsConfig, "f"))]));
+        return __classPrivateFieldGet(this, _DefaultAllureStore_environments, "f");
     }
     async testResultsByEnvironment(env, options = { includeHidden: false }) {
         const allTrs = await this.allTestResults(options);
@@ -407,7 +436,7 @@ export class DefaultAllureStore {
                 testResultsByEnv: {},
             };
             trs.forEach((tr) => {
-                const env = matchEnvironment(__classPrivateFieldGet(this, _DefaultAllureStore_environmentsConfig, "f"), tr);
+                const env = tr.environment || __classPrivateFieldGet(this, _DefaultAllureStore_environment, "f") || matchEnvironment(__classPrivateFieldGet(this, _DefaultAllureStore_environmentsConfig, "f"), tr);
                 envGroup.testResultsByEnv[env] = tr.id;
             });
             acc.push(envGroup);
@@ -423,5 +452,145 @@ export class DefaultAllureStore {
             ...(__classPrivateFieldGet(this, _DefaultAllureStore_environmentsConfig, "f")?.[env]?.variables ?? {}),
         };
     }
+    dumpState() {
+        const storeDump = {
+            testResults: mapToObject(__classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f")),
+            attachments: mapToObject(__classPrivateFieldGet(this, _DefaultAllureStore_attachments, "f")),
+            testCases: mapToObject(__classPrivateFieldGet(this, _DefaultAllureStore_testCases, "f")),
+            fixtures: mapToObject(__classPrivateFieldGet(this, _DefaultAllureStore_fixtures, "f")),
+            environments: __classPrivateFieldGet(this, _DefaultAllureStore_environments, "f"),
+            reportVariables: __classPrivateFieldGet(this, _DefaultAllureStore_reportVariables, "f"),
+            globalAttachments: __classPrivateFieldGet(this, _DefaultAllureStore_globalAttachments, "f"),
+            globalErrors: __classPrivateFieldGet(this, _DefaultAllureStore_globalErrors, "f"),
+            indexLatestEnvTestResultByHistoryId: {},
+            indexAttachmentByTestResult: {},
+            indexTestResultByHistoryId: {},
+            indexTestResultByTestCase: {},
+            indexAttachmentByFixture: {},
+            indexFixturesByTestResult: {},
+            indexKnownByHistoryId: {},
+        };
+        this.indexLatestEnvTestResultByHistoryId.forEach((envMap) => {
+            envMap.forEach((tr, historyId) => {
+                storeDump.indexLatestEnvTestResultByHistoryId[historyId] = tr.id;
+            });
+        });
+        this.indexAttachmentByFixture.forEach((link, fxId) => {
+            storeDump.indexAttachmentByFixture[fxId] = link.map((l) => l.id);
+        });
+        this.indexAttachmentByTestResult.forEach((links, trId) => {
+            storeDump.indexAttachmentByTestResult[trId] = links.map((l) => l.id);
+        });
+        this.indexTestResultByHistoryId.forEach((trs, historyId) => {
+            storeDump.indexTestResultByHistoryId[historyId] = trs.map((tr) => tr.id);
+        });
+        this.indexTestResultByTestCase.forEach((trs, tcId) => {
+            storeDump.indexTestResultByTestCase[tcId] = trs.map((tr) => tr.id);
+        });
+        this.indexFixturesByTestResult.forEach((fixtures, trId) => {
+            storeDump.indexFixturesByTestResult[trId] = fixtures.map((f) => f.id);
+        });
+        this.indexKnownByHistoryId.forEach((known, historyId) => {
+            storeDump.indexKnownByHistoryId[historyId] = known;
+        });
+        return storeDump;
+    }
+    async restoreState(stateDump, attachmentsContents = {}) {
+        const { testResults, attachments, testCases, fixtures, reportVariables, environments, globalAttachments = [], globalErrors = [], indexAttachmentByTestResult = {}, indexTestResultByHistoryId = {}, indexTestResultByTestCase = {}, indexLatestEnvTestResultByHistoryId = {}, indexAttachmentByFixture = {}, indexFixturesByTestResult = {}, indexKnownByHistoryId = {}, } = stateDump;
+        mergeMapWithRecord(__classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f"), testResults);
+        mergeMapWithRecord(__classPrivateFieldGet(this, _DefaultAllureStore_attachments, "f"), attachments);
+        mergeMapWithRecord(__classPrivateFieldGet(this, _DefaultAllureStore_testCases, "f"), testCases);
+        mergeMapWithRecord(__classPrivateFieldGet(this, _DefaultAllureStore_fixtures, "f"), fixtures);
+        mergeMapWithRecord(__classPrivateFieldGet(this, _DefaultAllureStore_attachmentContents, "f"), attachmentsContents);
+        __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_addEnvironments).call(this, environments);
+        __classPrivateFieldGet(this, _DefaultAllureStore_globalAttachments, "f").push(...globalAttachments);
+        __classPrivateFieldGet(this, _DefaultAllureStore_globalErrors, "f").push(...globalErrors);
+        Object.assign(__classPrivateFieldGet(this, _DefaultAllureStore_reportVariables, "f"), reportVariables);
+        Object.entries(indexAttachmentByTestResult).forEach(([trId, links]) => {
+            const attachmentsLinks = links.map((id) => __classPrivateFieldGet(this, _DefaultAllureStore_attachments, "f").get(id)).filter(Boolean);
+            if (attachmentsLinks.length === 0) {
+                return;
+            }
+            const existingLinks = this.indexAttachmentByTestResult.get(trId);
+            if (!existingLinks) {
+                this.indexAttachmentByTestResult.set(trId, attachmentsLinks);
+                return;
+            }
+            existingLinks.push(...attachmentsLinks);
+        });
+        Object.entries(indexTestResultByHistoryId).forEach(([historyId, trIds]) => {
+            const trs = trIds.map((id) => __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f").get(id)).filter(Boolean);
+            if (trs.length === 0) {
+                return;
+            }
+            const existingTrs = this.indexTestResultByHistoryId.get(historyId);
+            if (!existingTrs) {
+                this.indexTestResultByHistoryId.set(historyId, trs);
+                return;
+            }
+            existingTrs.push(...trs);
+        });
+        Object.entries(indexTestResultByTestCase).forEach(([tcId, trIds]) => {
+            const trs = trIds.map((id) => __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f").get(id)).filter(Boolean);
+            if (trs.length === 0) {
+                return;
+            }
+            const existingTrs = this.indexTestResultByTestCase.get(tcId);
+            if (!existingTrs) {
+                this.indexTestResultByTestCase.set(tcId, trs);
+                return;
+            }
+            existingTrs.push(...trs);
+        });
+        Object.entries(indexAttachmentByFixture).forEach(([fxId, attachmentIds]) => {
+            const attachmentsLinks = attachmentIds.map((id) => __classPrivateFieldGet(this, _DefaultAllureStore_attachments, "f").get(id)).filter(Boolean);
+            if (attachmentsLinks.length === 0) {
+                return;
+            }
+            const existingLinks = this.indexAttachmentByFixture.get(fxId);
+            if (!existingLinks) {
+                this.indexAttachmentByFixture.set(fxId, attachmentsLinks);
+                return;
+            }
+            existingLinks.push(...attachmentsLinks);
+        });
+        Object.entries(indexFixturesByTestResult).forEach(([trId, fixtureIds]) => {
+            const fxs = fixtureIds.map((id) => __classPrivateFieldGet(this, _DefaultAllureStore_fixtures, "f").get(id)).filter(Boolean);
+            if (fxs.length === 0) {
+                return;
+            }
+            const existingFixtures = this.indexFixturesByTestResult.get(trId);
+            if (!existingFixtures) {
+                this.indexFixturesByTestResult.set(trId, fxs);
+                return;
+            }
+            existingFixtures.push(...fxs);
+        });
+        Object.entries(indexKnownByHistoryId).forEach(([historyId, knownFailures]) => {
+            const existingKnown = this.indexKnownByHistoryId.get(historyId);
+            if (!existingKnown) {
+                this.indexKnownByHistoryId.set(historyId, knownFailures);
+                return;
+            }
+            existingKnown.push(...knownFailures);
+        });
+        Object.values(indexLatestEnvTestResultByHistoryId).forEach((trId) => {
+            const tr = __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f").get(trId);
+            if (!tr) {
+                return;
+            }
+            hidePreviousAttempt(this.indexLatestEnvTestResultByHistoryId, tr);
+        });
+    }
 }
-_DefaultAllureStore_testResults = new WeakMap(), _DefaultAllureStore_attachments = new WeakMap(), _DefaultAllureStore_attachmentContents = new WeakMap(), _DefaultAllureStore_testCases = new WeakMap(), _DefaultAllureStore_metadata = new WeakMap(), _DefaultAllureStore_history = new WeakMap(), _DefaultAllureStore_known = new WeakMap(), _DefaultAllureStore_fixtures = new WeakMap(), _DefaultAllureStore_defaultLabels = new WeakMap(), _DefaultAllureStore_environmentsConfig = new WeakMap(), _DefaultAllureStore_reportVariables = new WeakMap(), _DefaultAllureStore_realtimeDispatcher = new WeakMap(), _DefaultAllureStore_realtimeSubscriber = new WeakMap(), _DefaultAllureStore_globalAttachments = new WeakMap(), _DefaultAllureStore_globalErrors = new WeakMap(), _DefaultAllureStore_globalExitCode = new WeakMap(), _DefaultAllureStore_qualityGateResultsByRules = new WeakMap(), _DefaultAllureStore_historyPoints = new WeakMap(), _DefaultAllureStore_repoData = new WeakMap();
+_DefaultAllureStore_testResults = new WeakMap(), _DefaultAllureStore_attachments = new WeakMap(), _DefaultAllureStore_attachmentContents = new WeakMap(), _DefaultAllureStore_testCases = new WeakMap(), _DefaultAllureStore_metadata = new WeakMap(), _DefaultAllureStore_history = new WeakMap(), _DefaultAllureStore_known = new WeakMap(), _DefaultAllureStore_fixtures = new WeakMap(), _DefaultAllureStore_defaultLabels = new WeakMap(), _DefaultAllureStore_environment = new WeakMap(), _DefaultAllureStore_environmentsConfig = new WeakMap(), _DefaultAllureStore_reportVariables = new WeakMap(), _DefaultAllureStore_realtimeDispatcher = new WeakMap(), _DefaultAllureStore_realtimeSubscriber = new WeakMap(), _DefaultAllureStore_globalAttachments = new WeakMap(), _DefaultAllureStore_globalErrors = new WeakMap(), _DefaultAllureStore_globalExitCode = new WeakMap(), _DefaultAllureStore_qualityGateResultsByRules = new WeakMap(), _DefaultAllureStore_historyPoints = new WeakMap(), _DefaultAllureStore_repoData = new WeakMap(), _DefaultAllureStore_environments = new WeakMap(), _DefaultAllureStore_instances = new WeakSet(), _DefaultAllureStore_addEnvironments = function _DefaultAllureStore_addEnvironments(envs) {
+    if (__classPrivateFieldGet(this, _DefaultAllureStore_environments, "f").length === 0) {
+        __classPrivateFieldGet(this, _DefaultAllureStore_environments, "f").push(DEFAULT_ENVIRONMENT);
+    }
+    __classPrivateFieldSet(this, _DefaultAllureStore_environments, Array.from(new Set([...__classPrivateFieldGet(this, _DefaultAllureStore_environments, "f"), ...envs])), "f");
+    envs.forEach((key) => {
+        if (!this.indexLatestEnvTestResultByHistoryId.has(key)) {
+            this.indexLatestEnvTestResultByHistoryId.set(key, new Map());
+        }
+    });
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/core",
-  "version": "3.0.0-beta.18",
+  "version": "3.0.0-beta.19",
   "description": "Collection of generic Allure utilities used across the entire project",
   "keywords": [
     "allure"
@@ -25,25 +25,27 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@allurereport/ci": "3.0.0-beta.18",
-    "@allurereport/core-api": "3.0.0-beta.18",
-    "@allurereport/plugin-allure2": "3.0.0-beta.18",
-    "@allurereport/plugin-api": "3.0.0-beta.18",
-    "@allurereport/plugin-awesome": "3.0.0-beta.18",
-    "@allurereport/plugin-classic": "3.0.0-beta.18",
-    "@allurereport/plugin-csv": "3.0.0-beta.18",
-    "@allurereport/plugin-dashboard": "3.0.0-beta.18",
-    "@allurereport/plugin-log": "3.0.0-beta.18",
-    "@allurereport/plugin-progress": "3.0.0-beta.18",
-    "@allurereport/plugin-slack": "3.0.0-beta.18",
-    "@allurereport/plugin-testplan": "3.0.0-beta.18",
-    "@allurereport/reader": "3.0.0-beta.18",
-    "@allurereport/reader-api": "3.0.0-beta.18",
-    "@allurereport/service": "3.0.0-beta.18",
-    "@allurereport/summary": "3.0.0-beta.18",
+    "@allurereport/ci": "3.0.0-beta.19",
+    "@allurereport/core-api": "3.0.0-beta.19",
+    "@allurereport/plugin-allure2": "3.0.0-beta.19",
+    "@allurereport/plugin-api": "3.0.0-beta.19",
+    "@allurereport/plugin-awesome": "3.0.0-beta.19",
+    "@allurereport/plugin-classic": "3.0.0-beta.19",
+    "@allurereport/plugin-csv": "3.0.0-beta.19",
+    "@allurereport/plugin-dashboard": "3.0.0-beta.19",
+    "@allurereport/plugin-log": "3.0.0-beta.19",
+    "@allurereport/plugin-progress": "3.0.0-beta.19",
+    "@allurereport/plugin-slack": "3.0.0-beta.19",
+    "@allurereport/plugin-testplan": "3.0.0-beta.19",
+    "@allurereport/reader": "3.0.0-beta.19",
+    "@allurereport/reader-api": "3.0.0-beta.19",
+    "@allurereport/service": "3.0.0-beta.19",
+    "@allurereport/summary": "3.0.0-beta.19",
     "handlebars": "^4.7.8",
     "markdown-it": "^14.1.0",
-    "yoctocolors": "^2.1.1"
+    "node-stream-zip": "^1.15.0",
+    "yoctocolors": "^2.1.1",
+    "zip-stream": "^7.0.2"
   },
   "devDependencies": {
     "@stylistic/eslint-plugin": "^2.6.1",
@@ -51,6 +53,7 @@
     "@types/handlebars": "^4.1.0",
     "@types/markdown-it": "^14.1.2",
     "@types/node": "^20.17.9",
+    "@types/zip-stream": "^7.0.0",
     "@typescript-eslint/eslint-plugin": "^8.0.0",
     "@typescript-eslint/parser": "^8.0.0",
     "@vitest/runner": "^2.1.9",