@allurereport/core 3.6.2 → 3.8.0

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";
@@ -23,7 +22,7 @@ import { normalizeCategoriesConfig } from "@allurereport/core-api";
 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 { AllureLegacyServiceClient, AllureRemoteHistory, AllureServiceClient, KnownError, UnknownError, } from "@allurereport/service";
 import { generateSummary } from "@allurereport/summary";
 import { glob } from "glob";
 import ZipReadStream from "node-stream-zip";
@@ -35,23 +34,27 @@ 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.";
+const remoteReportParams = (ci) => {
+    const repo = ci?.repoName;
+    const branch = ci?.jobRunBranch;
+    return repo && branch ? { repo, branch } : {};
+};
 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);
@@ -121,7 +124,7 @@ export class AllureReport {
             });
         };
         this.start = async () => {
-            const branch = __classPrivateFieldGet(this, _AllureReport_ci, "f")?.jobRunBranch;
+            const remoteParams = remoteReportParams(__classPrivateFieldGet(this, _AllureReport_ci, "f"));
             await __classPrivateFieldGet(this, _AllureReport_store, "f").readHistory();
             if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") === "running") {
                 throw new Error("the report is already started");
@@ -145,28 +148,28 @@ 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) && branch) {
-                const { url } = await __classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f").createReport({
+            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,
                     reportName: __classPrivateFieldGet(this, _AllureReport_reportName, "f"),
-                    branch,
+                    ...remoteParams,
                 });
-                this.reportUrl = url;
+                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;
             }
@@ -175,85 +178,124 @@ 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;
+            }
+            dumpError ?? (dumpError = dumpArchiveError);
+            if (dumpError) {
+                await rm(dumpTempPath, { force: true });
+                throw dumpError;
             }
