@allurereport/core 3.7.0 → 3.8.0

package/dist/config.js

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

package/dist/report.js

@@ -9,11 +9,10 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _AllureReport_instances, _AllureReport_reportName, _AllureReport_reportVariables, _AllureReport_ci, _AllureReport_store, _AllureReport_readers, _AllureReport_plugins, _AllureReport_reportFiles, _AllureReport_eventEmitter, _AllureReport_realtimeSubscriber, _AllureReport_realtimeDispatcher, _AllureReport_realTime, _AllureReport_hideLabels, _AllureReport_output, _AllureReport_history, _AllureReport_allureServiceClient, _AllureReport_qualityGate, _AllureReport_dump, _AllureReport_categories, _AllureReport_environments, _AllureReport_globalAttachments, _AllureReport_dumpTempDirs, _AllureReport_state, _AllureReport_executionStage, _AllureReport_publish_get, _AllureReport_update, _AllureReport_eachPlugin, _AllureReport_getPluginState;
+var _AllureReport_instances, _AllureReport_reportName, _AllureReport_ci, _AllureReport_store, _AllureReport_readers, _AllureReport_plugins, _AllureReport_reportFiles, _AllureReport_realtimeChannel, _AllureReport_realtimeUpdateScheduler, _AllureReport_realTime, _AllureReport_hideLabels, _AllureReport_output, _AllureReport_history, _AllureReport_allureServiceClient, _AllureReport_qualityGate, _AllureReport_dump, _AllureReport_categories, _AllureReport_environments, _AllureReport_globalAttachments, _AllureReport_dumpTempDirs, _AllureReport_state, _AllureReport_executionStage, _AllureReport_publish_get, _AllureReport_runRealtimeUpdate, _AllureReport_eachPlugin, _AllureReport_getPluginState;
 import console from "node:console";
 import { randomUUID } from "node:crypto";
