@allurereport/core 3.8.2 → 3.10.0

package/dist/report.js

@@ -9,11 +9,12 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _AllureReport_instances, _AllureReport_reportName, _AllureReport_ci, _AllureReport_store, _AllureReport_readers, _AllureReport_plugins, _AllureReport_reportFiles, _AllureReport_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;
+var _AllureReport_instances, _AllureReport_ci, _AllureReport_store, _AllureReport_readers, _AllureReport_plugins, _AllureReport_reportFiles, _AllureReport_realtimeChannel, _AllureReport_realtimeUpdateScheduler, _AllureReport_realTime, _AllureReport_hideLabels, _AllureReport_output, _AllureReport_history, _AllureReport_allureServiceClient, _AllureReport_qualityGate, _AllureReport_dump, _AllureReport_categories, _AllureReport_environments, _AllureReport_globalAttachments, _AllureReport_dumpTempDirs, _AllureReport_state, _AllureReport_executionStage, _AllureReport_historyDataPoint, _AllureReport_summaryPath, _AllureReport_summariesByPluginId, _AllureReport_publishedRemoteHrefs, _AllureReport_published, _AllureReport_endGeneratePerfSpan, _AllureReport_publish, _AllureReport_runRealtimeUpdate, _AllureReport_getReportsToPublish, _AllureReport_cleanupFailedRemoteReport, _AllureReport_logPublishError, _AllureReport_applyPublishLinksToSummaries, _AllureReport_cloneSummariesByPluginId, _AllureReport_writeSummaryFiles, _AllureReport_generateRootSummary, _AllureReport_finishGeneratePerfSpan, _AllureReport_finishPerfMetrics, _AllureReport_eachPlugin, _AllureReport_getPluginState;
 import console from "node:console";
 import { randomUUID } from "node:crypto";
