@allurereport/core 3.1.0 → 3.3.1

package/dist/api.d.ts

@@ -1,4 +1,4 @@
-import type { DefaultLabelsConfig, EnvironmentsConfig, KnownTestFailure, ReportVariables } from "@allurereport/core-api";
+import type { CategoriesConfig, DefaultLabelsConfig, EnvironmentsConfig, KnownTestFailure, ReportVariables } from "@allurereport/core-api";
 import type { Plugin, QualityGateConfig, ReportFiles } from "@allurereport/plugin-api";
 import type { ResultsReader } from "@allurereport/reader-api";
 export interface PluginInstance {
@@ -16,7 +16,7 @@ export interface FullConfig {
     historyLimit?: number;
     knownIssuesPath: string;
     defaultLabels?: DefaultLabelsConfig;
-    stage?: string;
+    dump?: string;
     environment?: string;
     environments?: EnvironmentsConfig;
     variables?: ReportVariables;
@@ -27,6 +27,7 @@ export interface FullConfig {
     known?: KnownTestFailure[];
     realTime?: any;
     qualityGate?: QualityGateConfig;
+    categories?: CategoriesConfig;
     allureService?: {
         accessToken?: string;
     };

package/dist/config.js

@@ -61,6 +61,7 @@ export const validateConfig = (config) => {
         "appendHistory",
         "qualityGate",
         "allureService",
+        "categories",
     ];
     const unsupportedFields = Object.keys(config).filter((key) => !supportedFields.includes(key));
     return {
@@ -138,6 +139,7 @@ export const resolveConfig = async (config, override = {}) => {
         defaultLabels: config.defaultLabels ?? {},
         qualityGate: config.qualityGate,
         allureService: config.allureService,
+        categories: config.categories,
     };
 };
 export const readConfig = async (cwd = process.cwd(), configPath, override) => {

package/dist/history.d.ts

@@ -1,7 +1,7 @@
 import type { AllureHistory, HistoryDataPoint, TestCase, TestResult } from "@allurereport/core-api";
 export declare const createHistory: (reportUuid: string, reportName: string | undefined, testCases: TestCase[], testResults: TestResult[], remoteUrl?: string) => HistoryDataPoint;
-export declare const writeHistory: (historyPath: string, data: HistoryDataPoint) => Promise<void>;
 export declare class AllureLocalHistory implements AllureHistory {
+    #private;
     private readonly params;
     constructor(params: {
         historyPath: string;

package/dist/history.js

@@ -1,5 +1,20 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
+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 __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 _AllureLocalHistory_cachedHistory, _AllureLocalHistory_openFileToReadIfExists, _AllureLocalHistory_ensureFileOpenedToAppend, _AllureLocalHistory_findFirstEntryAddress, _AllureLocalHistory_throwUnexpectedReadError;
+import { once } from "node:events";
+import { mkdir, open } from "node:fs/promises";
+import path from "node:path";
+import readline from "node:readline/promises";
+import { pipeline } from "node:stream/promises";
 import { isFileNotFoundError } from "./utils/misc.js";
 const createHistoryItems = (testResults) => {
     return testResults
@@ -39,46 +54,143 @@ export const createHistory = (reportUuid, reportName = "Allure Report", testCase
         url: remoteUrl,
     };
 };
-export const writeHistory = async (historyPath, data) => {
-    const path = resolve(historyPath);
-    const parentDir = dirname(path);
-    await mkdir(parentDir, { recursive: true });
-    await writeFile(path, `${JSON.stringify(data)}\n`, { encoding: "utf-8", flag: "a+" });
-};
 export class AllureLocalHistory {
     constructor(params) {
         this.params = params;
+        _AllureLocalHistory_cachedHistory.set(this, []);
+        _AllureLocalHistory_openFileToReadIfExists.set(this, async (filePath) => {
+            try {
+                return await open(filePath, "r");
+            }
+            catch (e) {
+                if (isFileNotFoundError(e)) {
+                    return undefined;
+                }
+                throw e;
+            }
+        });
+        _AllureLocalHistory_ensureFileOpenedToAppend.set(this, async (filePath) => {
+            try {
+                return {
+                    file: await open(filePath, "r+"),
+                    exists: true,
+                };
+            }
+            catch (e) {
+                if (isFileNotFoundError(e)) {
+                    return {
+                        file: await open(filePath, "w"),
+                        exists: false,
+                    };
+                }
+                throw e;
+            }
+        });
+        _AllureLocalHistory_findFirstEntryAddress.set(this, async (jsonlFile, limit) => {
+            if (limit === undefined) {
+                return 0;
+            }
+            if (limit < 0) {
+                throw new Error(`Invalid history limit ${limit}. A history limit must be a positive integer number`);
+            }
+            const stat = await jsonlFile.stat();
+            let { size: position } = stat;
+            const { mtimeMs: originalMtime } = stat;
+            if (position === 0 || limit === 0) {
+                return position;
+            }
+            const buffer = Buffer.alloc(Buffer.poolSize);
+            while (position) {
+                const bytesToRead = Math.min(position, buffer.byteLength);
+                position -= bytesToRead;
+                const { bytesRead } = await jsonlFile.read({ buffer, length: bytesToRead, position });
+                if (bytesRead !== bytesToRead) {
+                    __classPrivateFieldGet(this, _AllureLocalHistory_throwUnexpectedReadError, "f").call(this, jsonlFile, originalMtime, bytesToRead, bytesRead);
+                }
+                for (let i = bytesToRead - 1; i >= 0; i--) {
+                    if (buffer[i] === 0x0a) {
+                        if (limit-- === 0) {
+                            return position + i + 1;
+                        }
+                    }
+                }
+            }
+            return 0;
+        });
+        _AllureLocalHistory_throwUnexpectedReadError.set(this, async (file, mtime, expectedBytes, actualBytes) => {
+            const { mtimeMs: currentMtime } = await file.stat();
+            if (currentMtime !== mtime) {
+                throw new Error("The history file was modified outside Allure. " +
+                    "Please, make sure the file doesn't change while Allure is running");
+            }
+            throw new Error(`Can't read the history file: the expected number of bytes to read ${expectedBytes} ` +
+                `doesn't match the actual number ${actualBytes}`);
+        });
     }
     async readHistory() {
-        const path = resolve(this.params.historyPath);
+        if (__classPrivateFieldGet(this, _AllureLocalHistory_cachedHistory, "f").length > 0) {
+            return __classPrivateFieldGet(this, _AllureLocalHistory_cachedHistory, "f");
+        }
+        const fullPath = path.resolve(this.params.historyPath);
+        const historyFile = await __classPrivateFieldGet(this, _AllureLocalHistory_openFileToReadIfExists, "f").call(this, fullPath);
+        if (historyFile === undefined) {
+            return [];
+        }
         try {
-            const historyPoints = (await readFile(path, { encoding: "utf-8" }))
-                .split("\n")
-                .filter((line) => line && line.trim() !== "")
-                .map((line) => JSON.parse(line));
-            if (this.params.limit) {
-                return historyPoints.slice(-this.params.limit);
-            }
-            return historyPoints;
+            const start = await __classPrivateFieldGet(this, _AllureLocalHistory_findFirstEntryAddress, "f").call(this, historyFile, this.params.limit);
+            const stream = historyFile.createReadStream({ start, encoding: "utf-8", autoClose: false });
+            const historyPoints = [];
+            const readlineInterface = readline
+                .createInterface({ input: stream, terminal: false, crlfDelay: Infinity })
+                .on("line", (line) => {
+                if (line && line.trim().length) {
+                    const historyEntry = JSON.parse(line);
+                    historyPoints.push(historyEntry);
+                }
+            });
+            await once(readlineInterface, "close");
+            __classPrivateFieldSet(this, _AllureLocalHistory_cachedHistory, historyPoints, "f");
+            return __classPrivateFieldGet(this, _AllureLocalHistory_cachedHistory, "f");
         }
-        catch (e) {
-            if (isFileNotFoundError(e)) {
-                return [];
-            }
-            throw e;
+        finally {
+            await historyFile.close();
         }
     }
     async appendHistory(data) {
-        const path = resolve(this.params.historyPath);
-        const parentDir = dirname(path);
+        const fullPath = path.resolve(this.params.historyPath);
+        const parentDir = path.dirname(fullPath);
+        const { limit } = this.params;
         await mkdir(parentDir, { recursive: true });
-        if (!this.params.limit) {
-            await writeFile(path, `${JSON.stringify(data)}\n`, { encoding: "utf-8", flag: "a+" });
-            return;
+        const { file: historyFile, exists: historyExists } = await __classPrivateFieldGet(this, _AllureLocalHistory_ensureFileOpenedToAppend, "f").call(this, fullPath);
+        try {
+            const dst = historyFile.createWriteStream({ encoding: "utf-8", start: 0, autoClose: false });
+            if (limit === 0 && historyExists) {
+                await historyFile.truncate(0);
+                return;
+            }
+            if (limit === 0 && !historyExists) {
+                return;
+            }
+            if (historyExists) {
+                const start = await __classPrivateFieldGet(this, _AllureLocalHistory_findFirstEntryAddress, "f").call(this, historyFile, limit ? limit - 1 : undefined);
+                const src = historyFile.createReadStream({ start, autoClose: false });
+                await pipeline(src, dst, { end: false });
+            }
+            const sources = [JSON.stringify(data), Buffer.from([0x0a])];
+            await pipeline(sources, dst);
+            if (historyExists) {
+                await historyFile.truncate(dst.bytesWritten);
+            }
+        }
+        finally {
+            await historyFile.close();
+            if (limit !== 0) {
+                __classPrivateFieldGet(this, _AllureLocalHistory_cachedHistory, "f").push(data);
+            }
+            if (limit) {
+                __classPrivateFieldGet(this, _AllureLocalHistory_cachedHistory, "f").splice(limit);
+            }
         }
-        const existingHistory = await this.readHistory();
-        const updatedHistory = [...existingHistory, data].slice(-this.params.limit);
-        const fileContent = updatedHistory.reduce((acc, point) => `${acc}${JSON.stringify(point)}\n`, "");
-        await writeFile(path, fileContent, "utf-8");
     }
 }
+_AllureLocalHistory_cachedHistory = new WeakMap(), _AllureLocalHistory_openFileToReadIfExists = new WeakMap(), _AllureLocalHistory_ensureFileOpenedToAppend = new WeakMap(), _AllureLocalHistory_findFirstEntryAddress = new WeakMap(), _AllureLocalHistory_throwUnexpectedReadError = new WeakMap();

package/dist/qualityGate/qualityGate.d.ts

@@ -1,4 +1,4 @@
-import type { KnownTestFailure, TestError, TestResult } from "@allurereport/core-api";
+import { type KnownTestFailure, type TestError, type TestResult } from "@allurereport/core-api";
 import type { QualityGateConfig, QualityGateValidationResult } from "@allurereport/plugin-api";
 export declare const stringifyQualityGateResults: (results: QualityGateValidationResult[]) => string;
 export declare const convertQualityGateResultsToTestErrors: (results: QualityGateValidationResult[]) => TestError[];
@@ -14,6 +14,7 @@ export declare class QualityGate {
         state?: QualityGateState;
         trs: TestResult[];
         knownIssues: KnownTestFailure[];
+        environment?: string;
     }): Promise<{
         fastFailed: boolean;
         results: QualityGateValidationResult[];

package/dist/qualityGate/qualityGate.js

@@ -4,6 +4,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _QualityGateState_state;
+import { DEFAULT_ENVIRONMENT } from "@allurereport/core-api";
 import { gray, red } from "yoctocolors";
 import { qualityGateDefaultRules } from "./rules.js";
 export const stringifyQualityGateResults = (results) => {
@@ -44,7 +45,7 @@ export class QualityGate {
         this.config = config;
     }
     async validate(payload) {
-        const { state, trs, knownIssues } = payload;
+        const { state, trs, knownIssues, environment } = payload;
         const { rules, use = [...qualityGateDefaultRules] } = this.config;
         const results = [];
         let fastFailed = false;
@@ -88,6 +89,7 @@ export class QualityGate {
                         actual: result.actual,
                         expected,
                     }),
+                    environment: environment || DEFAULT_ENVIRONMENT,
                 });
                 if (ruleset.fastFail) {
                     fastFailed = true;

package/dist/report.d.ts

@@ -20,12 +20,13 @@ export declare class AllureReport {
         trs: TestResult[];
         knownIssues: KnownTestFailure[];
         state?: QualityGateState;
+        environment?: string;
     }) => Promise<{
         fastFailed: boolean;
         results: import("@allurereport/plugin-api").QualityGateValidationResult[];
     }>;
     start: () => Promise<void>;
     dumpState: () => Promise<void>;
-    restoreState: (stages: string[]) => Promise<void>;
+    restoreState: (dumps: string[]) => Promise<void>;
     done: () => Promise<void>;
 }

package/dist/report.js

@@ -9,8 +9,9 @@ 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_output, _AllureReport_history, _AllureReport_allureServiceClient, _AllureReport_qualityGate, _AllureReport_stage, _AllureReport_stageTempDirs, _AllureReport_state, _AllureReport_executionStage, _AllureReport_publish_get, _AllureReport_update, _AllureReport_eachPlugin, _AllureReport_getPluginState;
+var _AllureReport_instances, _AllureReport_reportName, _AllureReport_reportVariables, _AllureReport_ci, _AllureReport_store, _AllureReport_readers, _AllureReport_plugins, _AllureReport_reportFiles, _AllureReport_eventEmitter, _AllureReport_realtimeSubscriber, _AllureReport_realtimeDispatcher, _AllureReport_realTime, _AllureReport_output, _AllureReport_history, _AllureReport_allureServiceClient, _AllureReport_qualityGate, _AllureReport_dump, _AllureReport_categories, _AllureReport_dumpTempDirs, _AllureReport_state, _AllureReport_executionStage, _AllureReport_publish_get, _AllureReport_update, _AllureReport_eachPlugin, _AllureReport_getPluginState;
 import { detect } from "@allurereport/ci";
+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";
@@ -53,8 +54,9 @@ export class AllureReport {
         _AllureReport_history.set(this, void 0);
         _AllureReport_allureServiceClient.set(this, void 0);
         _AllureReport_qualityGate.set(this, void 0);
-        _AllureReport_stage.set(this, void 0);
-        _AllureReport_stageTempDirs.set(this, []);
+        _AllureReport_dump.set(this, void 0);
+        _AllureReport_categories.set(this, void 0);
+        _AllureReport_dumpTempDirs.set(this, []);
         _AllureReport_state.set(this, void 0);
         _AllureReport_executionStage.set(this, "init");
         this.readDirectory = async (resultsDir) => {
@@ -99,11 +101,12 @@ export class AllureReport {
             }
         };
         this.validate = async (params) => {
-            const { trs, knownIssues, state } = params;
+            const { trs, knownIssues, state, environment } = params;
             return __classPrivateFieldGet(this, _AllureReport_qualityGate, "f").validate({
                 trs: trs.filter(Boolean),
                 knownIssues,
                 state,
+                environment,
             });
         };
         this.start = async () => {
@@ -143,13 +146,13 @@ export class AllureReport {
             });
         });
         this.dumpState = async () => {
-            const { testResults, testCases, fixtures, attachments: attachmentsLinks, environments, globalAttachments = [], globalErrors = [], indexAttachmentByTestResult = {}, indexTestResultByHistoryId = {}, indexTestResultByTestCase = {}, indexLatestEnvTestResultByHistoryId = {}, indexAttachmentByFixture = {}, indexFixturesByTestResult = {}, indexKnownByHistoryId = {}, qualityGateResultsByRules = {}, } = __classPrivateFieldGet(this, _AllureReport_store, "f").dumpState();
+            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_stage, "f")}.zip`);
+            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));
@@ -174,7 +177,7 @@ export class AllureReport {
             await addEntry(Buffer.from(JSON.stringify(__classPrivateFieldGet(this, _AllureReport_reportVariables, "f"))), {
                 name: AllureStoreDumpFiles.ReportVariables,
             });
-            await addEntry(Buffer.from(JSON.stringify(globalAttachments)), {
+            await addEntry(Buffer.from(JSON.stringify(globalAttachmentIds)), {
                 name: AllureStoreDumpFiles.GlobalAttachments,
             });
             await addEntry(Buffer.from(JSON.stringify(globalErrors)), {
@@ -201,8 +204,8 @@ export class AllureReport {
             await addEntry(Buffer.from(JSON.stringify(indexKnownByHistoryId)), {
                 name: AllureStoreDumpFiles.IndexKnownByHistoryId,
             });
-            await addEntry(Buffer.from(JSON.stringify(qualityGateResultsByRules)), {
-                name: AllureStoreDumpFiles.QualityGateResultsByRules,
+            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);
@@ -223,31 +226,31 @@ export class AllureReport {
             dumpArchive.finalize();
             return promise;
         };
-        this.restoreState = async (stages) => {
-            for (const stage of stages) {
-                if (!existsSync(stage)) {
+        this.restoreState = async (dumps) => {
+            for (const dump of dumps) {
+                if (!existsSync(dump)) {
                     continue;
                 }
-                const dump = new ZipReadStream.async({
-                    file: stage,
+                const dumpArchive = new ZipReadStream.async({
+                    file: dump,
                 });
-                const testResultsEntry = await dump.entryData(AllureStoreDumpFiles.TestResults);
-                const testCasesEntry = await dump.entryData(AllureStoreDumpFiles.TestCases);
-                const fixturesEntry = await dump.entryData(AllureStoreDumpFiles.Fixtures);
-                const attachmentsEntry = await dump.entryData(AllureStoreDumpFiles.Attachments);
-                const environmentsEntry = await dump.entryData(AllureStoreDumpFiles.Environments);
-                const reportVariablesEntry = await dump.entryData(AllureStoreDumpFiles.ReportVariables);
-                const globalAttachmentsEntry = await dump.entryData(AllureStoreDumpFiles.GlobalAttachments);
-                const globalErrorsEntry = await dump.entryData(AllureStoreDumpFiles.GlobalErrors);
-                const indexAttachmentsEntry = await dump.entryData(AllureStoreDumpFiles.IndexAttachmentsByTestResults);
-                const indexTestResultsByHistoryId = await dump.entryData(AllureStoreDumpFiles.IndexTestResultsByHistoryId);
-                const indexTestResultsByTestCaseEntry = await dump.entryData(AllureStoreDumpFiles.IndexTestResultsByTestCase);
-                const indexLatestEnvTestResultsByHistoryIdEntry = await dump.entryData(AllureStoreDumpFiles.IndexLatestEnvTestResultsByHistoryId);
-                const indexAttachmentsByFixtureEntry = await dump.entryData(AllureStoreDumpFiles.IndexAttachmentsByFixture);
-                const indexFixturesByTestResultEntry = await dump.entryData(AllureStoreDumpFiles.IndexFixturesByTestResult);
-                const indexKnownByHistoryIdEntry = await dump.entryData(AllureStoreDumpFiles.IndexKnownByHistoryId);
-                const qualityGateResultsByRulesEntry = await dump.entryData(AllureStoreDumpFiles.QualityGateResultsByRules);
-                const attachmentsEntries = Object.entries(await dump.entries()).reduce((acc, [entryName, entry]) => {
+                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:
@@ -264,7 +267,7 @@ export class AllureReport {
                         case AllureStoreDumpFiles.IndexAttachmentsByFixture:
                         case AllureStoreDumpFiles.IndexFixturesByTestResult:
                         case AllureStoreDumpFiles.IndexKnownByHistoryId:
-                        case AllureStoreDumpFiles.QualityGateResultsByRules:
+                        case AllureStoreDumpFiles.QualityGateResults:
                             return acc;
                         default:
                             return Object.assign(acc, {
@@ -279,7 +282,7 @@ export class AllureReport {
                     attachments: JSON.parse(attachmentsEntry.toString("utf8")),
                     environments: JSON.parse(environmentsEntry.toString("utf8")),
                     reportVariables: JSON.parse(reportVariablesEntry.toString("utf8")),
-                    globalAttachments: JSON.parse(globalAttachmentsEntry.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")),
@@ -288,25 +291,25 @@ export class AllureReport {
                     indexAttachmentByFixture: JSON.parse(indexAttachmentsByFixtureEntry.toString("utf8")),
                     indexFixturesByTestResult: JSON.parse(indexFixturesByTestResultEntry.toString("utf8")),
                     indexKnownByHistoryId: JSON.parse(indexKnownByHistoryIdEntry.toString("utf8")),
-                    qualityGateResultsByRules: JSON.parse(qualityGateResultsByRulesEntry.toString("utf8")),
+                    qualityGateResults: JSON.parse(qualityGateResultsEntry.toString("utf8")),
                 };
-                const stageTempDir = await mkdtemp(join(tmpdir(), basename(stage, ".zip")));
+                const dumpTempDir = await mkdtemp(join(tmpdir(), basename(dump, ".zip")));
                 const resultsAttachments = {};
-                __classPrivateFieldGet(this, _AllureReport_stageTempDirs, "f").push(stageTempDir);
+                __classPrivateFieldGet(this, _AllureReport_dumpTempDirs, "f").push(dumpTempDir);
                 try {
                     for (const [attachmentId] of Object.entries(attachmentsEntries)) {
-                        const attachmentContentEntry = await dump.entryData(attachmentId);
-                        const attachmentFilePath = join(stageTempDir, attachmentId);
+                        const attachmentContentEntry = await dumpArchive.entryData(attachmentId);
+                        const attachmentFilePath = join(dumpTempDir, attachmentId);
                         await writeFile(attachmentFilePath, attachmentContentEntry);
                         resultsAttachments[attachmentId] = new PathResultFile(attachmentFilePath, attachmentId);
                     }
                 }
                 catch (err) {
-                    console.error(`Can't restore state from "${stage}", continuing without it`);
+                    console.error(`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 "${stage}"`);
+                console.info(`Successfully restored state from "${dump}"`);
             }
         };
         this.done = async () => {
@@ -321,7 +324,7 @@ export class AllureReport {
             const historyDataPoint = createHistory(this.reportUuid, __classPrivateFieldGet(this, _AllureReport_reportName, "f"), testCases, testResults, this.reportUrl);
             __classPrivateFieldGet(this, _AllureReport_realtimeSubscriber, "f").offAll();
             __classPrivateFieldSet(this, _AllureReport_executionStage, "done", "f");
-            if (__classPrivateFieldGet(this, _AllureReport_stage, "f")) {
+            if (__classPrivateFieldGet(this, _AllureReport_dump, "f")) {
                 await this.dumpState();
                 return;
             }
@@ -429,7 +432,7 @@ export class AllureReport {
                 }
                 await rm(reportPath, { recursive: true });
             }
-            for (const dir of __classPrivateFieldGet(this, _AllureReport_stageTempDirs, "f")) {
+            for (const dir of __classPrivateFieldGet(this, _AllureReport_dumpTempDirs, "f")) {
                 try {
                     await rm(dir, { recursive: true });
                 }
@@ -460,7 +463,7 @@ export class AllureReport {
             if (!__classPrivateFieldGet(this, _AllureReport_qualityGate, "f")) {
                 return;
             }
-            const qualityGateResults = await __classPrivateFieldGet(this, _AllureReport_store, "f").qualityGateResults();
+            const qualityGateResults = await __classPrivateFieldGet(this, _AllureReport_store, "f").qualityGateResultsByEnv();
             await writeFile(join(__classPrivateFieldGet(this, _AllureReport_output, "f"), "quality-gate.json"), JSON.stringify(qualityGateResults));
         };
         _AllureReport_eachPlugin.set(this, async (initState, consumer) => {
@@ -498,6 +501,8 @@ export class AllureReport {
                     reportUrl: this.reportUrl,
                     output: __classPrivateFieldGet(this, _AllureReport_output, "f"),
                     ci: __classPrivateFieldGet(this, _AllureReport_ci, "f"),
+                    categories: __classPrivateFieldGet(this, _AllureReport_categories, "f"),
+                    history: __classPrivateFieldGet(this, _AllureReport_history, "f"),
                 };
                 try {
                     await consumer.call(this, plugin, pluginContext);
@@ -510,7 +515,7 @@ export class AllureReport {
                 }
             }
         });
-        const { name, readers = [allure1, allure2, cucumberjson, junitXml, attachments], plugins = [], known, reportFiles, realTime, historyPath, historyLimit, defaultLabels = {}, variables = {}, environment, environments, output, qualityGate, stage, allureService: allureServiceConfig, } = opts;
+        const { name, readers = [allure1, allure2, cucumberjson, junitXml, attachments], plugins = [], known, reportFiles, realTime, historyPath, historyLimit, defaultLabels = {}, variables = {}, environment, environments, output, qualityGate, dump, categories, allureService: allureServiceConfig, } = opts;
         __classPrivateFieldSet(this, _AllureReport_allureServiceClient, allureServiceConfig?.accessToken
             ? new AllureServiceClient(allureServiceConfig)
             : undefined, "f");
@@ -523,21 +528,22 @@ export class AllureReport {
         __classPrivateFieldSet(this, _AllureReport_realtimeDispatcher, new RealtimeEventsDispatcher(__classPrivateFieldGet(this, _AllureReport_eventEmitter, "f")), "f");
         __classPrivateFieldSet(this, _AllureReport_realtimeSubscriber, new RealtimeSubscriber(__classPrivateFieldGet(this, _AllureReport_eventEmitter, "f")), "f");
         __classPrivateFieldSet(this, _AllureReport_realTime, realTime, "f");
-        __classPrivateFieldSet(this, _AllureReport_stage, stage, "f");
+        __classPrivateFieldSet(this, _AllureReport_dump, dump, "f");
         if (qualityGate) {
             __classPrivateFieldSet(this, _AllureReport_qualityGate, new QualityGate(qualityGate), "f");
         }
+        __classPrivateFieldSet(this, _AllureReport_categories, normalizeCategoriesConfig(categories), "f");
         if (__classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f")) {
             __classPrivateFieldSet(this, _AllureReport_history, new AllureRemoteHistory({
-                allureServiceClient: __classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f"),
-                branch: __classPrivateFieldGet(this, _AllureReport_ci, "f")?.jobRunBranch,
                 limit: historyLimit,
+                branch: __classPrivateFieldGet(this, _AllureReport_ci, "f")?.jobRunBranch,
+                allureServiceClient: __classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f"),
             }), "f");
         }
         else if (historyPath) {
             __classPrivateFieldSet(this, _AllureReport_history, new AllureLocalHistory({
-                historyPath,
                 limit: historyLimit,
+                historyPath,
             }), "f");
         }
         __classPrivateFieldSet(this, _AllureReport_store, new DefaultAllureStore({
@@ -568,7 +574,7 @@ export class AllureReport {
         return __classPrivateFieldGet(this, _AllureReport_realtimeDispatcher, "f");
     }
 }
-_AllureReport_reportName = new WeakMap(), _AllureReport_reportVariables = new WeakMap(), _AllureReport_ci = new WeakMap(), _AllureReport_store = new WeakMap(), _AllureReport_readers = new WeakMap(), _AllureReport_plugins = new WeakMap(), _AllureReport_reportFiles = new WeakMap(), _AllureReport_eventEmitter = new WeakMap(), _AllureReport_realtimeSubscriber = new WeakMap(), _AllureReport_realtimeDispatcher = new WeakMap(), _AllureReport_realTime = new WeakMap(), _AllureReport_output = new WeakMap(), _AllureReport_history = new WeakMap(), _AllureReport_allureServiceClient = new WeakMap(), _AllureReport_qualityGate = new WeakMap(), _AllureReport_stage = new WeakMap(), _AllureReport_stageTempDirs = new WeakMap(), _AllureReport_state = new WeakMap(), _AllureReport_executionStage = new WeakMap(), _AllureReport_update = new WeakMap(), _AllureReport_eachPlugin = new WeakMap(), _AllureReport_instances = new WeakSet(), _AllureReport_publish_get = function _AllureReport_publish_get() {
+_AllureReport_reportName = new WeakMap(), _AllureReport_reportVariables = new WeakMap(), _AllureReport_ci = new WeakMap(), _AllureReport_store = new WeakMap(), _AllureReport_readers = new WeakMap(), _AllureReport_plugins = new WeakMap(), _AllureReport_reportFiles = new WeakMap(), _AllureReport_eventEmitter = new WeakMap(), _AllureReport_realtimeSubscriber = new WeakMap(), _AllureReport_realtimeDispatcher = new WeakMap(), _AllureReport_realTime = new WeakMap(), _AllureReport_output = new WeakMap(), _AllureReport_history = new WeakMap(), _AllureReport_allureServiceClient = new WeakMap(), _AllureReport_qualityGate = new WeakMap(), _AllureReport_dump = new WeakMap(), _AllureReport_categories = 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() {
     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/convert.js

@@ -1,7 +1,6 @@
 import { findByLabelName, notNull } from "@allurereport/core-api";
 import { md5 } from "@allurereport/plugin-api";
 import { extension, lookupContentType } from "@allurereport/reader-api";
-import MarkdownIt from "markdown-it";
 import { randomUUID } from "node:crypto";
 const defaultStatus = "unknown";
 export const __unknown = "#___unknown_value___#";
@@ -47,11 +46,11 @@ export const testResultRawToState = (stateData, raw, context) => {
         },
         ...processTimings(raw),
         description: raw.description,
-        descriptionHtml: raw.descriptionHtml ?? markdownToHtml(raw.description),
+        descriptionHtml: raw.descriptionHtml,
         precondition: raw.precondition,
-        preconditionHtml: raw.preconditionHtml ?? markdownToHtml(raw.precondition),
+        preconditionHtml: raw.preconditionHtml,
         expectedResult: raw.expectedResult,
-        expectedResultHtml: raw.expectedResultHtml ?? markdownToHtml(raw.expectedResult),
+        expectedResultHtml: raw.expectedResultHtml,
         flaky: raw.flaky ?? false,
         muted: raw.muted ?? false,
         known: raw.known ?? false,
@@ -235,7 +234,6 @@ const convertLink = (link) => ({
     url: link.url ?? __unknown,
     type: link.type,
 });
-const markdownToHtml = (value) => (value ? new MarkdownIt().render(value) : undefined);
 const calculateTestId = (raw) => {
     const maybeAllureId = raw.labels?.find((label) => label.name === "ALLURE_ID" || label.name === "AS_ID")?.value;
     if (maybeAllureId) {

package/dist/store/store.d.ts

@@ -1,6 +1,6 @@
-import { type AllureHistory, type AttachmentLink, type DefaultLabelsConfig, 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 AllureHistory, type AttachmentLink, type AttachmentLinkLinked, type DefaultLabelsConfig, 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 QualityGateValidationResult, type RealtimeEventsDispatcher, type RealtimeSubscriber, type ResultFile, type TestResultFilter } from "@allurereport/plugin-api";
-import type { RawFixtureResult, RawMetadata, RawTestResult, ReaderContext, ResultsVisitor } from "@allurereport/reader-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>;
 export declare const updateMapWithRecord: <K extends string | number | symbol, T = any>(map: Map<K, T>, record: Record<K, T>) => Map<K, T>;
 export declare class DefaultAllureStore implements AllureStore, ResultsVisitor {
@@ -25,16 +25,19 @@ export declare class DefaultAllureStore implements AllureStore, ResultsVisitor {
     readHistory(): Promise<HistoryDataPoint[]>;
     appendHistory(history: HistoryDataPoint): Promise<void>;
     qualityGateResults(): Promise<QualityGateValidationResult[]>;
+    qualityGateResultsByEnv(): Promise<Record<string, QualityGateValidationResult[]>>;
     globalExitCode(): Promise<ExitCode | undefined>;
     allGlobalErrors(): Promise<TestError[]>;
-    allGlobalAttachments(): Promise<AttachmentLink[]>;
+    allGlobalAttachments(): Promise<AttachmentLinkLinked[]>;
     visitTestResult(raw: RawTestResult, context: ReaderContext): Promise<void>;
     visitTestFixtureResult(result: RawFixtureResult, context: ReaderContext): Promise<void>;
-    visitAttachmentFile(resultFile: ResultFile, context: ReaderContext): Promise<void>;
+    visitAttachmentFile(resultFile: ResultFile): Promise<void>;
     visitMetadata(metadata: RawMetadata): Promise<void>;
+    visitGlobals(globals: RawGlobals): Promise<void>;
     allTestCases(): Promise<TestCase[]>;
     allTestResults(options?: {
         includeHidden?: boolean;
+        filter?: TestResultFilter;
     }): Promise<TestResult[]>;
     allAttachments(options?: {
         includeMissed?: boolean;
@@ -45,7 +48,7 @@ export declare class DefaultAllureStore implements AllureStore, ResultsVisitor {
     allHistoryDataPoints(): Promise<HistoryDataPoint[]>;
     allHistoryDataPointsByEnvironment(environment: string): Promise<HistoryDataPoint[]>;
     allKnownIssues(): Promise<KnownTestFailure[]>;
-    allNewTestResults(): Promise<TestResult[]>;
+    allNewTestResults(filter?: TestResultFilter, history?: HistoryDataPoint[]): Promise<TestResult[]>;
     testCaseById(tcId: string): Promise<TestCase | undefined>;
     testResultById(trId: string): Promise<TestResult | undefined>;
     attachmentById(attachmentId: string): Promise<AttachmentLink | undefined>;
@@ -61,8 +64,8 @@ export declare class DefaultAllureStore implements AllureStore, ResultsVisitor {
     failedTestResults(): Promise<TestResult[]>;
     unknownFailedTestResults(): Promise<TestResult[]>;
     testResultsByLabel(labelName: string): Promise<{
-        [x: string]: TestResult[];
         _: TestResult[];
+        [x: string]: TestResult[];
     }>;
     testsStatistic(filter?: TestResultFilter): Promise<Statistic>;
     allEnvironments(): Promise<string[]>;

package/dist/store/store.js

@@ -9,9 +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 _DefaultAllureStore_instances, _DefaultAllureStore_testResults, _DefaultAllureStore_attachments, _DefaultAllureStore_attachmentContents, _DefaultAllureStore_testCases, _DefaultAllureStore_metadata, _DefaultAllureStore_history, _DefaultAllureStore_known, _DefaultAllureStore_fixtures, _DefaultAllureStore_defaultLabels, _DefaultAllureStore_environment, _DefaultAllureStore_environmentsConfig, _DefaultAllureStore_reportVariables, _DefaultAllureStore_realtimeDispatcher, _DefaultAllureStore_realtimeSubscriber, _DefaultAllureStore_globalAttachments, _DefaultAllureStore_globalErrors, _DefaultAllureStore_globalExitCode, _DefaultAllureStore_qualityGateResultsByRules, _DefaultAllureStore_historyPoints, _DefaultAllureStore_environments, _DefaultAllureStore_addEnvironments;
-import { DEFAULT_ENVIRONMENT, compareBy, getWorstStatus, htrsByTr, matchEnvironment, nullsLast, ordinal, reverse, } from "@allurereport/core-api";
+var _DefaultAllureStore_instances, _DefaultAllureStore_testResults, _DefaultAllureStore_attachments, _DefaultAllureStore_attachmentContents, _DefaultAllureStore_testCases, _DefaultAllureStore_metadata, _DefaultAllureStore_history, _DefaultAllureStore_known, _DefaultAllureStore_fixtures, _DefaultAllureStore_defaultLabels, _DefaultAllureStore_environment, _DefaultAllureStore_environmentsConfig, _DefaultAllureStore_reportVariables, _DefaultAllureStore_realtimeDispatcher, _DefaultAllureStore_realtimeSubscriber, _DefaultAllureStore_globalAttachmentIds, _DefaultAllureStore_globalErrors, _DefaultAllureStore_globalExitCode, _DefaultAllureStore_qualityGateResults, _DefaultAllureStore_historyPoints, _DefaultAllureStore_environments, _DefaultAllureStore_addEnvironments;
+import { DEFAULT_ENVIRONMENT, compareBy, createDictionary, getWorstStatus, htrsByTr, matchEnvironment, nullsLast, ordinal, reverse, } from "@allurereport/core-api";
 import { md5, } from "@allurereport/plugin-api";
+import { extname } from "node:path";
 import { isFlaky } from "../utils/flaky.js";
 import { getStatusTransition } from "../utils/new.js";
 import { testFixtureResultRawToState, testResultRawToState } from "./convert.js";
@@ -86,10 +87,10 @@ export class DefaultAllureStore {
         this.indexAttachmentByFixture = new Map();
         this.indexFixturesByTestResult = new Map();
         this.indexKnownByHistoryId = new Map();
-        _DefaultAllureStore_globalAttachments.set(this, []);
+        _DefaultAllureStore_globalAttachmentIds.set(this, []);
         _DefaultAllureStore_globalErrors.set(this, []);
         _DefaultAllureStore_globalExitCode.set(this, void 0);
-        _DefaultAllureStore_qualityGateResultsByRules.set(this, {});
+        _DefaultAllureStore_qualityGateResults.set(this, []);
         _DefaultAllureStore_historyPoints.set(this, []);
         _DefaultAllureStore_environments.set(this, []);
         const { history, known = [], realtimeDispatcher, realtimeSubscriber, defaultLabels = {}, environment, environmentsConfig = {}, reportVariables = {}, } = params ?? {};
@@ -113,9 +114,7 @@ export class DefaultAllureStore {
         __classPrivateFieldSet(this, _DefaultAllureStore_reportVariables, reportVariables, "f");
         __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_addEnvironments).call(this, environments);
         __classPrivateFieldGet(this, _DefaultAllureStore_realtimeSubscriber, "f")?.onQualityGateResults(async (results) => {
-            results.forEach((result) => {
-                __classPrivateFieldGet(this, _DefaultAllureStore_qualityGateResultsByRules, "f")[result.rule] = result;
-            });
+            __classPrivateFieldGet(this, _DefaultAllureStore_qualityGateResults, "f").push(...results);
         });
         __classPrivateFieldGet(this, _DefaultAllureStore_realtimeSubscriber, "f")?.onGlobalExitCode(async (exitCode) => {
             __classPrivateFieldSet(this, _DefaultAllureStore_globalExitCode, exitCode, "f");
@@ -123,18 +122,21 @@ export class DefaultAllureStore {
         __classPrivateFieldGet(this, _DefaultAllureStore_realtimeSubscriber, "f")?.onGlobalError(async (error) => {
             __classPrivateFieldGet(this, _DefaultAllureStore_globalErrors, "f").push(error);
         });
-        __classPrivateFieldGet(this, _DefaultAllureStore_realtimeSubscriber, "f")?.onGlobalAttachment(async (attachment) => {
+        __classPrivateFieldGet(this, _DefaultAllureStore_realtimeSubscriber, "f")?.onGlobalAttachment(async ({ attachment, fileName }) => {
+            const originalFileName = attachment.getOriginalFileName();
             const attachmentLink = {
-                id: md5(attachment.getOriginalFileName()),
+                id: md5(originalFileName),
+                name: fileName || originalFileName,
                 missed: false,
-                used: false,
+                used: true,
                 ext: attachment.getExtension(),
-                originalFileName: attachment.getOriginalFileName(),
                 contentType: attachment.getContentType(),
                 contentLength: attachment.getContentLength(),
+                originalFileName,
             };
+            __classPrivateFieldGet(this, _DefaultAllureStore_attachments, "f").set(attachmentLink.id, attachmentLink);
             __classPrivateFieldGet(this, _DefaultAllureStore_attachmentContents, "f").set(attachmentLink.id, attachment);
-            __classPrivateFieldGet(this, _DefaultAllureStore_globalAttachments, "f").push(attachmentLink);
+            __classPrivateFieldGet(this, _DefaultAllureStore_globalAttachmentIds, "f").push(attachmentLink.id);
         });
     }
     async readHistory() {
@@ -153,7 +155,18 @@ export class DefaultAllureStore {
         await __classPrivateFieldGet(this, _DefaultAllureStore_history, "f").appendHistory(history);
     }
     async qualityGateResults() {
-        return Object.values(__classPrivateFieldGet(this, _DefaultAllureStore_qualityGateResultsByRules, "f"));
+        return __classPrivateFieldGet(this, _DefaultAllureStore_qualityGateResults, "f");
+    }
+    async qualityGateResultsByEnv() {
+        const resultsByEnv = createDictionary();
+        for (const result of __classPrivateFieldGet(this, _DefaultAllureStore_qualityGateResults, "f")) {
+            const environment = result.environment || "default";
+            if (!resultsByEnv[environment]) {
+                resultsByEnv[environment] = [];
+            }
+            resultsByEnv[environment].push(result);
+        }
+        return resultsByEnv;
     }
     async globalExitCode() {
         return __classPrivateFieldGet(this, _DefaultAllureStore_globalExitCode, "f");
@@ -162,7 +175,14 @@ export class DefaultAllureStore {
         return __classPrivateFieldGet(this, _DefaultAllureStore_globalErrors, "f");
     }
     async allGlobalAttachments() {
-        return __classPrivateFieldGet(this, _DefaultAllureStore_globalAttachments, "f");
+        return __classPrivateFieldGet(this, _DefaultAllureStore_globalAttachmentIds, "f").reduce((acc, id) => {
+            const attachment = __classPrivateFieldGet(this, _DefaultAllureStore_attachments, "f").get(id);
+            if (!attachment) {
+                return acc;
+            }
+            acc.push(attachment);
+            return acc;
+        }, []);
     }
     async visitTestResult(raw, context) {
         const attachmentLinks = [];
@@ -187,7 +207,7 @@ export class DefaultAllureStore {
         }
         testResult.environment = __classPrivateFieldGet(this, _DefaultAllureStore_environment, "f") || matchEnvironment(__classPrivateFieldGet(this, _DefaultAllureStore_environmentsConfig, "f"), testResult);
         const trHistory = await this.historyByTr(testResult);
-        if (trHistory) {
+        if (trHistory !== undefined) {
             testResult.transition = getStatusTransition(testResult, trHistory);
             testResult.flaky = isFlaky(testResult, trHistory);
         }
@@ -211,7 +231,7 @@ export class DefaultAllureStore {
         index(this.indexAttachmentByFixture, testFixtureResult.id, ...attachmentLinks);
         __classPrivateFieldGet(this, _DefaultAllureStore_realtimeDispatcher, "f")?.sendTestFixtureResult(testFixtureResult.id);
     }
-    async visitAttachmentFile(resultFile, context) {
+    async visitAttachmentFile(resultFile) {
         const originalFileName = resultFile.getOriginalFileName();
         const id = md5(originalFileName);
         __classPrivateFieldGet(this, _DefaultAllureStore_attachmentContents, "f").set(id, resultFile);
@@ -237,18 +257,42 @@ export class DefaultAllureStore {
         __classPrivateFieldGet(this, _DefaultAllureStore_realtimeDispatcher, "f")?.sendAttachmentFile(id);
     }
     async visitMetadata(metadata) {
-        Object.keys(metadata).forEach((key) => __classPrivateFieldGet(this, _DefaultAllureStore_metadata, "f").set(key, metadata[key]));
+        Object.keys(metadata).forEach((key) => {
+            __classPrivateFieldGet(this, _DefaultAllureStore_metadata, "f").set(key, metadata[key]);
+        });
+    }
+    async visitGlobals(globals) {
+        const { errors, attachments } = globals;
+        __classPrivateFieldGet(this, _DefaultAllureStore_globalErrors, "f").push(...errors);
+        attachments.forEach((attachment) => {
+            const originalFileName = attachment.originalFileName;
+            const id = md5(originalFileName);
+            const attachmentLink = {
+                id,
+                name: attachment?.name || originalFileName,
+                originalFileName,
+                ext: extname(originalFileName),
+                used: true,
+                missed: false,
+                contentType: attachment?.contentType,
+            };
+            __classPrivateFieldGet(this, _DefaultAllureStore_attachments, "f").set(id, attachmentLink);
+            __classPrivateFieldGet(this, _DefaultAllureStore_globalAttachmentIds, "f").push(id);
+        });
     }
     async allTestCases() {
         return Array.from(__classPrivateFieldGet(this, _DefaultAllureStore_testCases, "f").values());
     }
     async allTestResults(options = { includeHidden: false }) {
-        const { includeHidden } = options;
+        const { includeHidden = false, filter } = options;
         const result = [];
         for (const [, tr] of __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f")) {
             if (!includeHidden && tr.hidden) {
                 continue;
             }
+            if (typeof filter === "function" && !filter(tr)) {
+                continue;
+            }
             result.push(tr);
         }
         return result;
@@ -306,18 +350,24 @@ export class DefaultAllureStore {
     async allKnownIssues() {
         return __classPrivateFieldGet(this, _DefaultAllureStore_known, "f");
     }
-    async allNewTestResults() {
+    async allNewTestResults(filter, history) {
+        if (!__classPrivateFieldGet(this, _DefaultAllureStore_history, "f") && !history) {
+            return [];
+        }
+        const allHistoryDps = history ?? (await this.allHistoryDataPoints());
+        if (allHistoryDps.length === 0) {
+            return Array.from(__classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f").values());
+        }
+        const historicalIds = new Set(allHistoryDps.flatMap((dp) => Object.keys(dp.testResults)));
         const newTrs = [];
-        const allHistoryDps = await this.allHistoryDataPoints();
         for (const [, tr] of __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f")) {
             if (tr.hidden) {
                 continue;
             }
-            if (!tr.historyId) {
-                newTrs.push(tr);
+            if (typeof filter === "function" && !filter(tr)) {
                 continue;
             }
-            if (!allHistoryDps.some((dp) => dp.testResults[tr.historyId])) {
+            if (!tr.historyId || !historicalIds.has(tr.historyId)) {
                 newTrs.push(tr);
             }
         }
@@ -393,9 +443,8 @@ export class DefaultAllureStore {
         return failedTestResults.filter(({ historyId }) => historyId && !knownHistoryIds.includes(historyId));
     }
     async testResultsByLabel(labelName) {
-        const results = {
-            _: [],
-        };
+        const results = createDictionary();
+        results._ = [];
         for (const [, test] of __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f")) {
             if (test.hidden) {
                 continue;
@@ -507,7 +556,7 @@ export class DefaultAllureStore {
             fixtures: mapToObject(__classPrivateFieldGet(this, _DefaultAllureStore_fixtures, "f")),
             environments: __classPrivateFieldGet(this, _DefaultAllureStore_environments, "f"),
             reportVariables: __classPrivateFieldGet(this, _DefaultAllureStore_reportVariables, "f"),
-            globalAttachments: __classPrivateFieldGet(this, _DefaultAllureStore_globalAttachments, "f"),
+            globalAttachmentIds: __classPrivateFieldGet(this, _DefaultAllureStore_globalAttachmentIds, "f"),
             globalErrors: __classPrivateFieldGet(this, _DefaultAllureStore_globalErrors, "f"),
             indexLatestEnvTestResultByHistoryId: {},
             indexAttachmentByTestResult: {},
@@ -516,7 +565,7 @@ export class DefaultAllureStore {
             indexAttachmentByFixture: {},
             indexFixturesByTestResult: {},
             indexKnownByHistoryId: {},
-            qualityGateResultsByRules: __classPrivateFieldGet(this, _DefaultAllureStore_qualityGateResultsByRules, "f"),
+            qualityGateResults: __classPrivateFieldGet(this, _DefaultAllureStore_qualityGateResults, "f"),
         };
         this.indexLatestEnvTestResultByHistoryId.forEach((envMap) => {
             envMap.forEach((tr, historyId) => {
@@ -544,14 +593,14 @@ export class DefaultAllureStore {
         return storeDump;
     }
     async restoreState(stateDump, attachmentsContents = {}) {
-        const { testResults, attachments, testCases, fixtures, reportVariables, environments, globalAttachments = [], globalErrors = [], indexAttachmentByTestResult = {}, indexTestResultByHistoryId = {}, indexTestResultByTestCase = {}, indexLatestEnvTestResultByHistoryId = {}, indexAttachmentByFixture = {}, indexFixturesByTestResult = {}, indexKnownByHistoryId = {}, qualityGateResultsByRules = {}, } = stateDump;
+        const { testResults, attachments, testCases, fixtures, reportVariables, environments, globalAttachmentIds = [], globalErrors = [], indexAttachmentByTestResult = {}, indexTestResultByHistoryId = {}, indexTestResultByTestCase = {}, indexLatestEnvTestResultByHistoryId = {}, indexAttachmentByFixture = {}, indexFixturesByTestResult = {}, indexKnownByHistoryId = {}, qualityGateResults = [], } = stateDump;
         updateMapWithRecord(__classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f"), testResults);
         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);
         __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_addEnvironments).call(this, environments);
-        __classPrivateFieldGet(this, _DefaultAllureStore_globalAttachments, "f").push(...globalAttachments);
+        __classPrivateFieldGet(this, _DefaultAllureStore_globalAttachmentIds, "f").push(...globalAttachmentIds);
         __classPrivateFieldGet(this, _DefaultAllureStore_globalErrors, "f").push(...globalErrors);
         Object.assign(__classPrivateFieldGet(this, _DefaultAllureStore_reportVariables, "f"), reportVariables);
         Object.entries(indexAttachmentByTestResult).forEach(([trId, links]) => {
@@ -629,10 +678,10 @@ export class DefaultAllureStore {
             }
             hidePreviousAttempt(this.indexLatestEnvTestResultByHistoryId, tr);
         });
-        Object.assign(__classPrivateFieldGet(this, _DefaultAllureStore_qualityGateResultsByRules, "f"), qualityGateResultsByRules);
+        __classPrivateFieldGet(this, _DefaultAllureStore_qualityGateResults, "f").push(...qualityGateResults);
     }
 }
-_DefaultAllureStore_testResults = new WeakMap(), _DefaultAllureStore_attachments = new WeakMap(), _DefaultAllureStore_attachmentContents = new WeakMap(), _DefaultAllureStore_testCases = new WeakMap(), _DefaultAllureStore_metadata = new WeakMap(), _DefaultAllureStore_history = new WeakMap(), _DefaultAllureStore_known = new WeakMap(), _DefaultAllureStore_fixtures = new WeakMap(), _DefaultAllureStore_defaultLabels = new WeakMap(), _DefaultAllureStore_environment = new WeakMap(), _DefaultAllureStore_environmentsConfig = new WeakMap(), _DefaultAllureStore_reportVariables = new WeakMap(), _DefaultAllureStore_realtimeDispatcher = new WeakMap(), _DefaultAllureStore_realtimeSubscriber = new WeakMap(), _DefaultAllureStore_globalAttachments = new WeakMap(), _DefaultAllureStore_globalErrors = new WeakMap(), _DefaultAllureStore_globalExitCode = new WeakMap(), _DefaultAllureStore_qualityGateResultsByRules = new WeakMap(), _DefaultAllureStore_historyPoints = new WeakMap(), _DefaultAllureStore_environments = new WeakMap(), _DefaultAllureStore_instances = new WeakSet(), _DefaultAllureStore_addEnvironments = function _DefaultAllureStore_addEnvironments(envs) {
+_DefaultAllureStore_testResults = new WeakMap(), _DefaultAllureStore_attachments = new WeakMap(), _DefaultAllureStore_attachmentContents = new WeakMap(), _DefaultAllureStore_testCases = new WeakMap(), _DefaultAllureStore_metadata = new WeakMap(), _DefaultAllureStore_history = new WeakMap(), _DefaultAllureStore_known = new WeakMap(), _DefaultAllureStore_fixtures = new WeakMap(), _DefaultAllureStore_defaultLabels = new WeakMap(), _DefaultAllureStore_environment = new WeakMap(), _DefaultAllureStore_environmentsConfig = new WeakMap(), _DefaultAllureStore_reportVariables = new WeakMap(), _DefaultAllureStore_realtimeDispatcher = new WeakMap(), _DefaultAllureStore_realtimeSubscriber = new WeakMap(), _DefaultAllureStore_globalAttachmentIds = new WeakMap(), _DefaultAllureStore_globalErrors = new WeakMap(), _DefaultAllureStore_globalExitCode = new WeakMap(), _DefaultAllureStore_qualityGateResults = new WeakMap(), _DefaultAllureStore_historyPoints = new WeakMap(), _DefaultAllureStore_environments = new WeakMap(), _DefaultAllureStore_instances = new WeakSet(), _DefaultAllureStore_addEnvironments = function _DefaultAllureStore_addEnvironments(envs) {
     if (__classPrivateFieldGet(this, _DefaultAllureStore_environments, "f").length === 0) {
         __classPrivateFieldGet(this, _DefaultAllureStore_environments, "f").push(DEFAULT_ENVIRONMENT);
     }

package/dist/utils/event.d.ts

@@ -15,14 +15,17 @@ export interface AllureStoreEvents {
     [RealtimeEvents.TestResult]: [string];
     [RealtimeEvents.TestFixtureResult]: [string];
     [RealtimeEvents.AttachmentFile]: [string];
-    [RealtimeEvents.GlobalAttachment]: [ResultFile];
+    [RealtimeEvents.GlobalAttachment]: [{
+        attachment: ResultFile;
+        fileName?: string;
+    }];
     [RealtimeEvents.GlobalExitCode]: [ExitCode];
     [RealtimeEvents.GlobalError]: [TestError];
 }
 export declare class RealtimeEventsDispatcher implements RealtimeEventsDispatcherType {
     #private;
     constructor(emitter: EventEmitter<AllureStoreEvents>);
-    sendGlobalAttachment(attachment: ResultFile): void;
+    sendGlobalAttachment(attachment: ResultFile, fileName?: string): void;
     sendGlobalExitCode(codes: ExitCode): void;
     sendGlobalError(error: TestError): void;
     sendQualityGateResults(payload: QualityGateValidationResult[]): void;
@@ -33,7 +36,10 @@ export declare class RealtimeEventsDispatcher implements RealtimeEventsDispatche
 export declare class RealtimeSubscriber implements RealtimeSubscriberType {
     #private;
     constructor(emitter: EventEmitter<AllureStoreEvents>);
-    onGlobalAttachment(listener: (attachment: ResultFile) => Promise<void>): () => void;
+    onGlobalAttachment(listener: (payload: {
+        attachment: ResultFile;
+        fileName?: string;
+    }) => Promise<void>): () => void;
     onGlobalExitCode(listener: (payload: ExitCode) => Promise<void>): () => void;
     onGlobalError(listener: (error: TestError) => Promise<void>): () => void;
     onQualityGateResults(listener: (payload: QualityGateValidationResult[]) => Promise<void>): () => void;

package/dist/utils/event.js

@@ -27,8 +27,8 @@ export class RealtimeEventsDispatcher {
         _RealtimeEventsDispatcher_emitter.set(this, void 0);
         __classPrivateFieldSet(this, _RealtimeEventsDispatcher_emitter, emitter, "f");
     }
-    sendGlobalAttachment(attachment) {
-        __classPrivateFieldGet(this, _RealtimeEventsDispatcher_emitter, "f").emit(RealtimeEvents.GlobalAttachment, attachment);
+    sendGlobalAttachment(attachment, fileName) {
+        __classPrivateFieldGet(this, _RealtimeEventsDispatcher_emitter, "f").emit(RealtimeEvents.GlobalAttachment, { attachment, fileName });
     }
     sendGlobalExitCode(codes) {
         __classPrivateFieldGet(this, _RealtimeEventsDispatcher_emitter, "f").emit(RealtimeEvents.GlobalExitCode, codes);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/core",
-  "version": "3.1.0",
+  "version": "3.3.1",
   "description": "Collection of generic Allure utilities used across the entire project",
   "keywords": [
     "allure"
@@ -25,26 +25,25 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@allurereport/ci": "3.1.0",
-    "@allurereport/core-api": "3.1.0",
-    "@allurereport/plugin-allure2": "3.1.0",
-    "@allurereport/plugin-api": "3.1.0",
-    "@allurereport/plugin-awesome": "3.1.0",
-    "@allurereport/plugin-classic": "3.1.0",
-    "@allurereport/plugin-csv": "3.1.0",
-    "@allurereport/plugin-dashboard": "3.1.0",
-    "@allurereport/plugin-jira": "3.1.0",
-    "@allurereport/plugin-log": "3.1.0",
-    "@allurereport/plugin-progress": "3.1.0",
-    "@allurereport/plugin-slack": "3.1.0",
-    "@allurereport/plugin-testops": "3.1.0",
-    "@allurereport/plugin-testplan": "3.1.0",
-    "@allurereport/reader": "3.1.0",
-    "@allurereport/reader-api": "3.1.0",
-    "@allurereport/service": "3.1.0",
-    "@allurereport/summary": "3.1.0",
+    "@allurereport/ci": "3.3.1",
+    "@allurereport/core-api": "3.3.1",
+    "@allurereport/plugin-allure2": "3.3.1",
+    "@allurereport/plugin-api": "3.3.1",
+    "@allurereport/plugin-awesome": "3.3.1",
+    "@allurereport/plugin-classic": "3.3.1",
+    "@allurereport/plugin-csv": "3.3.1",
+    "@allurereport/plugin-dashboard": "3.3.1",
+    "@allurereport/plugin-jira": "3.3.1",
+    "@allurereport/plugin-log": "3.3.1",
+    "@allurereport/plugin-progress": "3.3.1",
+    "@allurereport/plugin-slack": "3.3.1",
+    "@allurereport/plugin-testops": "3.3.1",
+    "@allurereport/plugin-testplan": "3.3.1",
+    "@allurereport/reader": "3.3.1",
+    "@allurereport/reader-api": "3.3.1",
+    "@allurereport/service": "3.3.1",
+    "@allurereport/summary": "3.3.1",
     "handlebars": "^4.7.8",
-    "markdown-it": "^14.1.0",
     "node-stream-zip": "^1.15.0",
     "p-limit": "^7.2.0",
     "progress": "^2.0.3",
@@ -56,7 +55,6 @@
     "@stylistic/eslint-plugin": "^2.6.1",
     "@types/eslint": "^8.56.11",
     "@types/handlebars": "^4.1.0",
-    "@types/markdown-it": "^14.1.2",
     "@types/node": "^20.17.9",
     "@types/progress": "^2",
     "@types/zip-stream": "^7.0.0",