@allurereport/core 3.7.0 → 3.8.1

package/dist/config.js

@@ -189,23 +189,27 @@ export const resolveConfig = async (config, override = {}) => {
     const output = resolve(override.output ?? config.output ?? "./allure-report");
     const known = await readKnownIssues(knownIssuesPath);
     const variables = config.variables ?? {};
-    const configuredPlugins = override.plugins ?? config.plugins;
-    const basePlugins = Object.keys(configuredPlugins ?? {}).length === 0
-        ? {
-            awesome: {
-                options: {},
-            },
-        }
-        : configuredPlugins;
-    const plugins = hasConfiguredAgent(basePlugins)
-        ? basePlugins
-        : {
-            ...basePlugins,
-            agent: {
-                options: {},
-            },
-        };
-    const pluginInstances = await resolvePlugins(plugins);
+    let pluginInstances = [];
+    const hasPluginsOverride = override.plugins !== undefined;
+    if (!hasPluginsOverride || Object.keys(override.plugins ?? {}).length > 0) {
+        const configuredPlugins = hasPluginsOverride ? override.plugins : config.plugins;
+        const basePlugins = !hasPluginsOverride && Object.keys(configuredPlugins ?? {}).length === 0
+            ? {
+                awesome: {
+                    options: {},
+                },
+            }
+            : configuredPlugins;
+        const plugins = hasConfiguredAgent(basePlugins)
+            ? basePlugins
+            : {
+                ...basePlugins,
+                agent: {
+                    options: {},
+                },
+            };
+        pluginInstances = await resolvePlugins(plugins);
+    }
     return {
         name,
         output,

package/dist/report.js

@@ -9,11 +9,10 @@ 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_reportVariables, _AllureReport_ci, _AllureReport_store, _AllureReport_readers, _AllureReport_plugins, _AllureReport_reportFiles, _AllureReport_eventEmitter, _AllureReport_realtimeSubscriber, _AllureReport_realtimeDispatcher, _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_publish_get, _AllureReport_update, _AllureReport_eachPlugin, _AllureReport_getPluginState;
+var _AllureReport_instances, _AllureReport_reportName, _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_publish_get, _AllureReport_runRealtimeUpdate, _AllureReport_eachPlugin, _AllureReport_getPluginState;
 import console from "node:console";
 import { randomUUID } from "node:crypto";
-import { EventEmitter } from "node:events";
-import { createReadStream, createWriteStream, existsSync, readFileSync } from "node:fs";
+import { 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, sep } from "node:path";
@@ -35,7 +34,8 @@ import { DefaultPluginState, PluginFiles } from "./plugin.js";
 import { QualityGate } from "./qualityGate/index.js";
 import { DefaultAllureStore } from "./store/store.js";
 import { environmentIdentityById, environmentIdentityByName } from "./utils/environment.js";
-import { RealtimeEventsDispatcher, RealtimeSubscriber } from "./utils/event.js";
+import { RealtimeChannel } from "./utils/realtimeChannel.js";
+import { RealtimeUpdateScheduler } from "./utils/realtimeUpdateScheduler.js";
 import { resolveDumpAttachmentPath, UnsafeDumpPathError } from "./utils/safeDumpPath.js";
 const { version } = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
 const initRequired = "report is not initialised. Call the start() method first.";
@@ -44,19 +44,18 @@ 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);
         _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);
         _AllureReport_plugins.set(this, void 0);
         _AllureReport_reportFiles.set(this, void 0);
-        _AllureReport_eventEmitter.set(this, void 0);
-        _AllureReport_realtimeSubscriber.set(this, void 0);
-        _AllureReport_realtimeDispatcher.set(this, void 0);
+        _AllureReport_realtimeChannel.set(this, void 0);
+        _AllureReport_realtimeUpdateScheduler.set(this, void 0);
         _AllureReport_realTime.set(this, void 0);
         _AllureReport_hideLabels.set(this, void 0);
         _AllureReport_output.set(this, void 0);
@@ -150,7 +149,7 @@ export class AllureReport {
                         continue;
                     }
                     const originalFileName = basename(absoluteFilePath);