-import { createWriteStream, existsSync, readFileSync } from "node:fs";
-import { lstat, mkdtemp, opendir, readdir, realpath, rename, rm, writeFile } from "node:fs/promises";
+import { once } from "node:events";
+import { createReadStream, createWriteStream, existsSync, readFileSync } from "node:fs";
+import { lstat, mkdtemp, readdir, realpath, rename, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { basename, dirname, join, resolve, sep } from "node:path";
 import { promisify } from "node:util";
@@ -22,37 +23,53 @@ 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 { AllureRemoteHistory, AllureServiceClient, AllureTestOpsClient, KnownError, UnknownError, } from "@allurereport/service";
 import { generateSummary } from "@allurereport/summary";
 import { glob } from "glob";
 import ZipReadStream from "node-stream-zip";
 import pLimit from "p-limit";
-import ProgressBar from "progress";
 import ZipWriteStream from "zip-stream";
 import { AllureLocalHistory, createHistory } from "./history.js";
 import { DefaultPluginState, PluginFiles } from "./plugin.js";
 import { QualityGate } from "./qualityGate/index.js";
 import { DefaultAllureStore } from "./store/store.js";
+import { createUploadProgressBarCounter } from "./utils/cli.js";
 import { environmentIdentityById, environmentIdentityByName } from "./utils/environment.js";
+import { measurePerf, PERF_METRIC_NAMES, PERF_METRIC_PREFIXES, startPerfSpan, writePerfMetrics } from "./utils/perf.js";
 import { RealtimeChannel } from "./utils/realtimeChannel.js";
 import { RealtimeUpdateScheduler } from "./utils/realtimeUpdateScheduler.js";
 import { resolveDumpAttachmentPath, UnsafeDumpPathError } from "./utils/safeDumpPath.js";
 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 defaultReadConcurrency = 64;
+const maxReadConcurrency = 256;
+const readConcurrency = () => {
+    const parsed = Number.parseInt(process.env.ALLURE_READ_CONCURRENCY ?? "", 10);
+    if (!Number.isFinite(parsed)) {
+        return defaultReadConcurrency;
+    }
+    return Math.min(maxReadConcurrency, Math.max(1, parsed));
+};
+const clonePluginSummary = (summary) => structuredClone(summary);
 const remoteReportParams = (ci) => {
     const repo = ci?.repoName;
     const branch = ci?.jobRunBranch;
     return repo && branch ? { repo, branch } : {};
 };
-const REMOTE_UPLOAD_CONCURRENCY = 50;
-const REMOTE_UPLOAD_MAX_ATTEMPTS = 5;
-const REMOTE_UPLOAD_MAX_SIMULTANEOUS_FAILED = 5;
 const errorDetails = (err) => (err instanceof Error ? (err.stack ?? err.message) : String(err));
-const isAbortError = (err) => typeof err === "object" && err !== null && "name" in err && err?.name === "AbortError";
+const closeReadStream = async (stream) => {
+    if (stream.closed) {
+        return;
+    }
+    const closed = once(stream, "close").then(() => undefined);
+    if (!stream.destroyed) {
+        stream.destroy();
+    }
+    await closed.catch(() => undefined);
+};
 export class AllureReport {
     constructor(opts) {
         _AllureReport_instances.add(this);
-        _AllureReport_reportName.set(this, void 0);
         _AllureReport_ci.set(this, void 0);
         _AllureReport_store.set(this, void 0);
         _AllureReport_readers.set(this, void 0);
@@ -73,7 +90,123 @@ export class AllureReport {
         _AllureReport_dumpTempDirs.set(this, []);
         _AllureReport_state.set(this, void 0);
         _AllureReport_executionStage.set(this, "init");
-        this.readDirectory = async (resultsDir) => {
+        _AllureReport_historyDataPoint.set(this, void 0);
+        _AllureReport_summaryPath.set(this, void 0);
+        _AllureReport_summariesByPluginId.set(this, new Map());
+        _AllureReport_publishedRemoteHrefs.set(this, new Set());
+        _AllureReport_published.set(this, false);
+        _AllureReport_endGeneratePerfSpan.set(this, void 0);
+        _AllureReport_publish.set(this, async () => {
+            if (__classPrivateFieldGet(this, _AllureReport_published, "f")) {
+                return;
+            }
+            if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") !== "done") {
+                throw new Error("report is not completed. Call the done() method first.");
+            }
+            let historyPoint = __classPrivateFieldGet(this, _AllureReport_historyDataPoint, "f");
+            if (!historyPoint) {
+                const allTrs = await __classPrivateFieldGet(this, _AllureReport_store, "f").allTestResults();
+                const allTcs = await __classPrivateFieldGet(this, _AllureReport_store, "f").allTestCases();
+                historyPoint = createHistory(this.reportUuid, this.reportName, allTcs, allTrs, this.reportUrl);
+                __classPrivateFieldSet(this, _AllureReport_historyDataPoint, historyPoint, "f");
+            }
+            await __classPrivateFieldGet(this, _AllureReport_writeSummaryFiles, "f").call(this);
+            await __classPrivateFieldGet(this, _AllureReport_generateRootSummary, "f").call(this);
+            if (__classPrivateFieldGet(this, _AllureReport_realTime, "f") || !__classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f")) {
+                __classPrivateFieldSet(this, _AllureReport_published, true, "f");
+                return;
+            }
+            const reportsToPublish = (await __classPrivateFieldGet(this, _AllureReport_getReportsToPublish, "f").call(this)).filter((report) => report.publish && Object.keys(report.files).length > 0);
+            if (reportsToPublish.length === 0) {
+                __classPrivateFieldSet(this, _AllureReport_published, true, "f");
+                return;
+            }
+            const client = __classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f");
+            const linksByPluginId = {};
+            const summariesSnapshot = __classPrivateFieldGet(this, _AllureReport_cloneSummariesByPluginId, "f").call(this);
+            const uploadProgressBar = createUploadProgressBarCounter(reportsToPublish.length === 1 ? `Publishing "${reportsToPublish[0].pluginId}" report` : "Publishing reports", reportsToPublish.reduce((acc, report) => acc + Object.keys(report.files).length, 0));
+            let summariesMutated = false;
+            let reportCreated = false;
+            let publishErrorMessage = "Report upload has failed, the report won't be published";
+            const endPublishPerfSpan = startPerfSpan(PERF_METRIC_NAMES.publishUploadTotal);
+            try {
+                await client.createReport({
+                    reportUuid: this.reportUuid,
+                    reportName: this.reportName,
+                    ...remoteReportParams(__classPrivateFieldGet(this, _AllureReport_ci, "f")),
+                });
+                reportCreated = true;
+                for (const report of reportsToPublish) {
+                    publishErrorMessage = `Plugin "${report.pluginId}" upload has failed, the plugin won't be published`;
+                    const uploadResult = await measurePerf(`${PERF_METRIC_PREFIXES.publishUploadPlugin}${report.pluginId}`, () => client.uploadReport({
+                        reportUuid: this.reportUuid,
+                        pluginId: report.pluginId,
+                        files: Object.fromEntries(Object.entries(report.files).filter(([filename]) => filename !== "summary.json")),
+                        onProgress: () => uploadProgressBar.tick(),
+                    }));
+                    if (uploadResult.indexHref) {
+                        linksByPluginId[report.pluginId] = uploadResult.indexHref;
+                    }
+                }
+                const changedPluginIds = __classPrivateFieldGet(this, _AllureReport_applyPublishLinksToSummaries, "f").call(this, linksByPluginId);
+                summariesMutated = changedPluginIds.size > 0;
+                if (changedPluginIds.size > 0) {
+                    await __classPrivateFieldGet(this, _AllureReport_writeSummaryFiles, "f").call(this);
+                    await __classPrivateFieldGet(this, _AllureReport_generateRootSummary, "f").call(this);
+                }
+                const updatedReports = await __classPrivateFieldGet(this, _AllureReport_getReportsToPublish, "f").call(this);
+                const updatedReportsByPluginId = new Map(updatedReports.map((report) => [report.pluginId, report]));
+                for (const report of reportsToPublish) {
+                    const updatedReport = updatedReportsByPluginId.get(report.pluginId) ?? report;
+                    const summaryFilepath = updatedReport.files["summary.json"];
+                    if (!summaryFilepath) {
+                        continue;
+                    }
+                    publishErrorMessage = `Plugin "${report.pluginId}" summary upload has failed, the plugin won't be published`;
+                    await client.uploadReport({
+                        reportUuid: this.reportUuid,
+                        pluginId: updatedReport.pluginId,
+                        files: { "summary.json": summaryFilepath },
+                        onProgress: () => uploadProgressBar.tick(),
+                    });
+                }
+                publishErrorMessage = "Report summary upload has failed, the report won't be published";
+                const summaryHref = __classPrivateFieldGet(this, _AllureReport_summaryPath, "f")
+                    ? (await client.uploadReport({
+                        reportUuid: this.reportUuid,
+                        files: { "index.html": __classPrivateFieldGet(this, _AllureReport_summaryPath, "f") },
+                    })).indexHref
+                    : undefined;
+                publishErrorMessage = "Report completion has failed, the report won't be published";
+                await client.completeReport({
+                    reportUuid: this.reportUuid,
+                    historyPoint,
+                });
+                Object.values(linksByPluginId)
+                    .filter(Boolean)
+                    .forEach((href) => __classPrivateFieldGet(this, _AllureReport_publishedRemoteHrefs, "f").add(href));
+                if (summaryHref) {
+                    __classPrivateFieldGet(this, _AllureReport_publishedRemoteHrefs, "f").add(summaryHref);
+                }
+                __classPrivateFieldSet(this, _AllureReport_published, true, "f");
+            }
+            catch (err) {
+                if (reportCreated) {
+                    await __classPrivateFieldGet(this, _AllureReport_cleanupFailedRemoteReport, "f").call(this, client);
+                }
+                if (summariesMutated) {
+                    __classPrivateFieldSet(this, _AllureReport_summariesByPluginId, summariesSnapshot, "f");
+                    await __classPrivateFieldGet(this, _AllureReport_writeSummaryFiles, "f").call(this);
+                    await __classPrivateFieldGet(this, _AllureReport_generateRootSummary, "f").call(this);
+                }
+                __classPrivateFieldGet(this, _AllureReport_logPublishError, "f").call(this, publishErrorMessage, err);
+            }
+            finally {
+                endPublishPerfSpan();
+                uploadProgressBar.terminate();
+            }
+        });
+        this.readDirectory = async (resultsDir) => measurePerf(PERF_METRIC_NAMES.generateReadResults, async () => {
             if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") !== "running") {
                 throw new Error(initRequired);
             }
@@ -81,31 +214,40 @@ export class AllureReport {
             if (await readXcResultBundle(__classPrivateFieldGet(this, _AllureReport_store, "f"), resultsDirPath)) {
                 return;
             }
-            const dir = await opendir(resultsDirPath);
             try {
-                for await (const dirent of dir) {
-                    if (dirent.isFile()) {
-                        const path = await realpath(join(dirent.parentPath ?? dirent.path, dirent.name));
+                const entries = (await readdir(resultsDirPath, { withFileTypes: true }))
+                    .filter((dirent) => dirent.isFile())
+                    .sort((a, b) => a.name.localeCompare(b.name));
+                const limit = pLimit(readConcurrency());
+                await Promise.all(entries.map((dirent) => limit(async () => {
+                    try {
+                        const path = await realpath(join(resultsDirPath, dirent.name));
                         await this.readResult(new PathResultFile(path, dirent.name));
                     }
-                }
+                    catch (e) {
+                        console.error(`can't read result file ${dirent.name}`, e);
+                    }
+                })));
             }
             catch (e) {
                 console.error("can't read directory", e);
             }
-        };
-        this.readFile = async (resultsFile) => {
+        });
+        this.readFile = async (resultsFile) => measurePerf(PERF_METRIC_NAMES.generateReadResults, async () => {
             if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") !== "running") {
                 throw new Error(initRequired);
             }
             await this.readResult(new PathResultFile(resultsFile));
-        };
+        });
         this.readResult = async (data) => {
             if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") !== "running") {
                 throw new Error(initRequired);
             }
             for (const reader of __classPrivateFieldGet(this, _AllureReport_readers, "f")) {
                 try {
+                    if (reader.matches && !(await reader.matches(data))) {
+                        continue;
+                    }
                     const processed = await reader.read(__classPrivateFieldGet(this, _AllureReport_store, "f"), data);
                     if (processed) {
                         return;
@@ -129,7 +271,6 @@ export class AllureReport {
             });
         };
         this.start = async () => {
-            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");
@@ -138,6 +279,7 @@ export class AllureReport {
                 throw new Error("the report is already stopped, the restart isn't supported at the moment");
             }
             __classPrivateFieldSet(this, _AllureReport_executionStage, "running", "f");
+            __classPrivateFieldSet(this, _AllureReport_endGeneratePerfSpan, startPerfSpan(PERF_METRIC_NAMES.generateTotal), "f");
             const cwd = resolve(process.cwd());
             const cwdWithSep = cwd.endsWith(sep) ? cwd : `${cwd}${sep}`;
             if (__classPrivateFieldGet(this, _AllureReport_globalAttachments, "f")?.length) {
@@ -156,14 +298,6 @@ export class AllureReport {
                     __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)) {
-                const url = await __classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f").createReport({
-                    reportUuid: this.reportUuid,
-                    reportName: __classPrivateFieldGet(this, _AllureReport_reportName, "f"),
-                    ...remoteParams,
-                });
-                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_realtimeChannel, "f").subscriber);
             });