-            dumpArchive.finalize();
-            return promise;
+            await rename(dumpTempPath, dumpPath);
         };
         this.restoreState = async (dumps) => {
             for (const dump of dumps) {
@@ -263,93 +305,127 @@ export class AllureReport {
                 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 dumpEntries = await dumpArchive.entries();
+                    const dumpEntriesList = Object.entries(dumpEntries);
+                    const optionalEntryData = async (entryName) => dumpEntries[entryName] ? dumpArchive.entryData(entryName) : undefined;
+                    if (!dumpEntries[AllureStoreDumpFiles.TestResults]) {
+                        const nestedDumpEntries = dumpEntriesList.filter(([entryName, entry]) => !entry.isDirectory &&
+                            !entryName.startsWith("__MACOSX/") &&
+                            !basename(entryName).startsWith("._") &&
+                            entryName.toLowerCase().endsWith(".zip"));
+                        if (nestedDumpEntries.length > 0) {
+                            const nestedDumpsTempDir = await mkdtemp(join(tmpdir(), `${basename(dump, ".zip")}-nested-`));
+                            const nestedDumpPaths = [];
+                            __classPrivateFieldGet(this, _AllureReport_dumpTempDirs, "f").push(nestedDumpsTempDir);
+                            for (const [entryName] of nestedDumpEntries) {
+                                const nestedDumpPath = join(nestedDumpsTempDir, `${nestedDumpPaths.length}-${basename(entryName)}`);
+                                await writeFile(nestedDumpPath, await dumpArchive.entryData(entryName));
+                                nestedDumpPaths.push(nestedDumpPath);
+                            }
+                            await this.restoreState(nestedDumpPaths);
+                            continue;
+                        }
                     }
-                }
-                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;
+                    const testResultsEntry = await dumpArchive.entryData(AllureStoreDumpFiles.TestResults);
+                    const testCasesEntry = await dumpArchive.entryData(AllureStoreDumpFiles.TestCases);
+                    const fixturesEntry = await dumpArchive.entryData(AllureStoreDumpFiles.Fixtures);
+                    const attachmentsEntry = await dumpArchive.entryData(AllureStoreDumpFiles.Attachments);
+                    const checkResultsEntry = await optionalEntryData(AllureStoreDumpFiles.CheckResults);
+                    const environmentsEntry = await dumpArchive.entryData(AllureStoreDumpFiles.Environments);
+                    const reportVariablesEntry = await dumpArchive.entryData(AllureStoreDumpFiles.ReportVariables);
+                    const globalAttachmentsEntry = await dumpArchive.entryData(AllureStoreDumpFiles.GlobalAttachments);
+                    const globalErrorsEntry = await dumpArchive.entryData(AllureStoreDumpFiles.GlobalErrors);
+                    const indexAttachmentsEntry = await dumpArchive.entryData(AllureStoreDumpFiles.IndexAttachmentsByTestResults);
+                    const indexTestResultsByHistoryId = await dumpArchive.entryData(AllureStoreDumpFiles.IndexTestResultsByHistoryId);
+                    const indexTestResultsByTestCaseEntry = await dumpArchive.entryData(AllureStoreDumpFiles.IndexTestResultsByTestCase);
+                    const indexLatestEnvTestResultsByHistoryIdEntry = await dumpArchive.entryData(AllureStoreDumpFiles.IndexLatestEnvTestResultsByHistoryId);
+                    const indexAttachmentsByFixtureEntry = await dumpArchive.entryData(AllureStoreDumpFiles.IndexAttachmentsByFixture);
+                    const indexFixturesByTestResultEntry = await dumpArchive.entryData(AllureStoreDumpFiles.IndexFixturesByTestResult);
+                    const indexKnownByHistoryIdEntry = await dumpArchive.entryData(AllureStoreDumpFiles.IndexKnownByHistoryId);
+                    const qualityGateResultsEntry = await dumpArchive.entryData(AllureStoreDumpFiles.QualityGateResults);
+                    const attachmentsLinks = JSON.parse(attachmentsEntry.toString("utf8"));
+                    const attachmentsEntries = dumpEntriesList.reduce((acc, [entryName, entry]) => {
+                        switch (entryName) {
+                            case AllureStoreDumpFiles.Attachments:
+                            case AllureStoreDumpFiles.CheckResults:
+                            case AllureStoreDumpFiles.TestResults:
+                            case AllureStoreDumpFiles.TestCases:
+                            case AllureStoreDumpFiles.Fixtures:
+                            case AllureStoreDumpFiles.Environments:
+                            case AllureStoreDumpFiles.ReportVariables:
+                            case AllureStoreDumpFiles.GlobalAttachments:
+                            case AllureStoreDumpFiles.GlobalErrors:
+                            case AllureStoreDumpFiles.IndexAttachmentsByTestResults:
+                            case AllureStoreDumpFiles.IndexTestResultsByHistoryId:
+                            case AllureStoreDumpFiles.IndexTestResultsByTestCase:
+                            case AllureStoreDumpFiles.IndexLatestEnvTestResultsByHistoryId:
+                            case AllureStoreDumpFiles.IndexAttachmentsByFixture:
+                            case AllureStoreDumpFiles.IndexFixturesByTestResult:
+                            case AllureStoreDumpFiles.IndexKnownByHistoryId:
+                            case AllureStoreDumpFiles.QualityGateResults:
+                                return acc;
+                            default:
+                                if (entry.isDirectory || !attachmentsLinks[entryName] || attachmentsLinks[entryName].missed) {
+                                    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);
+                        }
                     }
-                    console.error(`Can't restore state from "${dump}", continuing without it`);
-                    console.error(err);
+                    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 state from "${dump}", continuing without it`);
+                        console.error(err);
+                    }
+                    await __classPrivateFieldGet(this, _AllureReport_store, "f").restoreState(dumpState, resultsAttachments);
+                    console.info(`Successfully restored state from "${dump}"`);
+                }
+                finally {
+                    await dumpArchive.close();
                 }
-                await __classPrivateFieldGet(this, _AllureReport_store, "f").restoreState(dumpState, resultsAttachments);
-                console.info(`Successfully restored state from "${dump}"`);
             }
         };
         this.done = async () => {
             const summaries = [];
-            const remoteHrefs = [];
+            const remoteHrefs = new Set();
+            const remoteHrefsByPluginId = {};
             const cancelledPluginsIds = new Set();
             if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") !== "running") {
                 throw new Error(initRequired);
@@ -357,7 +433,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();
@@ -377,24 +459,37 @@ export class AllureReport {
                         })
                         : undefined;
                     const limitFn = pLimit(50);
+                    const uploadAbortController = new AbortController();
                     const fns = pluginFilesEntries.map(([filename, filepath]) => limitFn(async () => {
-                        if (cancelledPluginsIds.has(context.id)) {
+                        if (cancelledPluginsIds.has(context.id) || uploadAbortController.signal.aborted) {
                             return;
                         }
                         if (/^(data|widgets|index\.html$|summary\.json$)/.test(filename)) {
-                            await __classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f").addReportFile({
+                            const uploadedFileUrl = await __classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f").addReportFile({
                                 reportUuid: this.reportUuid,
                                 pluginId: context.id,
                                 filename,
                                 filepath,
+                                signal: uploadAbortController.signal,
                             });
+                            if (cancelledPluginsIds.has(context.id) || uploadAbortController.signal.aborted) {
+                                return;
+                            }
+                            if (filename === "index.html") {
+                                remoteHrefsByPluginId[context.id] = uploadedFileUrl;
+                                remoteHrefs.add(uploadedFileUrl);
+                            }
                         }
                         else {
                             await __classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f").addReportAsset({
                                 filename,
                                 filepath,
+                                signal: uploadAbortController.signal,
                             });
                         }
+                        if (cancelledPluginsIds.has(context.id) || uploadAbortController.signal.aborted) {
+                            return;
+                        }
                         progressBar?.tick?.();
                     }));
                     progressBar?.render?.();
@@ -403,6 +498,13 @@ export class AllureReport {
                     }
                     catch (err) {
                         cancelledPluginsIds.add(context.id);
+                        uploadAbortController.abort();
+                        await Promise.allSettled(fns);
+                        const pluginRemoteHref = remoteHrefsByPluginId[context.id];
+                        if (pluginRemoteHref) {
+                            remoteHrefs.delete(pluginRemoteHref);
+                            delete remoteHrefsByPluginId[context.id];
+                        }
                         await __classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f").deleteReport({
                             reportUuid: this.reportUuid,
                             pluginId: context.id,
@@ -418,9 +520,12 @@ export class AllureReport {
                 summary.pluginId = context.id;
                 summary.pullRequestHref = __classPrivateFieldGet(this, _AllureReport_ci, "f")?.pullRequestUrl;
                 summary.jobHref = __classPrivateFieldGet(this, _AllureReport_ci, "f")?.jobRunUrl;
-                if (context.publish && this.reportUrl && !cancelledPluginsIds.has(context.id)) {
-                    summary.remoteHref = `${this.reportUrl}/${context.id}/`;
-                    remoteHrefs.push(summary.remoteHref);
+                if (context.publish && !cancelledPluginsIds.has(context.id)) {
+                    summary.remoteHref =
+                        remoteHrefsByPluginId[context.id] ?? (this.reportUrl ? `${this.reportUrl}/${context.id}/` : undefined);
+                    if (summary.remoteHref) {
+                        remoteHrefs.add(summary.remoteHref);
+                    }
                 }
                 summaries.push({
                     ...summary,
@@ -490,7 +595,7 @@ export class AllureReport {
                     }
                 }
             }
-            if (remoteHrefs.length > 0) {
+            if (remoteHrefs.size > 0) {
                 console.info("Next reports have been published:");
                 remoteHrefs.forEach((href) => {
                     console.info(`- ${href}`);
@@ -553,17 +658,20 @@ export class AllureReport {
             }
         });
         const { name, readers = [allure1, allure2, cucumberjson, junitXml, attachments], plugins = [], known, reportFiles, realTime, historyPath, historyLimit, defaultLabels = {}, variables = {}, environment, allowedEnvironments, environments, output, hideLabels, qualityGate, dump, categories, allureService: allureServiceConfig, globalAttachments, } = opts;
-        __classPrivateFieldSet(this, _AllureReport_allureServiceClient, allureServiceConfig?.accessToken
-            ? new AllureServiceClient(allureServiceConfig)
-            : undefined, "f");
+        if (allureServiceConfig?.accessToken) {
+            if (allureServiceConfig?.legacy) {
+                __classPrivateFieldSet(this, _AllureReport_allureServiceClient, new AllureLegacyServiceClient(allureServiceConfig), "f");
+            }
+            else {
+                __classPrivateFieldSet(this, _AllureReport_allureServiceClient, new AllureServiceClient(allureServiceConfig), "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_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");
@@ -576,7 +684,7 @@ export class AllureReport {
         if (__classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f")) {
             __classPrivateFieldSet(this, _AllureReport_history, new AllureRemoteHistory({
                 limit: historyLimit,
-                branch: __classPrivateFieldGet(this, _AllureReport_ci, "f")?.jobRunBranch,
+                ...remoteReportParams(__classPrivateFieldGet(this, _AllureReport_ci, "f")),
                 allureServiceClient: __classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f"),
             }), "f");
         }
@@ -587,8 +695,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"),
@@ -609,13 +717,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];