-                    __classPrivateFieldGet(this, _AllureReport_realtimeDispatcher, "f").sendGlobalAttachment(new PathResultFile(absoluteFilePath, originalFileName), originalFileName);
+                    __classPrivateFieldGet(this, _AllureReport_realtimeChannel, "f").dispatcher.sendGlobalAttachment(new PathResultFile(absoluteFilePath, originalFileName), originalFileName);
                 }
             }
             if (__classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f") && __classPrivateFieldGet(this, _AllureReport_instances, "a", _AllureReport_publish_get)) {
@@ -162,16 +161,16 @@ export class AllureReport {
                 this.reportUrl = url.href;
             }
             await __classPrivateFieldGet(this, _AllureReport_eachPlugin, "f").call(this, true, async (plugin, context) => {
-                await plugin.start?.(context, __classPrivateFieldGet(this, _AllureReport_store, "f"), __classPrivateFieldGet(this, _AllureReport_realtimeSubscriber, "f"));
+                await plugin.start?.(context, __classPrivateFieldGet(this, _AllureReport_store, "f"), __classPrivateFieldGet(this, _AllureReport_realtimeChannel, "f").subscriber);
             });
             if (__classPrivateFieldGet(this, _AllureReport_realTime, "f")) {
-                await __classPrivateFieldGet(this, _AllureReport_update, "f").call(this);
-                __classPrivateFieldGet(this, _AllureReport_realtimeSubscriber, "f").onAll(async () => {
-                    await __classPrivateFieldGet(this, _AllureReport_update, "f").call(this);
+                await __classPrivateFieldGet(this, _AllureReport_runRealtimeUpdate, "f").call(this);
+                __classPrivateFieldGet(this, _AllureReport_realtimeChannel, "f").onResultLikeChanged(() => {
+                    __classPrivateFieldGet(this, _AllureReport_realtimeUpdateScheduler, "f").request();
                 });
             }
         };
-        _AllureReport_update.set(this, async () => {
+        _AllureReport_runRealtimeUpdate.set(this, async () => {
             if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") !== "running") {
                 return;
             }
@@ -180,176 +179,275 @@ export class AllureReport {
             });
         });
         this.dumpState = async () => {
-            const { testResults, testCases, fixtures, attachments: attachmentsLinks, environments, globalAttachmentIds = [], globalErrors = [], indexAttachmentByTestResult = {}, indexTestResultByHistoryId = {}, indexTestResultByTestCase = {}, indexLatestEnvTestResultByHistoryId = {}, indexAttachmentByFixture = {}, indexFixturesByTestResult = {}, indexKnownByHistoryId = {}, qualityGateResults = [], } = __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_dump, "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));
+            const dumpPath = `${__classPrivateFieldGet(this, _AllureReport_dump, "f")}.zip`;
+            const dumpTempPath = `${dumpPath}.${randomUUID()}.tmp`;
+            const dumpArchiveWriteStream = createWriteStream(dumpTempPath);
+            let dumpArchiveError;
+            let dumpArchiveFinished = false;
+            let resolveDumpArchivePromise;
+            const finishDumpArchive = (err) => {
+                dumpArchiveError ?? (dumpArchiveError = err);
+                if (!dumpArchiveFinished) {
+                    dumpArchiveFinished = true;
+                    resolveDumpArchivePromise?.();
+                }
+            };
+            const dumpArchivePromise = new Promise((res) => {
+                resolveDumpArchivePromise = res;
+                dumpArchive.on("error", (err) => {
+                    dumpArchiveWriteStream.destroy();
+                    finishDumpArchive(err);
+                });
+                dumpArchiveWriteStream.on("finish", () => finishDumpArchive());
+                dumpArchiveWriteStream.on("error", (err) => finishDumpArchive(err));
             });
+            const errMessage = (err) => (err instanceof Error ? err.message : String(err));
+            const addDumpEntry = async (data, entryName) => {
+                try {
+                    await addEntry(data, { name: entryName });
+                    return undefined;
+                }
+                catch (err) {
+                    return err;
+                }
+            };
+            const addRequiredDumpEntry = async (data, entryName) => {
+                const err = await addDumpEntry(data, entryName);
+                if (err) {
+                    throw new Error(`Failed to write dump entry "${entryName}": ${errMessage(err)}`);
+                }
+            };
+            const addJsonDumpEntry = async (entryName, value) => {
+                await addRequiredDumpEntry(Buffer.from(JSON.stringify(value)), entryName);
+            };
+            const dumpJsonEntries = ({ testResults, testCases, fixtures, attachments, environments, reportVariables, checkResults = [], globalAttachmentIds = [], globalErrors = [], indexAttachmentByTestResult = {}, indexTestResultByHistoryId = {}, indexTestResultByTestCase = {}, indexLatestEnvTestResultByHistoryId = {}, indexAttachmentByFixture = {}, indexFixturesByTestResult = {}, indexKnownByHistoryId = {}, qualityGateResults = [], }) => [
+                [AllureStoreDumpFiles.TestResults, testResults],
+                [AllureStoreDumpFiles.TestCases, testCases],
+                [AllureStoreDumpFiles.Fixtures, fixtures],
+                [AllureStoreDumpFiles.Attachments, attachments],
+                [AllureStoreDumpFiles.CheckResults, checkResults],
+                [AllureStoreDumpFiles.Environments, environments],
+                [AllureStoreDumpFiles.ReportVariables, reportVariables],
+                [AllureStoreDumpFiles.GlobalAttachments, globalAttachmentIds],
+                [AllureStoreDumpFiles.GlobalErrors, globalErrors],
+                [AllureStoreDumpFiles.IndexAttachmentsByTestResults, indexAttachmentByTestResult],
+                [AllureStoreDumpFiles.IndexTestResultsByHistoryId, indexTestResultByHistoryId],
+                [AllureStoreDumpFiles.IndexTestResultsByTestCase, indexTestResultByTestCase],
+                [AllureStoreDumpFiles.IndexLatestEnvTestResultsByHistoryId, indexLatestEnvTestResultByHistoryId],
+                [AllureStoreDumpFiles.IndexAttachmentsByFixture, indexAttachmentByFixture],
+                [AllureStoreDumpFiles.IndexFixturesByTestResult, indexFixturesByTestResult],
+                [AllureStoreDumpFiles.IndexKnownByHistoryId, indexKnownByHistoryId],
+                [AllureStoreDumpFiles.QualityGateResults, qualityGateResults],
+            ];
+            let dumpError;
             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(globalAttachmentIds)), {
-                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,
-            });
-            await addEntry(Buffer.from(JSON.stringify(qualityGateResults)), {
-                name: AllureStoreDumpFiles.QualityGateResults,
-            });
-            for (const attachment of allAttachments) {
-                const content = await __classPrivateFieldGet(this, _AllureReport_store, "f").attachmentContentById(attachment.id);
-                if (!content) {
-                    continue;
+            try {
+                const allAttachments = await __classPrivateFieldGet(this, _AllureReport_store, "f").allAttachments();
+                for (const attachment of allAttachments) {
+                    const skipAttachment = (message) => {
+                        const originalFileName = attachment.originalFileName ? ` (${attachment.originalFileName})` : "";
+                        __classPrivateFieldGet(this, _AllureReport_store, "f").markAttachmentMissed(attachment.id);
+                        console.warn(`Skipping attachment while writing dump: ${attachment.id}${originalFileName}. ${message}`);
+                    };
+                    try {
+                        const content = await __classPrivateFieldGet(this, _AllureReport_store, "f").attachmentContentById(attachment.id);
+                        if (!content) {
+                            skipAttachment("attachment content is missing");
+                            continue;
+                        }
+                        const data = await content.asBuffer();
+                        if (data === undefined) {
+                            skipAttachment("attachment content is missing");
+                            continue;
+                        }
+                        const err = await addDumpEntry(data, attachment.id);
+                        if (err) {
+                            skipAttachment(`failed to add attachment entry: ${errMessage(err)}`);
+                        }
+                    }
+                    catch (err) {
+                        skipAttachment(errMessage(err));
+                    }
                 }
-                if (content instanceof PathResultFile) {
-                    await addEntry(createReadStream(content.path), {
-                        name: attachment.id,
-                    });
+                for (const [entryName, value] of dumpJsonEntries(__classPrivateFieldGet(this, _AllureReport_store, "f").dumpState())) {
+                    await addJsonDumpEntry(entryName, value);
                 }
-                else {
-                    await addEntry(await content.asBuffer(), {
-                        name: attachment.id,
-                    });
+            }
+            catch (err) {
+                dumpError = err;
+            }
+            finally {
+                try {
+                    dumpArchive.finalize();
+                }
+                catch (err) {
+                    dumpError ?? (dumpError = err);
+                    dumpArchiveWriteStream.destroy();
+                    finishDumpArchive(err);
                 }
+                await dumpArchivePromise;
             }
-            dumpArchive.finalize();
-            return promise;
+            dumpError ?? (dumpError = dumpArchiveError);
+            if (dumpError) {
+                await rm(dumpTempPath, { force: true });
+                throw dumpError;
+            }
+            await rename(dumpTempPath, dumpPath);
         };
         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,
-                });
-                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 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 attachmentsEntries = Object.entries(await dumpArchive.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:
-                        case AllureStoreDumpFiles.QualityGateResults:
-                            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")),
-                    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 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;
+                            }
+                        }
+                        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;
+                                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);
+                            }
+                        }
+                        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.");
+                    catch (err) {
+                        restoreError = err;
                         throw err;
                     }