@@ -228,7 +362,7 @@ export class AllureReport {
             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 = [], }) => [
+            const dumpJsonEntries = ({ testResults, testCases, fixtures, attachments, environments, reportVariables, checkResults = [], globalAttachmentIds = [], globalErrors = [], indexAttachmentByTestResult = {}, indexTestResultByHistoryId = {}, indexTestResultByTestCase = {}, indexAttachmentByFixture = {}, indexFixturesByTestResult = {}, indexKnownByHistoryId = {}, qualityGateResults = [], testResultIdsIngestOrder = [], }) => [
                 [AllureStoreDumpFiles.TestResults, testResults],
                 [AllureStoreDumpFiles.TestCases, testCases],
                 [AllureStoreDumpFiles.Fixtures, fixtures],
@@ -241,11 +375,11 @@ export class AllureReport {
                 [AllureStoreDumpFiles.IndexAttachmentsByTestResults, indexAttachmentByTestResult],
                 [AllureStoreDumpFiles.IndexTestResultsByHistoryId, indexTestResultByHistoryId],
                 [AllureStoreDumpFiles.IndexTestResultsByTestCase, indexTestResultByTestCase],
-                [AllureStoreDumpFiles.IndexLatestEnvTestResultsByHistoryId, indexLatestEnvTestResultByHistoryId],
                 [AllureStoreDumpFiles.IndexAttachmentsByFixture, indexAttachmentByFixture],
                 [AllureStoreDumpFiles.IndexFixturesByTestResult, indexFixturesByTestResult],
                 [AllureStoreDumpFiles.IndexKnownByHistoryId, indexKnownByHistoryId],
                 [AllureStoreDumpFiles.QualityGateResults, qualityGateResults],
+                [AllureStoreDumpFiles.TestResultIngestOrder, testResultIdsIngestOrder],
             ];
             let dumpError;
             dumpArchive.pipe(dumpArchiveWriteStream);
@@ -263,6 +397,15 @@ export class AllureReport {
                             skipAttachment("attachment content is missing");
                             continue;
                         }
+                        if (content instanceof PathResultFile) {
+                            const stream = createReadStream(content.path);
+                            const err = await addDumpEntry(stream, attachment.id);
+                            if (err) {
+                                await closeReadStream(stream);
+                                skipAttachment(`failed to add attachment entry: ${errMessage(err)}`);
+                            }
+                            continue;
+                        }
                         const data = await content.asBuffer();
                         if (data === undefined) {
                             skipAttachment("attachment content is missing");
@@ -302,382 +445,357 @@ export class AllureReport {
             }
             await rename(dumpTempPath, dumpPath);
         };
-        this.restoreState = async (dumps) => {
+        this.restoreState = async (dumps) => measurePerf(PERF_METRIC_NAMES.restoreStateTotal, async () => {
             for (const dump of dumps) {
-                if (!existsSync(dump)) {
-                    console.error(`Failed to restore state from "${dump}", continuing without it`);
-                    console.error("Dump file does not exist");
-                    continue;
-                }
-                try {
-                    const dumpArchive = new ZipReadStream.async({
-                        file: dump,
-                    });
-                    let restoreError;
+                await measurePerf(PERF_METRIC_NAMES.restoreStateDump, async () => {
+                    if (!existsSync(dump)) {
+                        console.error(`Failed to restore state from "${dump}", continuing without it`);
+                        console.error("Dump file does not exist");
+                        return;
+                    }
                     try {
-                        const dumpEntries = await dumpArchive.entries();
-                        const dumpEntriesList = Object.entries(dumpEntries);
-                        const requiredEntryData = async (entryName) => {
-                            if (!dumpEntries[entryName]) {
-                                throw new Error(`Missing required dump entry "${entryName}"`);
-                            }
-                            return dumpArchive.entryData(entryName);
-                        };
-                        const optionalEntryData = async (entryName) => dumpEntries[entryName] ? dumpArchive.entryData(entryName) : undefined;
-                        if (!dumpEntries[AllureStoreDumpFiles.TestResults]) {
-                            const nestedDumpEntries = dumpEntriesList.filter(([entryName, entry]) => !entry.isDirectory &&
-                                !entryName.startsWith("__MACOSX/") &&
-                                !basename(entryName).startsWith("._") &&
-                                entryName.toLowerCase().endsWith(".zip"));
-                            if (nestedDumpEntries.length > 0) {
-                                const nestedDumpsTempDir = await mkdtemp(join(tmpdir(), `${basename(dump, ".zip")}-nested-`));
-                                const nestedDumpPaths = [];
-                                __classPrivateFieldGet(this, _AllureReport_dumpTempDirs, "f").push(nestedDumpsTempDir);
-                                for (const [entryName] of nestedDumpEntries) {
-                                    const nestedDumpPath = join(nestedDumpsTempDir, `${nestedDumpPaths.length}-${basename(entryName)}`);
-                                    await writeFile(nestedDumpPath, await dumpArchive.entryData(entryName));
-                                    nestedDumpPaths.push(nestedDumpPath);
+                        const dumpArchive = new ZipReadStream.async({
+                            file: dump,
+                        });
+                        let restoreError;
+                        try {
+                            const dumpEntries = await dumpArchive.entries();
+                            const dumpEntriesList = Object.entries(dumpEntries);
+                            const requiredEntryData = async (entryName) => {
+                                if (!dumpEntries[entryName]) {
+                                    throw new Error(`Missing required dump entry "${entryName}"`);
+                                }
+                                return dumpArchive.entryData(entryName);
+                            };
+                            const optionalEntryData = async (entryName) => dumpEntries[entryName] ? dumpArchive.entryData(entryName) : undefined;
+                            if (!dumpEntries[AllureStoreDumpFiles.TestResults]) {
+                                const nestedDumpEntries = dumpEntriesList.filter(([entryName, entry]) => !entry.isDirectory &&
+                                    !entryName.startsWith("__MACOSX/") &&
+                                    !basename(entryName).startsWith("._") &&
+                                    entryName.toLowerCase().endsWith(".zip"));
+                                if (nestedDumpEntries.length > 0) {
+                                    const nestedDumpsTempDir = await mkdtemp(join(tmpdir(), `${basename(dump, ".zip")}-nested-`));
+                                    const nestedDumpPaths = [];
+                                    __classPrivateFieldGet(this, _AllureReport_dumpTempDirs, "f").push(nestedDumpsTempDir);
+                                    for (const [entryName] of nestedDumpEntries) {
+                                        const nestedDumpPath = join(nestedDumpsTempDir, `${nestedDumpPaths.length}-${basename(entryName)}`);
+                                        await writeFile(nestedDumpPath, await dumpArchive.entryData(entryName));
+                                        nestedDumpPaths.push(nestedDumpPath);
+                                    }
+                                    await this.restoreState(nestedDumpPaths);
+                                    return;
                                 }
-                                await this.restoreState(nestedDumpPaths);
-                                continue;
                             }
-                        }
-                        const testResultsEntry = await requiredEntryData(AllureStoreDumpFiles.TestResults);
-                        const testCasesEntry = await requiredEntryData(AllureStoreDumpFiles.TestCases);
-                        const fixturesEntry = await requiredEntryData(AllureStoreDumpFiles.Fixtures);
-                        const attachmentsEntry = await requiredEntryData(AllureStoreDumpFiles.Attachments);
-                        const checkResultsEntry = await optionalEntryData(AllureStoreDumpFiles.CheckResults);
-                        const environmentsEntry = await requiredEntryData(AllureStoreDumpFiles.Environments);
-                        const reportVariablesEntry = await requiredEntryData(AllureStoreDumpFiles.ReportVariables);
-                        const globalAttachmentsEntry = await requiredEntryData(AllureStoreDumpFiles.GlobalAttachments);
-                        const globalErrorsEntry = await requiredEntryData(AllureStoreDumpFiles.GlobalErrors);
-                        const indexAttachmentsEntry = await requiredEntryData(AllureStoreDumpFiles.IndexAttachmentsByTestResults);
-                        const indexTestResultsByHistoryId = await requiredEntryData(AllureStoreDumpFiles.IndexTestResultsByHistoryId);
-                        const indexTestResultsByTestCaseEntry = await requiredEntryData(AllureStoreDumpFiles.IndexTestResultsByTestCase);
-                        const 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) {
+                            const testResultsEntry = await requiredEntryData(AllureStoreDumpFiles.TestResults);
+                            const testCasesEntry = await requiredEntryData(AllureStoreDumpFiles.TestCases);
+                            const fixturesEntry = await requiredEntryData(AllureStoreDumpFiles.Fixtures);
+                            const attachmentsEntry = await requiredEntryData(AllureStoreDumpFiles.Attachments);
+                            const checkResultsEntry = await optionalEntryData(AllureStoreDumpFiles.CheckResults);
+                            const environmentsEntry = await requiredEntryData(AllureStoreDumpFiles.Environments);
+                            const reportVariablesEntry = await requiredEntryData(AllureStoreDumpFiles.ReportVariables);
+                            const globalAttachmentsEntry = await requiredEntryData(AllureStoreDumpFiles.GlobalAttachments);
+                            const globalErrorsEntry = await requiredEntryData(AllureStoreDumpFiles.GlobalErrors);
+                            const indexAttachmentsEntry = await requiredEntryData(AllureStoreDumpFiles.IndexAttachmentsByTestResults);
+                            const indexTestResultsByHistoryId = await requiredEntryData(AllureStoreDumpFiles.IndexTestResultsByHistoryId);
+                            const indexTestResultsByTestCaseEntry = await requiredEntryData(AllureStoreDumpFiles.IndexTestResultsByTestCase);
+                            const indexAttachmentsByFixtureEntry = await requiredEntryData(AllureStoreDumpFiles.IndexAttachmentsByFixture);
+                            const indexFixturesByTestResultEntry = await requiredEntryData(AllureStoreDumpFiles.IndexFixturesByTestResult);
+                            const indexKnownByHistoryIdEntry = await requiredEntryData(AllureStoreDumpFiles.IndexKnownByHistoryId);
+                            const qualityGateResultsEntry = await requiredEntryData(AllureStoreDumpFiles.QualityGateResults);
+                            const testResultIngestOrderEntry = await optionalEntryData(AllureStoreDumpFiles.TestResultIngestOrder);
+                            const attachmentsLinks = JSON.parse(attachmentsEntry.toString("utf8"));
+                            const attachmentsEntries = dumpEntriesList.reduce((acc, [entryName, entry]) => {
+                                switch (entryName) {
+                                    case AllureStoreDumpFiles.Attachments:
+                                    case AllureStoreDumpFiles.CheckResults:
+                                    case AllureStoreDumpFiles.TestResults:
+                                    case AllureStoreDumpFiles.TestCases:
+                                    case AllureStoreDumpFiles.Fixtures:
+                                    case AllureStoreDumpFiles.Environments:
+                                    case AllureStoreDumpFiles.ReportVariables:
+                                    case AllureStoreDumpFiles.GlobalAttachments:
+                                    case AllureStoreDumpFiles.GlobalErrors:
+                                    case AllureStoreDumpFiles.IndexAttachmentsByTestResults:
+                                    case AllureStoreDumpFiles.IndexTestResultsByHistoryId:
+                                    case AllureStoreDumpFiles.IndexTestResultsByTestCase:
+                                    case AllureStoreDumpFiles.IndexAttachmentsByFixture:
+                                    case AllureStoreDumpFiles.IndexFixturesByTestResult:
+                                    case AllureStoreDumpFiles.IndexKnownByHistoryId:
+                                    case AllureStoreDumpFiles.QualityGateResults:
+                                    case AllureStoreDumpFiles.TestResultIngestOrder:
                                         return acc;
+                                    default:
+                                        if (entry.isDirectory || !attachmentsLinks[entryName] || attachmentsLinks[entryName].missed) {
+                                            return acc;
+                                        }
+                                        return Object.assign(acc, {
+                                            [entryName]: entry,
+                                        });
+                                }
+                            }, {});
+                            const dumpState = {
+                                testResults: JSON.parse(testResultsEntry.toString("utf8")),
+                                testCases: JSON.parse(testCasesEntry.toString("utf8")),
+                                fixtures: JSON.parse(fixturesEntry.toString("utf8")),
+                                attachments: attachmentsLinks,
+                                checkResults: checkResultsEntry ? JSON.parse(checkResultsEntry.toString("utf8")) : [],
+                                environments: JSON.parse(environmentsEntry.toString("utf8")),
+                                reportVariables: JSON.parse(reportVariablesEntry.toString("utf8")),
+                                globalAttachmentIds: JSON.parse(globalAttachmentsEntry.toString("utf8")),
+                                globalErrors: JSON.parse(globalErrorsEntry.toString("utf8")),
+                                indexAttachmentByTestResult: JSON.parse(indexAttachmentsEntry.toString("utf8")),
+                                indexTestResultByHistoryId: JSON.parse(indexTestResultsByHistoryId.toString("utf8")),
+                                indexTestResultByTestCase: JSON.parse(indexTestResultsByTestCaseEntry.toString("utf8")),
+                                indexAttachmentByFixture: JSON.parse(indexAttachmentsByFixtureEntry.toString("utf8")),
+                                indexFixturesByTestResult: JSON.parse(indexFixturesByTestResultEntry.toString("utf8")),
+                                indexKnownByHistoryId: JSON.parse(indexKnownByHistoryIdEntry.toString("utf8")),
+                                qualityGateResults: JSON.parse(qualityGateResultsEntry.toString("utf8")),
+                                testResultIdsIngestOrder: testResultIngestOrderEntry
+                                    ? JSON.parse(testResultIngestOrderEntry.toString("utf8"))
+                                    : [],
+                            };
+                            const dumpTempDir = await mkdtemp(join(tmpdir(), basename(dump, ".zip")));
+                            const resultsAttachments = {};
+                            __classPrivateFieldGet(this, _AllureReport_dumpTempDirs, "f").push(dumpTempDir);
+                            await measurePerf(PERF_METRIC_NAMES.restoreStateAttachments, async () => {
+                                try {
+                                    for (const [attachmentId] of Object.entries(attachmentsEntries)) {
+                                        const attachmentContentEntry = await dumpArchive.entryData(attachmentId);
+                                        const attachmentFilePath = resolveDumpAttachmentPath(dumpTempDir, attachmentId);
+                                        await writeFile(attachmentFilePath, attachmentContentEntry);
+                                        resultsAttachments[attachmentId] = new PathResultFile(attachmentFilePath, attachmentId);
                                     }
-                                    return Object.assign(acc, {
-                                        [entryName]: entry,
-                                    });
-                            }
-                        }, {});
-                        const dumpState = {
-                            testResults: JSON.parse(testResultsEntry.toString("utf8")),
-                            testCases: JSON.parse(testCasesEntry.toString("utf8")),
-                            fixtures: JSON.parse(fixturesEntry.toString("utf8")),
-                            attachments: attachmentsLinks,
-                            checkResults: checkResultsEntry ? JSON.parse(checkResultsEntry.toString("utf8")) : [],
-                            environments: JSON.parse(environmentsEntry.toString("utf8")),
-                            reportVariables: JSON.parse(reportVariablesEntry.toString("utf8")),
-                            globalAttachmentIds: JSON.parse(globalAttachmentsEntry.toString("utf8")),
-                            globalErrors: JSON.parse(globalErrorsEntry.toString("utf8")),
-                            indexAttachmentByTestResult: JSON.parse(indexAttachmentsEntry.toString("utf8")),
-                            indexTestResultByHistoryId: JSON.parse(indexTestResultsByHistoryId.toString("utf8")),
-                            indexTestResultByTestCase: JSON.parse(indexTestResultsByTestCaseEntry.toString("utf8")),
-                            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 measurePerf(PERF_METRIC_NAMES.restoreStateStoreRestore, async () => __classPrivateFieldGet(this, _AllureReport_store, "f").restoreState(dumpState, resultsAttachments));
+                            console.info(`Successfully restored state from "${dump}"`);
                         }
                         catch (err) {
-                            if (err instanceof UnsafeDumpPathError) {
-                                console.error(`Cannot restore dump from "${dump}": the archive lists attachment paths that would write outside the extract directory (unsafe zip paths such as "../" or absolute names).`);
-                                console.error(err.message);
-                                console.error("Only use dump archives produced by this tool; do not load untrusted or third-party --dump zip files.");
-                                throw err;
+                            restoreError = err;
+                            throw err;
+                        }
+                        finally {
+                            try {
+                                await dumpArchive.close();
+                            }
+                            catch (err) {
+                                if (!restoreError) {
+                                    console.error(`Failed to close dump archive "${dump}"`);
+                                    console.error(errorDetails(err));
+                                }
                             }
-                            console.error(`Can't restore attachment contents from "${dump}", continuing without them`);
-                            console.error(errorDetails(err));
                         }
-                        await __classPrivateFieldGet(this, _AllureReport_store, "f").restoreState(dumpState, resultsAttachments);
-                        console.info(`Successfully restored state from "${dump}"`);
                     }
                     catch (err) {
-                        restoreError = err;
-                        throw err;
+                        console.error(`Failed to restore state from "${dump}", continuing without it`);
+                        console.error(errorDetails(err));
                     }
-                    finally {
-                        try {
-                            await dumpArchive.close();
-                        }
-                        catch (err) {
-                            if (!restoreError) {
-                                console.error(`Failed to close dump archive "${dump}"`);
-                                console.error(errorDetails(err));
-                            }
-                        }
-                    }
-                }
-                catch (err) {
-                    console.error(`Failed to restore state from "${dump}", continuing without it`);
-                    console.error(errorDetails(err));
-                }
+                });
             }
-        };
-        this.done = async () => {
-            const summaries = [];
-            const remoteHrefs = new Set();
-            const remoteHrefsByPluginId = {};
-            const cancelledPluginsIds = new Set();
-            let remoteCleanupFailed = false;
-            const getSuccessfulPublishedPlugins = () => __classPrivateFieldGet(this, _AllureReport_plugins, "f").filter(({ enabled, id, options }) => enabled && !!options?.publish && !cancelledPluginsIds.has(id));
-            if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") !== "running") {
-                throw new Error(initRequired);
+        });
+        _AllureReport_getReportsToPublish.set(this, async () => {
+            const reports = [];
+            for (const { enabled, id, options } of __classPrivateFieldGet(this, _AllureReport_plugins, "f")) {
+                if (!enabled) {
+                    continue;
+                }
+                const files = (await __classPrivateFieldGet(this, _AllureReport_state, "f")?.[id]?.get("files")) ?? {};
+                reports.push({
+                    pluginId: id,
+                    publish: !!options?.publish,
+                    files,
+                });
             }
-            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_realtimeChannel, "f").close();
+            return reports;
+        });
+        _AllureReport_cleanupFailedRemoteReport.set(this, async (client) => {
             try {
-                await __classPrivateFieldGet(this, _AllureReport_realtimeUpdateScheduler, "f").close();
+                await client.deleteReport({
+                    reportUuid: this.reportUuid,
+                });
             }
-            catch (e) {
-                console.error("realtime update failed during shutdown", e);
+            catch (cleanupError) {
+                console.error("Failed to clean up failed report upload");
+                console.error(errorDetails(cleanupError));
             }
-            __classPrivateFieldSet(this, _AllureReport_executionStage, "done", "f");
-            if (__classPrivateFieldGet(this, _AllureReport_dump, "f")) {
-                await this.dumpState();
+        });
+        _AllureReport_logPublishError.set(this, (message, err) => {
+            console.error(message);
+            if (err instanceof KnownError) {
+                console.error(err.message);
+            }
+            else {
+                console.error(errorDetails(err));
+            }
+        });
+        _AllureReport_applyPublishLinksToSummaries.set(this, (linksByPluginId) => {
+            const changedPluginIds = new Set();
+            if (__classPrivateFieldGet(this, _AllureReport_summariesByPluginId, "f").size === 0) {
+                return changedPluginIds;
+            }
+            for (const [pluginId, remoteHref] of Object.entries(linksByPluginId)) {
+                const summary = __classPrivateFieldGet(this, _AllureReport_summariesByPluginId, "f").get(pluginId);
+                if (summary && remoteHref) {
+                    summary.remoteHref = remoteHref;
+                    changedPluginIds.add(pluginId);
+                }
+            }
+            return changedPluginIds;
+        });
+        _AllureReport_cloneSummariesByPluginId.set(this, () => new Map([...__classPrivateFieldGet(this, _AllureReport_summariesByPluginId, "f")].map(([pluginId, summary]) => [pluginId, clonePluginSummary(summary)])));
+        _AllureReport_writeSummaryFiles.set(this, async (pluginIds) => {
+            if (__classPrivateFieldGet(this, _AllureReport_summariesByPluginId, "f").size === 0) {
                 return;
             }
-            await __classPrivateFieldGet(this, _AllureReport_eachPlugin, "f").call(this, false, async (plugin, context) => {
-                await plugin.done?.(context, __classPrivateFieldGet(this, _AllureReport_store, "f"));
-            });
-            await __classPrivateFieldGet(this, _AllureReport_eachPlugin, "f").call(this, false, async (plugin, context) => {
-                if (__classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f") && context.publish) {
-                    const pluginFiles = (await context.state.get("files")) ?? {};
-                    const pluginFilesEntries = Object.entries(pluginFiles);
-                    const progressBar = pluginFilesEntries?.length > 0
-                        ? new ProgressBar(`Publishing "${context.id}" report [:bar] :current/:total`, {
-                            total: pluginFilesEntries.length,
-                            width: 20,
-                        })
-                        : undefined;
-                    const limitFn = pLimit(REMOTE_UPLOAD_CONCURRENCY);
-                    const uploadAbortController = new AbortController();
-                    const failedUploads = new Set();
-                    let terminalUploadError;
-                    let remoteReportDeleted = false;
-                    let fns = [];
-                    const cleanupFailedPluginUpload = async (err) => {
-                        if (remoteReportDeleted) {
-                            return;
-                        }
-                        remoteReportDeleted = true;
-                        cancelledPluginsIds.add(context.id);
-                        uploadAbortController.abort();
-                        await Promise.allSettled(fns);
-                        const pluginRemoteHref = remoteHrefsByPluginId[context.id];
-                        if (pluginRemoteHref) {
-                            remoteHrefs.delete(pluginRemoteHref);
-                            delete remoteHrefsByPluginId[context.id];
-                        }
-                        try {
-                            await __classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f").deleteReport({
-                                reportUuid: this.reportUuid,
-                                pluginId: context.id,
-                            });
-                        }
-                        catch (cleanupErr) {
-                            remoteCleanupFailed = true;
-                            console.error(`Plugin "${context.id}" upload cleanup has failed, the remote report won't be completed`);
-                            console.error(cleanupErr);
-                        }
-                        console.error(`Plugin "${context.id}" upload has failed, the plugin won't be published`);
-                        console.error(err);
-                    };
-                    fns = pluginFilesEntries.map(([filename, filepath]) => limitFn(async () => {
-                        if (cancelledPluginsIds.has(context.id) || uploadAbortController.signal.aborted) {
-                            return;
-                        }
-                        for (let attempt = 1; attempt <= REMOTE_UPLOAD_MAX_ATTEMPTS; attempt++) {
-                            if (cancelledPluginsIds.has(context.id) || uploadAbortController.signal.aborted) {
-                                return;
-                            }
-                            try {
-                                if (/^(data|widgets|index\.html$|summary\.json$)/.test(filename)) {
-                                    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,
-                                    });
-                                }
-                                failedUploads.delete(filename);
-                                progressBar?.tick?.();
-                                return;
-                            }
-                            catch (err) {
-                                if (cancelledPluginsIds.has(context.id) || uploadAbortController.signal.aborted) {
-                                    return;
-                                }
-                                if (isAbortError(err)) {
-                                    throw err;
-                                }
-                                failedUploads.add(filename);
-                                if (failedUploads.size > REMOTE_UPLOAD_MAX_SIMULTANEOUS_FAILED ||
-                                    attempt >= REMOTE_UPLOAD_MAX_ATTEMPTS) {
-                                    terminalUploadError ?? (terminalUploadError = err);
-                                    throw terminalUploadError;
-                                }
-                            }
-                        }
-                    }));
-                    progressBar?.render?.();
-                    try {
-                        await Promise.all(fns);
-                    }
-                    catch (err) {
-                        await cleanupFailedPluginUpload(terminalUploadError ?? err);
-                    }
+            const pluginIdsSet = pluginIds ? new Set(pluginIds) : undefined;
+            await __classPrivateFieldGet(this, _AllureReport_eachPlugin, "f").call(this, false, async (_plugin, context) => {
+                if (pluginIdsSet && !pluginIdsSet.has(context.id)) {
+                    return;
                 }
-                const summary = await plugin?.info?.(context, __classPrivateFieldGet(this, _AllureReport_store, "f"));
+                const summary = __classPrivateFieldGet(this, _AllureReport_summariesByPluginId, "f").get(context.id);
                 if (!summary) {
                     return;
                 }
-                summary.pluginId = context.id;
-                summary.pullRequestHref = __classPrivateFieldGet(this, _AllureReport_ci, "f")?.pullRequestUrl;
-                summary.jobHref = __classPrivateFieldGet(this, _AllureReport_ci, "f")?.jobRunUrl;
-                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,
-                    href: `${context.id}/`,
-                });
                 await context.reportFiles.addFile("summary.json", Buffer.from(JSON.stringify(summary)));
             });
+        });
+        _AllureReport_generateRootSummary.set(this, async () => {
+            const summaries = [...__classPrivateFieldGet(this, _AllureReport_summariesByPluginId, "f").values()].map(clonePluginSummary);
             if (summaries.length > 1) {
-                const summaryPath = await generateSummary(__classPrivateFieldGet(this, _AllureReport_output, "f"), summaries);
-                const publishedReports = getSuccessfulPublishedPlugins();
-                if (__classPrivateFieldGet(this, _AllureReport_instances, "a", _AllureReport_publish_get) && summaryPath && publishedReports.length > 1) {
-                    await __classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f")?.addReportFile({
-                        reportUuid: this.reportUuid,
-                        filename: "index.html",
-                        filepath: summaryPath,
-                    });
-                }
+                __classPrivateFieldSet(this, _AllureReport_summaryPath, await measurePerf(PERF_METRIC_NAMES.summaryGenerate, async () => generateSummary(__classPrivateFieldGet(this, _AllureReport_output, "f"), summaries)), "f");
             }
-            const publishedReports = getSuccessfulPublishedPlugins();
-            if (__classPrivateFieldGet(this, _AllureReport_instances, "a", _AllureReport_publish_get) && !remoteCleanupFailed && publishedReports.length > 0) {
-                await __classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f")?.completeReport({
-                    reportUuid: this.reportUuid,
-                    historyPoint: historyDataPoint,
-                });
+            else {
+                __classPrivateFieldSet(this, _AllureReport_summaryPath, undefined, "f");
             }
-            let outputDirFiles = [];
-            try {
-                outputDirFiles = await readdir(__classPrivateFieldGet(this, _AllureReport_output, "f"));
-            }
-            catch { }
-            if (outputDirFiles.length === 0) {
-                return;
+        });
+        this.done = async () => {
+            const summaries = [];
+            if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") !== "running") {
+                throw new Error(initRequired);
             }
-            const reportPath = join(__classPrivateFieldGet(this, _AllureReport_output, "f"), outputDirFiles[0]);
-            const reportStats = await lstat(reportPath);
-            const outputEntriesStats = await Promise.all(outputDirFiles.map((file) => lstat(join(__classPrivateFieldGet(this, _AllureReport_output, "f"), file))));
-            const outputDirectoryEntries = outputEntriesStats.filter((entry) => entry.isDirectory());
-            if (reportStats.isDirectory() && outputDirectoryEntries.length === 1) {
-                const reportContent = await readdir(reportPath);
-                for (const entry of reportContent) {
-                    const currentFilePath = join(reportPath, entry);
-                    const newFilePath = resolve(dirname(currentFilePath), "..", entry);
-                    await rename(currentFilePath, newFilePath);
+            try {
+                const testResults = await __classPrivateFieldGet(this, _AllureReport_store, "f").allTestResults();
+                const testCases = await __classPrivateFieldGet(this, _AllureReport_store, "f").allTestCases();
+                __classPrivateFieldSet(this, _AllureReport_historyDataPoint, createHistory(this.reportUuid, this.reportName, testCases, testResults, this.reportUrl), "f");
+                __classPrivateFieldGet(this, _AllureReport_realtimeChannel, "f").close();
+                try {
+                    await __classPrivateFieldGet(this, _AllureReport_realtimeUpdateScheduler, "f").close();
                 }
-                await rm(reportPath, { recursive: true });
-            }
-            for (const dir of __classPrivateFieldGet(this, _AllureReport_dumpTempDirs, "f")) {
+                catch (e) {
+                    console.error("realtime update failed during shutdown", e);
+                }
+                __classPrivateFieldSet(this, _AllureReport_executionStage, "done", "f");
+                if (__classPrivateFieldGet(this, _AllureReport_dump, "f")) {
+                    await this.dumpState();
+                    return;
+                }
+                await measurePerf(PERF_METRIC_NAMES.generatePluginsDone, async () => {
+                    await __classPrivateFieldGet(this, _AllureReport_eachPlugin, "f").call(this, false, async (plugin, context) => {
+                        await measurePerf(`${PERF_METRIC_PREFIXES.generatePluginDone}${context.id}`, async () => {
+                            await plugin.done?.(context, __classPrivateFieldGet(this, _AllureReport_store, "f"));
+                        });
+                    });
+                });
+                __classPrivateFieldGet(this, _AllureReport_finishGeneratePerfSpan, "f").call(this);
+                await __classPrivateFieldGet(this, _AllureReport_eachPlugin, "f").call(this, false, async (plugin, context) => {
+                    const summary = await plugin?.info?.(context, __classPrivateFieldGet(this, _AllureReport_store, "f"));
+                    if (!summary) {
+                        return;
+                    }
+                    summary.pluginId = context.id;
+                    summary.pullRequestHref = __classPrivateFieldGet(this, _AllureReport_ci, "f")?.pullRequestUrl;
+                    summary.jobHref = __classPrivateFieldGet(this, _AllureReport_ci, "f")?.jobRunUrl;
+                    summaries.push({
+                        ...summary,
+                        href: `${context.id}/`,
+                    });
+                });
+                __classPrivateFieldSet(this, _AllureReport_summariesByPluginId, new Map(summaries
+                    .filter((summary) => !!summary.pluginId)
+                    .map((summary) => [summary.pluginId, summary])), "f");
+                await __classPrivateFieldGet(this, _AllureReport_publish, "f").call(this);
+                let outputDirFiles = [];
                 try {
-                    await rm(dir, { recursive: true });
+                    outputDirFiles = await readdir(__classPrivateFieldGet(this, _AllureReport_output, "f"));
                 }
                 catch { }
-            }
-            if (__classPrivateFieldGet(this, _AllureReport_history, "f")) {
-                try {
-                    await __classPrivateFieldGet(this, _AllureReport_store, "f").appendHistory(historyDataPoint);
+                if (outputDirFiles.length === 0) {
+                    return;
                 }
-                catch (err) {
-                    if (err instanceof KnownError) {
-                        console.error("Failed to append history", err.message);
+                const reportPath = join(__classPrivateFieldGet(this, _AllureReport_output, "f"), outputDirFiles[0]);
+                const reportStats = await lstat(reportPath);
+                const outputEntriesStats = await Promise.all(outputDirFiles.map((file) => lstat(join(__classPrivateFieldGet(this, _AllureReport_output, "f"), file))));
+                const outputDirectoryEntries = outputEntriesStats.filter((entry) => entry.isDirectory());
+                if (reportStats.isDirectory() && outputDirectoryEntries.length === 1) {
+                    const reportContent = await readdir(reportPath);
+                    for (const entry of reportContent) {
+                        const currentFilePath = join(reportPath, entry);
+                        const newFilePath = resolve(dirname(currentFilePath), "..", entry);
+                        await rename(currentFilePath, newFilePath);
                     }
-                    else if (err instanceof UnknownError) {
-                        console.error("Failed to append history due to unexpected error", err.message);
+                    await rm(reportPath, { recursive: true });
+                }
+                for (const dir of __classPrivateFieldGet(this, _AllureReport_dumpTempDirs, "f")) {
+                    try {
+                        await rm(dir, { recursive: true });
+                    }
+                    catch { }
+                }
+                if (__classPrivateFieldGet(this, _AllureReport_history, "f")) {
+                    try {
+                        await __classPrivateFieldGet(this, _AllureReport_store, "f").appendHistory(__classPrivateFieldGet(this, _AllureReport_historyDataPoint, "f"));
                     }
-                    else {
-                        throw err;
+                    catch (err) {
+                        if (err instanceof KnownError) {
+                            console.error("Failed to append history", err.message);
+                        }
+                        else if (err instanceof UnknownError) {
+                            console.error("Failed to append history due to unexpected error", err.message);
+                        }
+                        else {
+                            throw err;
+                        }
                     }
                 }
+                if (__classPrivateFieldGet(this, _AllureReport_publishedRemoteHrefs, "f").size > 0) {
+                    console.info("Next reports have been published:");
+                    __classPrivateFieldGet(this, _AllureReport_publishedRemoteHrefs, "f").forEach((href) => {
+                        console.info(`- ${href}`);
+                    });
+                }
+                if (!__classPrivateFieldGet(this, _AllureReport_qualityGate, "f")) {
+                    return;
+                }
+                const qualityGateResults = await __classPrivateFieldGet(this, _AllureReport_store, "f").qualityGateResultsByEnv();
+                await writeFile(join(__classPrivateFieldGet(this, _AllureReport_output, "f"), "quality-gate.json"), JSON.stringify(qualityGateResults));
             }
-            if (!remoteCleanupFailed && remoteHrefs.size > 0) {
-                console.info("Next reports have been published:");
-                remoteHrefs.forEach((href) => {
-                    console.info(`- ${href}`);
-                });
-            }
-            if (!__classPrivateFieldGet(this, _AllureReport_qualityGate, "f")) {
-                return;
+            finally {
+                await __classPrivateFieldGet(this, _AllureReport_finishPerfMetrics, "f").call(this);
             }
-            const qualityGateResults = await __classPrivateFieldGet(this, _AllureReport_store, "f").qualityGateResultsByEnv();
-            await writeFile(join(__classPrivateFieldGet(this, _AllureReport_output, "f"), "quality-gate.json"), JSON.stringify(qualityGateResults));
         };
+        _AllureReport_finishGeneratePerfSpan.set(this, () => {
+            __classPrivateFieldGet(this, _AllureReport_endGeneratePerfSpan, "f")?.call(this);
+            __classPrivateFieldSet(this, _AllureReport_endGeneratePerfSpan, undefined, "f");
+        });
+        _AllureReport_finishPerfMetrics.set(this, async () => {
+            __classPrivateFieldGet(this, _AllureReport_finishGeneratePerfSpan, "f").call(this);
+            try {
+                await writePerfMetrics(__classPrivateFieldGet(this, _AllureReport_output, "f"));
+            }
+            catch (err) {
+                console.error("Failed to write Allure performance metrics", err);
+            }
+        });
         _AllureReport_eachPlugin.set(this, async (initState, consumer) => {
             if (initState) {
                 __classPrivateFieldSet(this, _AllureReport_state, {}, "f");
@@ -707,11 +825,12 @@ export class AllureReport {
                     publish: !!options?.publish,
                     allureVersion: version,
                     reportUuid: this.reportUuid,
-                    reportName: __classPrivateFieldGet(this, _AllureReport_reportName, "f"),
+                    reportName: this.reportName,
                     hideLabels: __classPrivateFieldGet(this, _AllureReport_hideLabels, "f"),
                     state: pluginState,
                     reportFiles: pluginFiles,
                     reportUrl: this.reportUrl,
+                    realTime: !!__classPrivateFieldGet(this, _AllureReport_realTime, "f"),
                     output: __classPrivateFieldGet(this, _AllureReport_output, "f"),
                     ci: __classPrivateFieldGet(this, _AllureReport_ci, "f"),
                     categories: __classPrivateFieldGet(this, _AllureReport_categories, "f"),
@@ -719,6 +838,7 @@ export class AllureReport {
                 };
                 try {
                     await consumer.call(this, plugin, pluginContext);
+                    this.reportUrl = pluginContext.reportUrl ?? this.reportUrl;
                     if (initState) {
                         __classPrivateFieldGet(this, _AllureReport_state, "f")[id] = pluginState;
                     }
@@ -728,14 +848,23 @@ 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;
-        if (allureServiceConfig?.accessToken) {
-            __classPrivateFieldSet(this, _AllureReport_allureServiceClient, new AllureServiceClient(allureServiceConfig), "f");
+        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, globalAttachments, } = opts;
+        const allureServiceAccessToken = allureService?.accessToken;
+        if (allureServiceAccessToken) {
+            const allureServiceClientConfig = {
+                ...allureService,
+                accessToken: allureServiceAccessToken,
+            };
+            __classPrivateFieldSet(this, _AllureReport_allureServiceClient, allureServiceAccessToken.startsWith("ato1.")
+                ? new AllureTestOpsClient(allureServiceClientConfig)
+                : allureServiceAccessToken.startsWith("ars1.")
+                    ? new AllureServiceClient(allureServiceClientConfig)
+                    : undefined, "f");
         }
         this.reportUuid = randomUUID();
         __classPrivateFieldSet(this, _AllureReport_ci, detect(), "f");
         const reportTitleSuffix = __classPrivateFieldGet(this, _AllureReport_ci, "f")?.pullRequestName ?? __classPrivateFieldGet(this, _AllureReport_ci, "f")?.jobRunName;
-        __classPrivateFieldSet(this, _AllureReport_reportName, [name, reportTitleSuffix].filter(Boolean).join(" – "), "f");
+        this.reportName = [name, reportTitleSuffix].filter(Boolean).join(" – ");
         __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");
@@ -789,8 +918,6 @@ export class AllureReport {
         return __classPrivateFieldGet(this, _AllureReport_realtimeChannel, "f").dispatcher;
     }
 }
-_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) {
+_AllureReport_ci = new WeakMap(), _AllureReport_store = new WeakMap(), _AllureReport_readers = new WeakMap(), _AllureReport_plugins = new WeakMap(), _AllureReport_reportFiles = new WeakMap(), _AllureReport_realtimeChannel = new WeakMap(), _AllureReport_realtimeUpdateScheduler = new WeakMap(), _AllureReport_realTime = new WeakMap(), _AllureReport_hideLabels = new WeakMap(), _AllureReport_output = new WeakMap(), _AllureReport_history = new WeakMap(), _AllureReport_allureServiceClient = new WeakMap(), _AllureReport_qualityGate = new WeakMap(), _AllureReport_dump = new WeakMap(), _AllureReport_categories = new WeakMap(), _AllureReport_environments = new WeakMap(), _AllureReport_globalAttachments = new WeakMap(), _AllureReport_dumpTempDirs = new WeakMap(), _AllureReport_state = new WeakMap(), _AllureReport_executionStage = new WeakMap(), _AllureReport_historyDataPoint = new WeakMap(), _AllureReport_summaryPath = new WeakMap(), _AllureReport_summariesByPluginId = new WeakMap(), _AllureReport_publishedRemoteHrefs = new WeakMap(), _AllureReport_published = new WeakMap(), _AllureReport_endGeneratePerfSpan = new WeakMap(), _AllureReport_publish = new WeakMap(), _AllureReport_runRealtimeUpdate = new WeakMap(), _AllureReport_getReportsToPublish = new WeakMap(), _AllureReport_cleanupFailedRemoteReport = new WeakMap(), _AllureReport_logPublishError = new WeakMap(), _AllureReport_applyPublishLinksToSummaries = new WeakMap(), _AllureReport_cloneSummariesByPluginId = new WeakMap(), _AllureReport_writeSummaryFiles = new WeakMap(), _AllureReport_generateRootSummary = new WeakMap(), _AllureReport_finishGeneratePerfSpan = new WeakMap(), _AllureReport_finishPerfMetrics = new WeakMap(), _AllureReport_eachPlugin = new WeakMap(), _AllureReport_instances = new WeakSet(), _AllureReport_getPluginState = function _AllureReport_getPluginState(init, id) {
     return init ? new DefaultPluginState({}) : __classPrivateFieldGet(this, _AllureReport_state, "f")?.[id];
 };