-import { EventEmitter } from "node:events";
-import { createReadStream, createWriteStream, existsSync, readFileSync } from "node:fs";
+import { createWriteStream, existsSync, readFileSync } from "node:fs";
 import { lstat, mkdtemp, opendir, readdir, realpath, rename, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { basename, dirname, join, resolve, sep } from "node:path";
@@ -35,7 +34,8 @@ import { DefaultPluginState, PluginFiles } from "./plugin.js";
 import { QualityGate } from "./qualityGate/index.js";
 import { DefaultAllureStore } from "./store/store.js";
 import { environmentIdentityById, environmentIdentityByName } from "./utils/environment.js";
-import { RealtimeEventsDispatcher, RealtimeSubscriber } from "./utils/event.js";
+import { RealtimeChannel } from "./utils/realtimeChannel.js";
+import { RealtimeUpdateScheduler } from "./utils/realtimeUpdateScheduler.js";
 import { resolveDumpAttachmentPath, UnsafeDumpPathError } from "./utils/safeDumpPath.js";
 const { version } = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
 const initRequired = "report is not initialised. Call the start() method first.";
@@ -48,15 +48,13 @@ export class AllureReport {
     constructor(opts) {
         _AllureReport_instances.add(this);
         _AllureReport_reportName.set(this, void 0);
-        _AllureReport_reportVariables.set(this, void 0);
         _AllureReport_ci.set(this, void 0);
         _AllureReport_store.set(this, void 0);
         _AllureReport_readers.set(this, void 0);
         _AllureReport_plugins.set(this, void 0);
         _AllureReport_reportFiles.set(this, void 0);
-        _AllureReport_eventEmitter.set(this, void 0);
-        _AllureReport_realtimeSubscriber.set(this, void 0);
-        _AllureReport_realtimeDispatcher.set(this, void 0);
+        _AllureReport_realtimeChannel.set(this, void 0);
+        _AllureReport_realtimeUpdateScheduler.set(this, void 0);
         _AllureReport_realTime.set(this, void 0);
         _AllureReport_hideLabels.set(this, void 0);
         _AllureReport_output.set(this, void 0);
@@ -150,7 +148,7 @@ export class AllureReport {
                         continue;
                     }
                     const originalFileName = basename(absoluteFilePath);
-                    __classPrivateFieldGet(this, _AllureReport_realtimeDispatcher, "f").sendGlobalAttachment(new PathResultFile(absoluteFilePath, originalFileName), originalFileName);
+                    __classPrivateFieldGet(this, _AllureReport_realtimeChannel, "f").dispatcher.sendGlobalAttachment(new PathResultFile(absoluteFilePath, originalFileName), originalFileName);
                 }
             }
             if (__classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f") && __classPrivateFieldGet(this, _AllureReport_instances, "a", _AllureReport_publish_get)) {
@@ -162,16 +160,16 @@ export class AllureReport {
                 this.reportUrl = url.href;
             }
             await __classPrivateFieldGet(this, _AllureReport_eachPlugin, "f").call(this, true, async (plugin, context) => {
-                await plugin.start?.(context, __classPrivateFieldGet(this, _AllureReport_store, "f"), __classPrivateFieldGet(this, _AllureReport_realtimeSubscriber, "f"));
+                await plugin.start?.(context, __classPrivateFieldGet(this, _AllureReport_store, "f"), __classPrivateFieldGet(this, _AllureReport_realtimeChannel, "f").subscriber);
             });
             if (__classPrivateFieldGet(this, _AllureReport_realTime, "f")) {
-                await __classPrivateFieldGet(this, _AllureReport_update, "f").call(this);
-                __classPrivateFieldGet(this, _AllureReport_realtimeSubscriber, "f").onAll(async () => {
-                    await __classPrivateFieldGet(this, _AllureReport_update, "f").call(this);
+                await __classPrivateFieldGet(this, _AllureReport_runRealtimeUpdate, "f").call(this);
+                __classPrivateFieldGet(this, _AllureReport_realtimeChannel, "f").onResultLikeChanged(() => {
+                    __classPrivateFieldGet(this, _AllureReport_realtimeUpdateScheduler, "f").request();
                 });
             }
         };
-        _AllureReport_update.set(this, async () => {
+        _AllureReport_runRealtimeUpdate.set(this, async () => {
             if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") !== "running") {
                 return;
             }
@@ -180,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) {
@@ -268,88 +305,121 @@ 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 () => {
@@ -363,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();
@@ -586,7 +662,7 @@ export class AllureReport {
             if (allureServiceConfig?.legacy) {
                 __classPrivateFieldSet(this, _AllureReport_allureServiceClient, new AllureLegacyServiceClient(allureServiceConfig), "f");
             }
-            else if (allureServiceConfig?.url) {
+            else {
                 __classPrivateFieldSet(this, _AllureReport_allureServiceClient, new AllureServiceClient(allureServiceConfig), "f");
             }
         }
@@ -594,10 +670,8 @@ export class AllureReport {
         __classPrivateFieldSet(this, _AllureReport_ci, detect(), "f");
         const reportTitleSuffix = __classPrivateFieldGet(this, _AllureReport_ci, "f")?.pullRequestName ?? __classPrivateFieldGet(this, _AllureReport_ci, "f")?.jobRunName;
         __classPrivateFieldSet(this, _AllureReport_reportName, [name, reportTitleSuffix].filter(Boolean).join(" – "), "f");
-        __classPrivateFieldSet(this, _AllureReport_reportVariables, variables, "f");
-        __classPrivateFieldSet(this, _AllureReport_eventEmitter, new EventEmitter(), "f");
-        __classPrivateFieldSet(this, _AllureReport_realtimeDispatcher, new RealtimeEventsDispatcher(__classPrivateFieldGet(this, _AllureReport_eventEmitter, "f")), "f");
-        __classPrivateFieldSet(this, _AllureReport_realtimeSubscriber, new RealtimeSubscriber(__classPrivateFieldGet(this, _AllureReport_eventEmitter, "f")), "f");
+        __classPrivateFieldSet(this, _AllureReport_realtimeChannel, new RealtimeChannel(), "f");
+        __classPrivateFieldSet(this, _AllureReport_realtimeUpdateScheduler, new RealtimeUpdateScheduler(__classPrivateFieldGet(this, _AllureReport_runRealtimeUpdate, "f")), "f");
         __classPrivateFieldSet(this, _AllureReport_realTime, realTime, "f");
         __classPrivateFieldSet(this, _AllureReport_dump, dump, "f");
         __classPrivateFieldSet(this, _AllureReport_hideLabels, hideLabels, "f");
@@ -621,8 +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"),
@@ -643,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];

package/dist/store/store.d.ts

@@ -1,4 +1,4 @@
-import { type AllureHistory, type AttachmentLink, type DefaultLabelsConfig, type EnvironmentIdentity, type EnvironmentsConfig, type HistoryDataPoint, type HistoryTestResult, type KnownTestFailure, type ReportVariables, type Statistic, type TestCase, type TestEnvGroup, type TestError, type TestFixtureResult, type TestResult } from "@allurereport/core-api";
+import { type AllureCheckResult, type AllureHistory, type AttachmentLink, type DefaultLabelsConfig, type EnvironmentIdentity, type EnvironmentsConfig, type HistoryDataPoint, type HistoryTestResult, type KnownTestFailure, type ReportVariables, type Statistic, type TestCase, type TestEnvGroup, type TestError, type TestFixtureResult, type TestResult } from "@allurereport/core-api";
 import { type AllureStore, type AllureStoreDump, type ExitCode, type PluginGlobalAttachment, type PluginGlobalError, type QualityGateValidationResult, type RealtimeEventsDispatcher, type RealtimeSubscriber, type ResultFile, type TestResultFilter } from "@allurereport/plugin-api";
 import type { RawFixtureResult, RawGlobals, RawMetadata, RawTestResult, ReaderContext, ResultsVisitor } from "@allurereport/reader-api";
 export declare const mapToObject: <K extends string | number | symbol, T = any>(map: Map<K, T>) => Record<K, T>;
@@ -26,6 +26,8 @@ export declare class DefaultAllureStore implements AllureStore, ResultsVisitor {
     });
     readHistory(): Promise<HistoryDataPoint[]>;
     appendHistory(history: HistoryDataPoint): Promise<void>;
+    addCheckResult(result: AllureCheckResult): Promise<void>;
+    allCheckResults(): Promise<AllureCheckResult[]>;
     qualityGateResults(): Promise<QualityGateValidationResult[]>;
     qualityGateResultsByEnv(): Promise<Record<string, QualityGateValidationResult[]>>;
     qualityGateResultsByEnvironmentId(): Promise<Record<string, QualityGateValidationResult[]>>;
@@ -34,6 +36,7 @@ export declare class DefaultAllureStore implements AllureStore, ResultsVisitor {
     allGlobalErrorsByEnv(): Promise<Record<string, PluginGlobalError[]>>;
     allGlobalAttachments(): Promise<AttachmentLink[]>;
     allGlobalAttachmentsByEnv(): Promise<Record<string, PluginGlobalAttachment[]>>;
+    visitCheckResult(result: AllureCheckResult): Promise<void>;
     visitTestResult(raw: RawTestResult, context: ReaderContext): Promise<void>;
     visitTestFixtureResult(result: RawFixtureResult, context: ReaderContext): Promise<void>;
     visitAttachmentFile(resultFile: ResultFile): Promise<void>;
@@ -59,6 +62,7 @@ export declare class DefaultAllureStore implements AllureStore, ResultsVisitor {
     testResultById(trId: string): Promise<TestResult | undefined>;
     attachmentById(attachmentId: string): Promise<AttachmentLink | undefined>;
     attachmentContentById(attachmentId: string): Promise<ResultFile | undefined>;
+    markAttachmentMissed(attachmentId: string): void;
     metadataByKey<T>(key: string): Promise<T | undefined>;
     testResultsByTcId(tcId: string): Promise<TestResult[]>;
     environmentIdByTrId(trId: string): Promise<string | undefined>;

package/dist/store/store.js

@@ -9,7 +9,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _DefaultAllureStore_instances, _DefaultAllureStore_testResults, _DefaultAllureStore_environmentDisplayNames, _DefaultAllureStore_environmentNameToId, _DefaultAllureStore_attachments, _DefaultAllureStore_attachmentContents, _DefaultAllureStore_testCases, _DefaultAllureStore_metadata, _DefaultAllureStore_history, _DefaultAllureStore_known, _DefaultAllureStore_fixtures, _DefaultAllureStore_defaultLabels, _DefaultAllureStore_environment, _DefaultAllureStore_environmentsConfig, _DefaultAllureStore_reportVariables, _DefaultAllureStore_realtimeDispatcher, _DefaultAllureStore_realtimeSubscriber, _DefaultAllureStore_allowedEnvironmentIds, _DefaultAllureStore_globalAttachmentIds, _DefaultAllureStore_globalAttachmentIdsByEnv, _DefaultAllureStore_globalErrors, _DefaultAllureStore_globalErrorsByEnv, _DefaultAllureStore_globalExitCode, _DefaultAllureStore_qualityGateResults, _DefaultAllureStore_historyPoints, _DefaultAllureStore_environments, _DefaultAllureStore_mergeEnvironmentIdentity, _DefaultAllureStore_environmentIdForLookup, _DefaultAllureStore_addEnvironments, _DefaultAllureStore_environmentIdByName, _DefaultAllureStore_setTestResultEnvironmentId, _DefaultAllureStore_assertAllowedEnvironmentId, _DefaultAllureStore_assertAllowedStoredEnvironment, _DefaultAllureStore_environmentIdByTestResult, _DefaultAllureStore_resolveGlobalEnvironmentIdentity, _DefaultAllureStore_globalAttachmentId, _DefaultAllureStore_indexGlobalError, _DefaultAllureStore_addGlobalError, _DefaultAllureStore_indexGlobalAttachment, _DefaultAllureStore_addGlobalAttachment;
+var _DefaultAllureStore_instances, _DefaultAllureStore_testResults, _DefaultAllureStore_environmentDisplayNames, _DefaultAllureStore_environmentNameToId, _DefaultAllureStore_attachments, _DefaultAllureStore_attachmentContents, _DefaultAllureStore_testCases, _DefaultAllureStore_metadata, _DefaultAllureStore_history, _DefaultAllureStore_known, _DefaultAllureStore_fixtures, _DefaultAllureStore_defaultLabels, _DefaultAllureStore_environment, _DefaultAllureStore_environmentsConfig, _DefaultAllureStore_reportVariables, _DefaultAllureStore_realtimeDispatcher, _DefaultAllureStore_realtimeSubscriber, _DefaultAllureStore_allowedEnvironmentIds, _DefaultAllureStore_globalAttachmentIds, _DefaultAllureStore_globalAttachmentIdsByEnv, _DefaultAllureStore_globalErrors, _DefaultAllureStore_globalErrorsByEnv, _DefaultAllureStore_globalExitCode, _DefaultAllureStore_checkResults, _DefaultAllureStore_qualityGateResults, _DefaultAllureStore_historyPoints, _DefaultAllureStore_environments, _DefaultAllureStore_mergeEnvironmentIdentity, _DefaultAllureStore_environmentIdForLookup, _DefaultAllureStore_addEnvironments, _DefaultAllureStore_environmentIdByName, _DefaultAllureStore_setTestResultEnvironmentId, _DefaultAllureStore_assertAllowedEnvironmentId, _DefaultAllureStore_assertAllowedStoredEnvironment, _DefaultAllureStore_environmentIdByTestResult, _DefaultAllureStore_resolveGlobalEnvironmentIdentity, _DefaultAllureStore_globalAttachmentId, _DefaultAllureStore_indexGlobalError, _DefaultAllureStore_addGlobalError, _DefaultAllureStore_indexGlobalAttachment, _DefaultAllureStore_addGlobalAttachment, _DefaultAllureStore_restoreAttachmentContent, _DefaultAllureStore_relinkRestoredAttachmentSteps;
 import { extname } from "node:path";
 import { DEFAULT_ENVIRONMENT, DEFAULT_ENVIRONMENT_IDENTITY, compareBy, createDictionary, getHistoryIdCandidates, getWorstStatus, nullsLast, ordinal, reverse, selectHistoryTestResults, validateEnvironmentId, validateEnvironmentName, } from "@allurereport/core-api";
 import { md5, } from "@allurereport/plugin-api";
@@ -64,6 +64,18 @@ export const updateMapWithRecord = (map, record) => {
     });
     return map;
 };
+const relinkAttachmentSteps = (steps = [], attachments) => {
+    steps.forEach((step) => {
+        if (step.type === "attachment") {
+            const restoredLink = attachments.get(step.link.id);
+            if (restoredLink && restoredLink.used) {
+                step.link = restoredLink;
+            }
+            return;
+        }
+        relinkAttachmentSteps(step.steps, attachments);
+    });
+};
 export class DefaultAllureStore {
     constructor(params) {
         _DefaultAllureStore_instances.add(this);
@@ -97,6 +109,7 @@ export class DefaultAllureStore {
         _DefaultAllureStore_globalErrors.set(this, []);
         _DefaultAllureStore_globalErrorsByEnv.set(this, new Map());
         _DefaultAllureStore_globalExitCode.set(this, void 0);
+        _DefaultAllureStore_checkResults.set(this, []);
         _DefaultAllureStore_qualityGateResults.set(this, []);
         _DefaultAllureStore_historyPoints.set(this, []);
         _DefaultAllureStore_environments.set(this, []);
@@ -135,7 +148,7 @@ export class DefaultAllureStore {
         __classPrivateFieldSet(this, _DefaultAllureStore_reportVariables, reportVariables, "f");
         __classPrivateFieldSet(this, _DefaultAllureStore_allowedEnvironmentIds, new Set(allowedEnvironments ?? []), "f");
         __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_addEnvironments).call(this, environments);
-        __classPrivateFieldGet(this, _DefaultAllureStore_realtimeSubscriber, "f")?.onQualityGateResults(async (results) => {
+        __classPrivateFieldGet(this, _DefaultAllureStore_realtimeSubscriber, "f")?.onQualityGateResults((results) => {
             __classPrivateFieldGet(this, _DefaultAllureStore_qualityGateResults, "f").push(...results);
             __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_addEnvironments).call(this, results
                 .map((result) => {
@@ -156,13 +169,13 @@ export class DefaultAllureStore {
             })
                 .filter(Boolean));
         });
-        __classPrivateFieldGet(this, _DefaultAllureStore_realtimeSubscriber, "f")?.onGlobalExitCode(async (exitCode) => {
+        __classPrivateFieldGet(this, _DefaultAllureStore_realtimeSubscriber, "f")?.onGlobalExitCode((exitCode) => {
             __classPrivateFieldSet(this, _DefaultAllureStore_globalExitCode, exitCode, "f");
         });
-        __classPrivateFieldGet(this, _DefaultAllureStore_realtimeSubscriber, "f")?.onGlobalError(async (error) => {
+        __classPrivateFieldGet(this, _DefaultAllureStore_realtimeSubscriber, "f")?.onGlobalError((error) => {
             __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_addGlobalError).call(this, error);
         });
-        __classPrivateFieldGet(this, _DefaultAllureStore_realtimeSubscriber, "f")?.onGlobalAttachment(async ({ attachment, fileName, environment }) => {
+        __classPrivateFieldGet(this, _DefaultAllureStore_realtimeSubscriber, "f")?.onGlobalAttachment(({ attachment, fileName, environment }) => {
             const originalFileName = attachment.getOriginalFileName();
             const resolvedEnvironment = __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_resolveGlobalEnvironmentIdentity).call(this, environment);
             const attachmentLink = {
@@ -194,6 +207,24 @@ export class DefaultAllureStore {
         __classPrivateFieldGet(this, _DefaultAllureStore_historyPoints, "f").push(history);
         await __classPrivateFieldGet(this, _DefaultAllureStore_history, "f").appendHistory(history);
     }
+    async addCheckResult(result) {
+        __classPrivateFieldGet(this, _DefaultAllureStore_checkResults, "f").push({
+            name: result.name,
+            status: result.status,
+            ...(result.tags?.length ? { tags: [...result.tags] } : {}),
+            details: {
+                command: result.details.command,
+                ...(result.details.message ? { message: result.details.message } : {}),
+                ...(result.details.error ? { error: result.details.error } : {}),
+            },
+        });
+    }
+    async allCheckResults() {
+        return __classPrivateFieldGet(this, _DefaultAllureStore_checkResults, "f").map((result) => ({
+            ...result,
+            ...(result.tags ? { tags: [...result.tags] } : {}),
+        }));
+    }
     async qualityGateResults() {
         return [...__classPrivateFieldGet(this, _DefaultAllureStore_qualityGateResults, "f")];
     }
@@ -264,6 +295,9 @@ export class DefaultAllureStore {
         });
         return result;
     }
+    async visitCheckResult(result) {
+        await this.addCheckResult(result);
+    }
     async visitTestResult(raw, context) {
         const attachmentLinks = [];
         const testResult = testResultRawToState({
@@ -520,6 +554,17 @@ export class DefaultAllureStore {
     async attachmentContentById(attachmentId) {
         return __classPrivateFieldGet(this, _DefaultAllureStore_attachmentContents, "f").get(attachmentId);
     }
+    markAttachmentMissed(attachmentId) {
+        const attachment = __classPrivateFieldGet(this, _DefaultAllureStore_attachments, "f").get(attachmentId);
+        if (!attachment) {
+            return;
+        }
+        const missedAttachment = attachment;
+        missedAttachment.missed = true;
+        delete missedAttachment.contentLength;
+        __classPrivateFieldGet(this, _DefaultAllureStore_attachmentContents, "f").delete(attachmentId);
+        __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_relinkRestoredAttachmentSteps).call(this);
+    }
     async metadataByKey(key) {
         return __classPrivateFieldGet(this, _DefaultAllureStore_metadata, "f").get(key);
     }
@@ -749,6 +794,10 @@ export class DefaultAllureStore {
             reportVariables: __classPrivateFieldGet(this, _DefaultAllureStore_reportVariables, "f"),
             globalAttachmentIds: __classPrivateFieldGet(this, _DefaultAllureStore_globalAttachmentIds, "f"),
             globalErrors: __classPrivateFieldGet(this, _DefaultAllureStore_globalErrors, "f"),
+            checkResults: __classPrivateFieldGet(this, _DefaultAllureStore_checkResults, "f").map((result) => ({
+                ...result,
+                ...(result.tags ? { tags: [...result.tags] } : {}),
+            })),
             indexLatestEnvTestResultByHistoryId: {},
             indexAttachmentByTestResult: {},
             indexTestResultByHistoryId: {},
@@ -787,7 +836,7 @@ export class DefaultAllureStore {
         return storeDump;
     }
     async restoreState(stateDump, attachmentsContents = {}) {
-        const { testResults, attachments, testCases, fixtures, reportVariables, environments, globalAttachmentIds = [], globalErrors = [], indexAttachmentByTestResult = {}, indexTestResultByHistoryId = {}, indexTestResultByTestCase = {}, indexLatestEnvTestResultByHistoryId = {}, indexAttachmentByFixture = {}, indexFixturesByTestResult = {}, indexKnownByHistoryId = {}, qualityGateResults = [], } = stateDump;
+        const { testResults, attachments, testCases, fixtures, reportVariables, environments, globalAttachmentIds = [], globalErrors = [], checkResults = [], indexAttachmentByTestResult = {}, indexTestResultByHistoryId = {}, indexTestResultByTestCase = {}, indexLatestEnvTestResultByHistoryId = {}, indexAttachmentByFixture = {}, indexFixturesByTestResult = {}, indexKnownByHistoryId = {}, qualityGateResults = [], } = stateDump;
         const storedEnvironmentAliases = environments.flatMap((environmentValue) => {
             if (typeof environmentValue === "string") {
                 return [{ id: environmentValue, name: environmentValue }];
@@ -846,7 +895,10 @@ export class DefaultAllureStore {
         updateMapWithRecord(__classPrivateFieldGet(this, _DefaultAllureStore_attachments, "f"), attachments);
         updateMapWithRecord(__classPrivateFieldGet(this, _DefaultAllureStore_testCases, "f"), testCases);
         updateMapWithRecord(__classPrivateFieldGet(this, _DefaultAllureStore_fixtures, "f"), fixtures);
-        updateMapWithRecord(__classPrivateFieldGet(this, _DefaultAllureStore_attachmentContents, "f"), attachmentsContents);
+        Object.entries(attachmentsContents).forEach(([id, content]) => {
+            __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_restoreAttachmentContent).call(this, id, content);
+        });
+        __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_relinkRestoredAttachmentSteps).call(this);
         globalAttachmentIds.forEach((id) => {
             const attachment = __classPrivateFieldGet(this, _DefaultAllureStore_attachments, "f").get(id);
             if (!attachment) {
@@ -870,6 +922,18 @@ export class DefaultAllureStore {
             });
             __classPrivateFieldGet(this, _DefaultAllureStore_globalErrors, "f").push(__classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_indexGlobalError).call(this, error));
         });
+        checkResults.forEach((result) => {
+            __classPrivateFieldGet(this, _DefaultAllureStore_checkResults, "f").push({
+                name: result.name,
+                status: result.status,
+                ...(result.tags?.length ? { tags: [...result.tags] } : {}),
+                details: {
+                    command: result.details?.command ?? "",
+                    ...(result.details?.message ? { message: result.details.message } : {}),
+                    ...(result.details?.error ? { error: result.details.error } : {}),
+                },
+            });
+        });
         Object.assign(__classPrivateFieldGet(this, _DefaultAllureStore_reportVariables, "f"), reportVariables);
         Object.entries(indexAttachmentByTestResult).forEach(([trId, links]) => {
             const attachmentsLinks = links.map((id) => __classPrivateFieldGet(this, _DefaultAllureStore_attachments, "f").get(id)).filter(Boolean);
@@ -1000,7 +1064,7 @@ export class DefaultAllureStore {
         });
     }
 }
-_DefaultAllureStore_testResults = new WeakMap(), _DefaultAllureStore_environmentDisplayNames = new WeakMap(), _DefaultAllureStore_environmentNameToId = new WeakMap(), _DefaultAllureStore_attachments = new WeakMap(), _DefaultAllureStore_attachmentContents = new WeakMap(), _DefaultAllureStore_testCases = new WeakMap(), _DefaultAllureStore_metadata = new WeakMap(), _DefaultAllureStore_history = new WeakMap(), _DefaultAllureStore_known = new WeakMap(), _DefaultAllureStore_fixtures = new WeakMap(), _DefaultAllureStore_defaultLabels = new WeakMap(), _DefaultAllureStore_environment = new WeakMap(), _DefaultAllureStore_environmentsConfig = new WeakMap(), _DefaultAllureStore_reportVariables = new WeakMap(), _DefaultAllureStore_realtimeDispatcher = new WeakMap(), _DefaultAllureStore_realtimeSubscriber = new WeakMap(), _DefaultAllureStore_allowedEnvironmentIds = new WeakMap(), _DefaultAllureStore_globalAttachmentIds = new WeakMap(), _DefaultAllureStore_globalAttachmentIdsByEnv = new WeakMap(), _DefaultAllureStore_globalErrors = new WeakMap(), _DefaultAllureStore_globalErrorsByEnv = new WeakMap(), _DefaultAllureStore_globalExitCode = new WeakMap(), _DefaultAllureStore_qualityGateResults = new WeakMap(), _DefaultAllureStore_historyPoints = new WeakMap(), _DefaultAllureStore_environments = new WeakMap(), _DefaultAllureStore_instances = new WeakSet(), _DefaultAllureStore_mergeEnvironmentIdentity = function _DefaultAllureStore_mergeEnvironmentIdentity(existingEnvironment, incomingEnvironment) {
+_DefaultAllureStore_testResults = new WeakMap(), _DefaultAllureStore_environmentDisplayNames = new WeakMap(), _DefaultAllureStore_environmentNameToId = new WeakMap(), _DefaultAllureStore_attachments = new WeakMap(), _DefaultAllureStore_attachmentContents = new WeakMap(), _DefaultAllureStore_testCases = new WeakMap(), _DefaultAllureStore_metadata = new WeakMap(), _DefaultAllureStore_history = new WeakMap(), _DefaultAllureStore_known = new WeakMap(), _DefaultAllureStore_fixtures = new WeakMap(), _DefaultAllureStore_defaultLabels = new WeakMap(), _DefaultAllureStore_environment = new WeakMap(), _DefaultAllureStore_environmentsConfig = new WeakMap(), _DefaultAllureStore_reportVariables = new WeakMap(), _DefaultAllureStore_realtimeDispatcher = new WeakMap(), _DefaultAllureStore_realtimeSubscriber = new WeakMap(), _DefaultAllureStore_allowedEnvironmentIds = new WeakMap(), _DefaultAllureStore_globalAttachmentIds = new WeakMap(), _DefaultAllureStore_globalAttachmentIdsByEnv = new WeakMap(), _DefaultAllureStore_globalErrors = new WeakMap(), _DefaultAllureStore_globalErrorsByEnv = new WeakMap(), _DefaultAllureStore_globalExitCode = new WeakMap(), _DefaultAllureStore_checkResults = new WeakMap(), _DefaultAllureStore_qualityGateResults = new WeakMap(), _DefaultAllureStore_historyPoints = new WeakMap(), _DefaultAllureStore_environments = new WeakMap(), _DefaultAllureStore_instances = new WeakSet(), _DefaultAllureStore_mergeEnvironmentIdentity = function _DefaultAllureStore_mergeEnvironmentIdentity(existingEnvironment, incomingEnvironment) {
     const configuredEnvironment = environmentIdentityById(__classPrivateFieldGet(this, _DefaultAllureStore_environmentsConfig, "f"), incomingEnvironment.id);
     if (configuredEnvironment) {
         return configuredEnvironment;
@@ -1142,4 +1206,23 @@ _DefaultAllureStore_testResults = new WeakMap(), _DefaultAllureStore_environment
         __classPrivateFieldGet(this, _DefaultAllureStore_attachmentContents, "f").set(indexedAttachment.id, attachment);
     }
     __classPrivateFieldGet(this, _DefaultAllureStore_globalAttachmentIds, "f").push(indexedAttachment.id);
+}, _DefaultAllureStore_restoreAttachmentContent = function _DefaultAllureStore_restoreAttachmentContent(id, content) {
+    const attachment = __classPrivateFieldGet(this, _DefaultAllureStore_attachments, "f").get(id);
+    __classPrivateFieldGet(this, _DefaultAllureStore_attachmentContents, "f").set(id, content);
+    if (!attachment) {
+        return;
+    }
+    const linkedAttachment = attachment;
+    linkedAttachment.missed = false;
+    linkedAttachment.contentType = linkedAttachment.contentType ?? content.getContentType();
+    linkedAttachment.contentLength = content.getContentLength();
+    linkedAttachment.ext =
+        linkedAttachment.ext === undefined || linkedAttachment.ext === "" ? content.getExtension() : linkedAttachment.ext;
+}, _DefaultAllureStore_relinkRestoredAttachmentSteps = function _DefaultAllureStore_relinkRestoredAttachmentSteps() {
+    __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f").forEach(({ steps }) => {
+        relinkAttachmentSteps(steps, __classPrivateFieldGet(this, _DefaultAllureStore_attachments, "f"));
+    });
+    __classPrivateFieldGet(this, _DefaultAllureStore_fixtures, "f").forEach(({ steps }) => {
+        relinkAttachmentSteps(steps, __classPrivateFieldGet(this, _DefaultAllureStore_attachments, "f"));
+    });
 };

package/dist/utils/event.d.ts

@@ -1,5 +1,5 @@
-import type { EventEmitter } from "node:events";
-import type { BatchOptions, ExitCode, PluginGlobalError, QualityGateValidationResult, RealtimeEventsDispatcher as RealtimeEventsDispatcherType, RealtimeSubscriber as RealtimeSubscriberType, ResultFile } from "@allurereport/plugin-api";
+import { EventEmitter } from "node:events";
+import type { BatchOptions, ExitCode, PluginGlobalError, QualityGateValidationResult, RealtimeEventsDispatcher as RealtimeEventsDispatcherType, RealtimeListenerResult, RealtimeSubscriber as RealtimeSubscriberType, ResultFile } from "@allurereport/plugin-api";
 export declare enum RealtimeEvents {
     TestResult = "testResult",
     TestFixtureResult = "testFixtureResult",
@@ -40,13 +40,12 @@ export declare class RealtimeSubscriber implements RealtimeSubscriberType {
         attachment: ResultFile;
         fileName?: string;
         environment?: string;
-    }) => Promise<void>): () => void;
-    onGlobalExitCode(listener: (payload: ExitCode) => Promise<void>): () => void;
-    onGlobalError(listener: (error: PluginGlobalError) => Promise<void>): () => void;
-    onQualityGateResults(listener: (payload: QualityGateValidationResult[]) => Promise<void>): () => void;
-    onTestResults(listener: (trIds: string[]) => Promise<void>, options?: BatchOptions): () => void;
-    onTestFixtureResults(listener: (tfrIds: string[]) => Promise<void>, options?: BatchOptions): () => void;
-    onAttachmentFiles(listener: (afIds: string[]) => Promise<void>, options?: BatchOptions): () => void;
-    onAll(listener: () => Promise<void>, options?: BatchOptions): () => void;
+    }) => RealtimeListenerResult): () => void;
+    onGlobalExitCode(listener: (payload: ExitCode) => RealtimeListenerResult): () => void;
+    onGlobalError(listener: (error: PluginGlobalError) => RealtimeListenerResult): () => void;
+    onQualityGateResults(listener: (payload: QualityGateValidationResult[]) => RealtimeListenerResult): () => void;
+    onTestResults(listener: (trIds: string[]) => RealtimeListenerResult, options?: BatchOptions): () => void;
+    onTestFixtureResults(listener: (tfrIds: string[]) => RealtimeListenerResult, options?: BatchOptions): () => void;
+    onAttachmentFiles(listener: (afIds: string[]) => RealtimeListenerResult, options?: BatchOptions): () => void;
     offAll(): void;
 }

package/dist/utils/event.js

@@ -9,7 +9,7 @@ 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 _RealtimeEventsDispatcher_emitter, _RealtimeSubscriber_instances, _RealtimeSubscriber_emitter, _RealtimeSubscriber_handlers, _RealtimeSubscriber_createBatchHandler;
+var _RealtimeEventsDispatcher_emitter, _RealtimeSubscriber_instances, _RealtimeSubscriber_emitter, _RealtimeSubscriber_handlers, _RealtimeSubscriber_onEvent, _RealtimeSubscriber_onBatchedEvent, _RealtimeSubscriber_createBatchHandler, _RealtimeSubscriber_runBatchHandler, _RealtimeSubscriber_disposeBatchHandler;
 import console from "node:console";
 import { setTimeout } from "node:timers/promises";
 export var RealtimeEvents;
@@ -22,6 +22,20 @@ export var RealtimeEvents;
     RealtimeEvents["GlobalError"] = "globalError";
     RealtimeEvents["GlobalExitCode"] = "globalExitCode";
 })(RealtimeEvents || (RealtimeEvents = {}));
+const runListener = (listener, ...args) => {
+    try {
+        return Promise.resolve(listener(...args)).catch((err) => {
+            console.error("can't execute listener", err);
+        });
+    }
+    catch (err) {
+        console.error("can't execute listener", err);
+        return Promise.resolve();
+    }
+};
+const createListenerHandler = (listener) => (...args) => {
+    void runListener(listener, ...args);
+};
 export class RealtimeEventsDispatcher {
     constructor(emitter) {
         _RealtimeEventsDispatcher_emitter.set(this, void 0);
@@ -58,97 +72,95 @@ export class RealtimeSubscriber {
         __classPrivateFieldSet(this, _RealtimeSubscriber_emitter, emitter, "f");
     }
     onGlobalAttachment(listener) {
-        __classPrivateFieldGet(this, _RealtimeSubscriber_emitter, "f").on(RealtimeEvents.GlobalAttachment, listener);
-        return () => {
-            __classPrivateFieldGet(this, _RealtimeSubscriber_emitter, "f").off(RealtimeEvents.GlobalAttachment, listener);
-        };
+        return __classPrivateFieldGet(this, _RealtimeSubscriber_instances, "m", _RealtimeSubscriber_onEvent).call(this, RealtimeEvents.GlobalAttachment, listener);
     }
     onGlobalExitCode(listener) {
-        __classPrivateFieldGet(this, _RealtimeSubscriber_emitter, "f").on(RealtimeEvents.GlobalExitCode, listener);
-        return () => {
-            __classPrivateFieldGet(this, _RealtimeSubscriber_emitter, "f").off(RealtimeEvents.GlobalExitCode, listener);
-        };
+        return __classPrivateFieldGet(this, _RealtimeSubscriber_instances, "m", _RealtimeSubscriber_onEvent).call(this, RealtimeEvents.GlobalExitCode, listener);
     }
     onGlobalError(listener) {
-        __classPrivateFieldGet(this, _RealtimeSubscriber_emitter, "f").on(RealtimeEvents.GlobalError, listener);
-        return () => {
-            __classPrivateFieldGet(this, _RealtimeSubscriber_emitter, "f").off(RealtimeEvents.GlobalError, listener);
-        };
+        return __classPrivateFieldGet(this, _RealtimeSubscriber_instances, "m", _RealtimeSubscriber_onEvent).call(this, RealtimeEvents.GlobalError, listener);
     }
     onQualityGateResults(listener) {
-        __classPrivateFieldGet(this, _RealtimeSubscriber_emitter, "f").on(RealtimeEvents.QualityGateResults, listener);
-        return () => {
-            __classPrivateFieldGet(this, _RealtimeSubscriber_emitter, "f").off(RealtimeEvents.QualityGateResults, listener);
-        };
+        return __classPrivateFieldGet(this, _RealtimeSubscriber_instances, "m", _RealtimeSubscriber_onEvent).call(this, RealtimeEvents.QualityGateResults, listener);
     }
     onTestResults(listener, options = {}) {
-        const { maxTimeout = 100 } = options;
-        const handler = __classPrivateFieldGet(this, _RealtimeSubscriber_instances, "m", _RealtimeSubscriber_createBatchHandler).call(this, maxTimeout, listener);
-        __classPrivateFieldGet(this, _RealtimeSubscriber_emitter, "f").on(RealtimeEvents.TestResult, handler);
-        return () => {
-            __classPrivateFieldGet(this, _RealtimeSubscriber_emitter, "f").off(RealtimeEvents.TestResult, handler);
-        };
+        return __classPrivateFieldGet(this, _RealtimeSubscriber_instances, "m", _RealtimeSubscriber_onBatchedEvent).call(this, RealtimeEvents.TestResult, listener, options);
     }
     onTestFixtureResults(listener, options = {}) {
-        const { maxTimeout = 100 } = options;
-        const handler = __classPrivateFieldGet(this, _RealtimeSubscriber_instances, "m", _RealtimeSubscriber_createBatchHandler).call(this, maxTimeout, listener);
-        __classPrivateFieldGet(this, _RealtimeSubscriber_emitter, "f").on(RealtimeEvents.TestFixtureResult, handler);
-        return () => {
-            __classPrivateFieldGet(this, _RealtimeSubscriber_emitter, "f").off(RealtimeEvents.TestFixtureResult, handler);
-        };
+        return __classPrivateFieldGet(this, _RealtimeSubscriber_instances, "m", _RealtimeSubscriber_onBatchedEvent).call(this, RealtimeEvents.TestFixtureResult, listener, options);
     }
     onAttachmentFiles(listener, options = {}) {
-        const { maxTimeout = 100 } = options;
-        const handler = __classPrivateFieldGet(this, _RealtimeSubscriber_instances, "m", _RealtimeSubscriber_createBatchHandler).call(this, maxTimeout, listener);
-        __classPrivateFieldGet(this, _RealtimeSubscriber_emitter, "f").on(RealtimeEvents.AttachmentFile, handler);
-        return () => {
-            __classPrivateFieldGet(this, _RealtimeSubscriber_emitter, "f").off(RealtimeEvents.AttachmentFile, handler);
-        };
-    }
-    onAll(listener, options = {}) {
-        const { maxTimeout = 100 } = options;
-        const handler = __classPrivateFieldGet(this, _RealtimeSubscriber_instances, "m", _RealtimeSubscriber_createBatchHandler).call(this, maxTimeout, listener);
-        __classPrivateFieldGet(this, _RealtimeSubscriber_emitter, "f").on(RealtimeEvents.TestResult, handler);
-        __classPrivateFieldGet(this, _RealtimeSubscriber_emitter, "f").on(RealtimeEvents.TestFixtureResult, handler);
-        __classPrivateFieldGet(this, _RealtimeSubscriber_emitter, "f").on(RealtimeEvents.AttachmentFile, handler);
-        return () => {
-            __classPrivateFieldGet(this, _RealtimeSubscriber_emitter, "f").off(RealtimeEvents.TestResult, handler);
-            __classPrivateFieldGet(this, _RealtimeSubscriber_emitter, "f").off(RealtimeEvents.TestFixtureResult, handler);
-            __classPrivateFieldGet(this, _RealtimeSubscriber_emitter, "f").off(RealtimeEvents.AttachmentFile, handler);
-        };
+        return __classPrivateFieldGet(this, _RealtimeSubscriber_instances, "m", _RealtimeSubscriber_onBatchedEvent).call(this, RealtimeEvents.AttachmentFile, listener, options);
     }
     offAll() {
         __classPrivateFieldGet(this, _RealtimeSubscriber_emitter, "f").removeAllListeners();
         for (const handler of __classPrivateFieldGet(this, _RealtimeSubscriber_handlers, "f")) {
-            handler.ac?.abort();
+            __classPrivateFieldGet(this, _RealtimeSubscriber_instances, "m", _RealtimeSubscriber_disposeBatchHandler).call(this, handler);
         }
         __classPrivateFieldSet(this, _RealtimeSubscriber_handlers, [], "f");
     }
 }
-_RealtimeSubscriber_emitter = new WeakMap(), _RealtimeSubscriber_handlers = new WeakMap(), _RealtimeSubscriber_instances = new WeakSet(), _RealtimeSubscriber_createBatchHandler = function _RealtimeSubscriber_createBatchHandler(maxTimeout, listener) {
+_RealtimeSubscriber_emitter = new WeakMap(), _RealtimeSubscriber_handlers = new WeakMap(), _RealtimeSubscriber_instances = new WeakSet(), _RealtimeSubscriber_onEvent = function _RealtimeSubscriber_onEvent(event, listener) {
+    const handler = createListenerHandler(listener);
+    __classPrivateFieldGet(this, _RealtimeSubscriber_emitter, "f").on(event, handler);
+    return () => {
+        __classPrivateFieldGet(this, _RealtimeSubscriber_emitter, "f").off(event, handler);
+    };
+}, _RealtimeSubscriber_onBatchedEvent = function _RealtimeSubscriber_onBatchedEvent(event, listener, options) {
+    const { maxTimeout = 100 } = options;
+    const { dispose, eventHandler } = __classPrivateFieldGet(this, _RealtimeSubscriber_instances, "m", _RealtimeSubscriber_createBatchHandler).call(this, maxTimeout, listener);
+    __classPrivateFieldGet(this, _RealtimeSubscriber_emitter, "f").on(event, eventHandler);
+    return () => {
+        __classPrivateFieldGet(this, _RealtimeSubscriber_emitter, "f").off(event, eventHandler);
+        dispose();
+    };
+}, _RealtimeSubscriber_createBatchHandler = function _RealtimeSubscriber_createBatchHandler(maxTimeout, listener) {
     const handler = {
         buffer: [],
+        closed: false,
     };
     __classPrivateFieldGet(this, _RealtimeSubscriber_handlers, "f").push(handler);
-    return (trId) => {
+    const eventHandler = (trId) => {
+        if (handler.closed) {
+            return;
+        }
         handler.buffer.push(trId);
-        if (handler.timeout) {
+        if (handler.cycle) {
             return;
         }
-        handler.ac = new AbortController();
-        handler.timeout = setTimeout(maxTimeout, undefined, { signal: handler.ac.signal })
-            .then(() => {
-            handler.timeout = undefined;
+        handler.cycle = __classPrivateFieldGet(this, _RealtimeSubscriber_instances, "m", _RealtimeSubscriber_runBatchHandler).call(this, handler, maxTimeout, listener);
+    };
+    return {
+        dispose: () => __classPrivateFieldGet(this, _RealtimeSubscriber_instances, "m", _RealtimeSubscriber_disposeBatchHandler).call(this, handler),
+        eventHandler,
+    };
+}, _RealtimeSubscriber_runBatchHandler = async function _RealtimeSubscriber_runBatchHandler(handler, maxTimeout, listener) {
+    try {
+        while (!handler.closed && handler.buffer.length > 0) {
+            handler.abortController = new AbortController();
+            await setTimeout(maxTimeout, undefined, { signal: handler.abortController.signal });
+            handler.abortController = undefined;
             const bufferCopy = [...handler.buffer];
             handler.buffer = [];
-            handler.ac = undefined;
-            return listener(bufferCopy);
-        })
-            .catch((err) => {
-            if (err.name === "AbortError") {
-                return;
-            }
-            console.error("can't execute listener", err);
-        });
-    };
+            await runListener(listener, bufferCopy);
+        }
+    }
+    catch (err) {
+        if (err.name === "AbortError") {
+            return;
+        }
+        handler.buffer = [];
+        console.error("can't execute listener", err);
+    }
+    finally {
+        handler.abortController = undefined;
+        handler.cycle = undefined;
+    }
+}, _RealtimeSubscriber_disposeBatchHandler = function _RealtimeSubscriber_disposeBatchHandler(handler) {
+    handler.closed = true;
+    handler.abortController?.abort();
+    handler.abortController = undefined;
+    handler.buffer = [];
+    handler.cycle = undefined;
+    __classPrivateFieldSet(this, _RealtimeSubscriber_handlers, __classPrivateFieldGet(this, _RealtimeSubscriber_handlers, "f").filter((registeredHandler) => registeredHandler !== handler), "f");
 };

package/dist/utils/realtimeChannel.d.ts

@@ -0,0 +1,8 @@
+import { RealtimeEventsDispatcher, RealtimeSubscriber } from "./event.js";
+export declare class RealtimeChannel {
+    #private;
+    readonly dispatcher: RealtimeEventsDispatcher;
+    readonly subscriber: RealtimeSubscriber;
+    onResultLikeChanged(listener: () => void): () => void;
+    close(): void;
+}

package/dist/utils/realtimeChannel.js

@@ -0,0 +1,29 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    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 _RealtimeChannel_emitter;
+import { EventEmitter } from "node:events";
+import { RealtimeEvents, RealtimeEventsDispatcher, RealtimeSubscriber } from "./event.js";
+export class RealtimeChannel {
+    constructor() {
+        _RealtimeChannel_emitter.set(this, new EventEmitter());
+        this.dispatcher = new RealtimeEventsDispatcher(__classPrivateFieldGet(this, _RealtimeChannel_emitter, "f"));
+        this.subscriber = new RealtimeSubscriber(__classPrivateFieldGet(this, _RealtimeChannel_emitter, "f"));
+    }
+    onResultLikeChanged(listener) {
+        __classPrivateFieldGet(this, _RealtimeChannel_emitter, "f").on(RealtimeEvents.TestResult, listener);
+        __classPrivateFieldGet(this, _RealtimeChannel_emitter, "f").on(RealtimeEvents.TestFixtureResult, listener);
+        __classPrivateFieldGet(this, _RealtimeChannel_emitter, "f").on(RealtimeEvents.AttachmentFile, listener);
+        return () => {
+            __classPrivateFieldGet(this, _RealtimeChannel_emitter, "f").off(RealtimeEvents.TestResult, listener);
+            __classPrivateFieldGet(this, _RealtimeChannel_emitter, "f").off(RealtimeEvents.TestFixtureResult, listener);
+            __classPrivateFieldGet(this, _RealtimeChannel_emitter, "f").off(RealtimeEvents.AttachmentFile, listener);
+        };
+    }
+    close() {
+        this.subscriber.offAll();
+    }
+}
+_RealtimeChannel_emitter = new WeakMap();

package/dist/utils/realtimeUpdateScheduler.d.ts

@@ -0,0 +1,10 @@
+export interface RealtimeUpdateSchedulerOptions {
+    cooldownMs?: number;
+}
+export declare class RealtimeUpdateScheduler {
+    #private;
+    constructor(worker: () => Promise<void>, options?: RealtimeUpdateSchedulerOptions);
+    request(): void;
+    flush(): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/utils/realtimeUpdateScheduler.js

@@ -0,0 +1,81 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    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 _RealtimeUpdateScheduler_instances, _RealtimeUpdateScheduler_worker, _RealtimeUpdateScheduler_cooldownMs, _RealtimeUpdateScheduler_closed, _RealtimeUpdateScheduler_dirty, _RealtimeUpdateScheduler_phase, _RealtimeUpdateScheduler_cycle, _RealtimeUpdateScheduler_failed, _RealtimeUpdateScheduler_failure, _RealtimeUpdateScheduler_startCycle, _RealtimeUpdateScheduler_runCycle;
+import { setTimeout } from "node:timers/promises";
+export class RealtimeUpdateScheduler {
+    constructor(worker, options = {}) {
+        _RealtimeUpdateScheduler_instances.add(this);
+        _RealtimeUpdateScheduler_worker.set(this, void 0);
+        _RealtimeUpdateScheduler_cooldownMs.set(this, void 0);
+        _RealtimeUpdateScheduler_closed.set(this, false);
+        _RealtimeUpdateScheduler_dirty.set(this, false);
+        _RealtimeUpdateScheduler_phase.set(this, "idle");
+        _RealtimeUpdateScheduler_cycle.set(this, void 0);
+        _RealtimeUpdateScheduler_failed.set(this, false);
+        _RealtimeUpdateScheduler_failure.set(this, void 0);
+        _RealtimeUpdateScheduler_runCycle.set(this, async () => {
+            do {
+                __classPrivateFieldSet(this, _RealtimeUpdateScheduler_phase, "scheduled", "f");
+                await setTimeout(__classPrivateFieldGet(this, _RealtimeUpdateScheduler_cooldownMs, "f"));
+                __classPrivateFieldSet(this, _RealtimeUpdateScheduler_phase, "running", "f");
+                __classPrivateFieldSet(this, _RealtimeUpdateScheduler_dirty, false, "f");
+                await __classPrivateFieldGet(this, _RealtimeUpdateScheduler_worker, "f").call(this);
+            } while (__classPrivateFieldGet(this, _RealtimeUpdateScheduler_dirty, "f"));
+        });
+        __classPrivateFieldSet(this, _RealtimeUpdateScheduler_worker, worker, "f");
+        __classPrivateFieldSet(this, _RealtimeUpdateScheduler_cooldownMs, options.cooldownMs ?? 100, "f");
+    }
+    request() {
+        if (__classPrivateFieldGet(this, _RealtimeUpdateScheduler_closed, "f")) {
+            return;
+        }
+        if (__classPrivateFieldGet(this, _RealtimeUpdateScheduler_phase, "f") === "running") {
+            __classPrivateFieldSet(this, _RealtimeUpdateScheduler_dirty, true, "f");
+            return;
+        }
+        if (__classPrivateFieldGet(this, _RealtimeUpdateScheduler_phase, "f") === "idle") {
+            __classPrivateFieldGet(this, _RealtimeUpdateScheduler_instances, "m", _RealtimeUpdateScheduler_startCycle).call(this);
+        }
+    }
+    async flush() {
+        await __classPrivateFieldGet(this, _RealtimeUpdateScheduler_cycle, "f");
+        if (__classPrivateFieldGet(this, _RealtimeUpdateScheduler_failed, "f")) {
+            throw __classPrivateFieldGet(this, _RealtimeUpdateScheduler_failure, "f");
+        }
+    }
+    async close() {
+        __classPrivateFieldSet(this, _RealtimeUpdateScheduler_closed, true, "f");
+        await this.flush();
+    }
+}
+_RealtimeUpdateScheduler_worker = new WeakMap(), _RealtimeUpdateScheduler_cooldownMs = new WeakMap(), _RealtimeUpdateScheduler_closed = new WeakMap(), _RealtimeUpdateScheduler_dirty = new WeakMap(), _RealtimeUpdateScheduler_phase = new WeakMap(), _RealtimeUpdateScheduler_cycle = new WeakMap(), _RealtimeUpdateScheduler_failed = new WeakMap(), _RealtimeUpdateScheduler_failure = new WeakMap(), _RealtimeUpdateScheduler_runCycle = new WeakMap(), _RealtimeUpdateScheduler_instances = new WeakSet(), _RealtimeUpdateScheduler_startCycle = function _RealtimeUpdateScheduler_startCycle() {
+    if (__classPrivateFieldGet(this, _RealtimeUpdateScheduler_phase, "f") !== "idle") {
+        return;
+    }
+    __classPrivateFieldSet(this, _RealtimeUpdateScheduler_failed, false, "f");
+    __classPrivateFieldSet(this, _RealtimeUpdateScheduler_failure, undefined, "f");
+    __classPrivateFieldSet(this, _RealtimeUpdateScheduler_dirty, false, "f");
+    const cycle = __classPrivateFieldGet(this, _RealtimeUpdateScheduler_runCycle, "f").call(this)
+        .catch((err) => {
+        __classPrivateFieldSet(this, _RealtimeUpdateScheduler_failed, true, "f");
+        __classPrivateFieldSet(this, _RealtimeUpdateScheduler_failure, err, "f");
+        throw err;
+    })
+        .finally(() => {
+        if (__classPrivateFieldGet(this, _RealtimeUpdateScheduler_cycle, "f") === cycle) {
+            __classPrivateFieldSet(this, _RealtimeUpdateScheduler_cycle, undefined, "f");
+            __classPrivateFieldSet(this, _RealtimeUpdateScheduler_phase, "idle", "f");
+        }
+    });
+    cycle.catch(() => { });
+    __classPrivateFieldSet(this, _RealtimeUpdateScheduler_cycle, cycle, "f");
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/core",
-  "version": "3.7.0",
+  "version": "3.8.0",
   "description": "Collection of generic Allure utilities used across the entire project",
   "keywords": [
     "allure"
@@ -25,25 +25,25 @@
     "lint:fix": "oxlint --import-plugin --fix src test features stories"
   },
   "dependencies": {
-    "@allurereport/ci": "3.7.0",
-    "@allurereport/core-api": "3.7.0",
-    "@allurereport/plugin-agent": "3.7.0",
-    "@allurereport/plugin-allure2": "3.7.0",
-    "@allurereport/plugin-api": "3.7.0",
-    "@allurereport/plugin-awesome": "3.7.0",
-    "@allurereport/plugin-classic": "3.7.0",
-    "@allurereport/plugin-csv": "3.7.0",
-    "@allurereport/plugin-dashboard": "3.7.0",
-    "@allurereport/plugin-jira": "3.7.0",
-    "@allurereport/plugin-log": "3.7.0",
-    "@allurereport/plugin-progress": "3.7.0",
-    "@allurereport/plugin-slack": "3.7.0",
-    "@allurereport/plugin-testops": "3.7.0",
-    "@allurereport/plugin-testplan": "3.7.0",
-    "@allurereport/reader": "3.7.0",
-    "@allurereport/reader-api": "3.7.0",
-    "@allurereport/service": "3.7.0",
-    "@allurereport/summary": "3.7.0",
+    "@allurereport/ci": "3.8.0",
+    "@allurereport/core-api": "3.8.0",
+    "@allurereport/plugin-agent": "3.8.0",
+    "@allurereport/plugin-allure2": "3.8.0",
+    "@allurereport/plugin-api": "3.8.0",
+    "@allurereport/plugin-awesome": "3.8.0",
+    "@allurereport/plugin-classic": "3.8.0",
+    "@allurereport/plugin-csv": "3.8.0",
+    "@allurereport/plugin-dashboard": "3.8.0",
+    "@allurereport/plugin-jira": "3.8.0",
+    "@allurereport/plugin-log": "3.8.0",
+    "@allurereport/plugin-progress": "3.8.0",
+    "@allurereport/plugin-slack": "3.8.0",
+    "@allurereport/plugin-testops": "3.8.0",
+    "@allurereport/plugin-testplan": "3.8.0",
+    "@allurereport/reader": "3.8.0",
+    "@allurereport/reader-api": "3.8.0",
+    "@allurereport/service": "3.8.0",
+    "@allurereport/summary": "3.8.0",
     "glob": "^13.0.6",
     "handlebars": "^4.7.9",
     "node-stream-zip": "^1.15.0",