-                    console.error(`Can't restore state from "${dump}", continuing without it`);
-                    console.error(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));
                 }
-                await __classPrivateFieldGet(this, _AllureReport_store, "f").restoreState(dumpState, resultsAttachments);
-                console.info(`Successfully restored state from "${dump}"`);
             }
         };
         this.done = async () => {
@@ -363,7 +461,13 @@ export class AllureReport {
             const testResults = await __classPrivateFieldGet(this, _AllureReport_store, "f").allTestResults();
             const testCases = await __classPrivateFieldGet(this, _AllureReport_store, "f").allTestCases();
             const historyDataPoint = createHistory(this.reportUuid, __classPrivateFieldGet(this, _AllureReport_reportName, "f"), testCases, testResults, this.reportUrl);
-            __classPrivateFieldGet(this, _AllureReport_realtimeSubscriber, "f").offAll();
+            __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();
@@ -586,7 +690,7 @@ export class AllureReport {
             if (allureServiceConfig?.legacy) {
                 __classPrivateFieldSet(this, _AllureReport_allureServiceClient, new AllureLegacyServiceClient(allureServiceConfig), "f");
             }
-            else if (allureServiceConfig?.url) {
+            else {
                 __classPrivateFieldSet(this, _AllureReport_allureServiceClient, new AllureServiceClient(allureServiceConfig), "f");
             }
         }
@@ -594,10 +698,8 @@ export class AllureReport {
         __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_realtimeChannel, new RealtimeChannel(), "f");
+        __classPrivateFieldSet(this, _AllureReport_realtimeUpdateScheduler, new RealtimeUpdateScheduler(__classPrivateFieldGet(this, _AllureReport_runRealtimeUpdate, "f")), "f");
         __classPrivateFieldSet(this, _AllureReport_realTime, realTime, "f");
         __classPrivateFieldSet(this, _AllureReport_dump, dump, "f");
         __classPrivateFieldSet(this, _AllureReport_hideLabels, hideLabels, "f");
@@ -621,8 +723,8 @@ export class AllureReport {
             }), "f");
         }
         __classPrivateFieldSet(this, _AllureReport_store, new DefaultAllureStore({
-            realtimeSubscriber: __classPrivateFieldGet(this, _AllureReport_realtimeSubscriber, "f"),
-            realtimeDispatcher: __classPrivateFieldGet(this, _AllureReport_realtimeDispatcher, "f"),
+            realtimeSubscriber: __classPrivateFieldGet(this, _AllureReport_realtimeChannel, "f").subscriber,
+            realtimeDispatcher: __classPrivateFieldGet(this, _AllureReport_realtimeChannel, "f").dispatcher,
             reportVariables: variables,
             environmentsConfig: environments,
             history: __classPrivateFieldGet(this, _AllureReport_history, "f"),
@@ -643,13 +745,13 @@ export class AllureReport {
         return __classPrivateFieldGet(this, _AllureReport_store, "f");
     }
     get realtimeSubscriber() {
-        return __classPrivateFieldGet(this, _AllureReport_realtimeSubscriber, "f");
+        return __classPrivateFieldGet(this, _AllureReport_realtimeChannel, "f").subscriber;
     }
     get realtimeDispatcher() {
-        return __classPrivateFieldGet(this, _AllureReport_realtimeDispatcher, "f");
+        return __classPrivateFieldGet(this, _AllureReport_realtimeChannel, "f").dispatcher;
     }
 }
-_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_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_update = new WeakMap(), _AllureReport_eachPlugin = new WeakMap(), _AllureReport_instances = new WeakSet(), _AllureReport_publish_get = function _AllureReport_publish_get() {
+_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_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_runRealtimeUpdate = 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];