@allurereport/core 3.14.3 → 3.16.0

package/dist/api.d.ts

@@ -7,18 +7,20 @@ export interface PluginInstance {
     plugin: Plugin;
     options: Record<string, any>;
 }
-type FullConfigRequiredFromConfig = Required<Pick<Config, "name" | "output" | "open" | "knownIssuesPath">>;
-export interface FullConfig extends Omit<Config, "name" | "output" | "open" | "allureService" | "knownIssuesPath" | "plugins" | "port">, FullConfigRequiredFromConfig {
+type FullConfigRequiredFromConfig = Required<Pick<Config, "name" | "output" | "open">>;
+export interface FullConfig extends Omit<Config, "name" | "output" | "open" | "allureService" | "knownIssuesPath" | "plugins" | "port" | "resultsDir">, FullConfigRequiredFromConfig {
     port: Config["port"] | undefined;
     allowedEnvironments?: Config["allowedEnvironments"];
     reportFiles: ReportFiles;
     readers?: ResultsReader[];
     plugins?: PluginInstance[];
     known?: KnownTestFailure[];
+    knownIssuesPath?: Config["knownIssuesPath"];
     realTime?: any;
     qualityGate?: Config["qualityGate"];
     allureService?: ResolvedAllureServiceConfig;
     categories?: CategoriesConfig;
     globalAttachments?: string[];
+    resultsDir?: string[];
 }
 export {};

package/dist/config.d.ts

@@ -25,6 +25,7 @@ export declare const validateConfig: (config: Config) => {
 export declare const loadYamlConfig: (configPath: string) => Promise<Config>;
 export declare const loadJsonConfig: (configPath: string) => Promise<Config>;
 export declare const loadJsConfig: (configPath: string) => Promise<Config>;
+export declare const loadTsConfig: (configPath: string) => Promise<Config>;
 export declare const resolveConfig: (config: Config, override?: ConfigOverride) => Promise<FullConfig>;
 export declare const readConfig: (cwd?: string, configPath?: string, override?: ConfigOverride) => Promise<FullConfig>;
 export declare const readRawConfig: (cwd?: string, configPath?: string) => Promise<Config>;

package/dist/config.js

@@ -2,17 +2,22 @@ import { readFile, stat } from "node:fs/promises";
 import { extname, resolve } from "node:path";
 import * as process from "node:process";
 import { validateEnvironmentName } from "@allurereport/core-api";
+import { createJiti } from "jiti";
 import { parse } from "yaml";
-import { readKnownIssues } from "./known.js";
+import { DEFAULT_KNOWN_ISSUES_PATH, hasKnownIssueRules, readKnownIssues, resolveExactIssuesFilePath } from "./known.js";
 import { FileSystemReportFiles } from "./plugin.js";
 import { environmentIdentityById, environmentIdentityByName, validateAllowedEnvironmentIds, normalizeEnvironmentDescriptorMap, validateAllowedEnvironmentId, } from "./utils/environment.js";
 import { importWrapper } from "./utils/module.js";
 import { normalizeImportPath } from "./utils/path.js";
+import { normalizeResultsDir } from "./utils/resultsDir.js";
 import { assertValidPluginIdForWindows, isWindows } from "./utils/windows.js";
 const CONFIG_FILENAMES = [
     "allurerc.js",
     "allurerc.mjs",
     "allurerc.cjs",
+    "allurerc.ts",
+    "allurerc.mts",
+    "allurerc.cts",
     "allurerc.json",
     "allurerc.yaml",
     "allurerc.yml",
@@ -80,7 +85,7 @@ export const findConfig = async (cwd, configPath) => {
                 return resolved;
             }
         }
-        catch (ignored) {
+        catch {
         }
     }
 };
@@ -94,6 +99,7 @@ export const validateConfig = (config) => {
         "historyPath",
         "historyLimit",
         "knownIssuesPath",
+        "knownIssues",
         "plugins",
         "defaultLabels",
         "variables",
@@ -105,6 +111,7 @@ export const validateConfig = (config) => {
         "allureService",
         "categories",
         "globalAttachments",
+        "resultsDir",
     ];
     const unsupportedFields = Object.keys(config).filter((key) => !supportedFields.includes(key));
     return {
@@ -141,6 +148,10 @@ export const loadJsonConfig = async (configPath) => {
 export const loadJsConfig = async (configPath) => {
     return (await import(normalizeImportPath(configPath))).default;
 };
+export const loadTsConfig = async (configPath) => {
+    const jiti = createJiti(import.meta.url);
+    return await jiti.import(resolve(configPath), { default: true });
+};
 const resolveConfigEnvironments = (config) => {
     const errors = [];
     const { ids: allowedEnvironments, idsSet: allowedEnvironmentIds, errors: allowedEnvironmentErrors, } = validateAllowedEnvironmentIds(config.allowedEnvironments, "config.allowedEnvironments");
@@ -192,10 +203,13 @@ export const resolveConfig = async (config, override = {}) => {
     const historyPath = override.historyPath ?? config.historyPath;
     const historyLimit = override.historyLimit ?? config.historyLimit;
     const appendHistory = config.appendHistory ?? true;
-    const knownIssuesPath = resolve(override.knownIssuesPath ?? config.knownIssuesPath ?? "./allure/known.json");
+    const configuredKnownIssuesPath = override.knownIssuesPath ?? config.knownIssuesPath;
+    const knownIssuesPathInput = configuredKnownIssuesPath ?? (hasKnownIssueRules(config.knownIssues) ? DEFAULT_KNOWN_ISSUES_PATH : undefined);
+    const knownIssuesPath = await resolveExactIssuesFilePath(knownIssuesPathInput, "known issues");
     const output = resolve(override.output ?? config.output ?? "./allure-report");
-    const known = await readKnownIssues(knownIssuesPath);
+    const known = knownIssuesPath ? await readKnownIssues(knownIssuesPath) : undefined;
     const variables = config.variables ?? {};
+    const resultsDir = normalizeResultsDir(config.resultsDir);
     let pluginInstances = [];
     const hasPluginsOverride = override.plugins !== undefined;
     if (!hasPluginsOverride || Object.keys(override.plugins ?? {}).length > 0) {
@@ -225,6 +239,7 @@ export const resolveConfig = async (config, override = {}) => {
         hideLabels,
         knownIssuesPath,
         known,
+        knownIssues: config.knownIssues,
         environment,
         allowedEnvironments,
         variables,
@@ -247,6 +262,7 @@ export const resolveConfig = async (config, override = {}) => {
             : undefined,
         categories: config.categories,
         globalAttachments: config.globalAttachments,
+        ...(resultsDir.length ? { resultsDir } : {}),
     };
 };
 export const readConfig = async (cwd = process.cwd(), configPath, override) => {
@@ -265,6 +281,11 @@ export const readConfig = async (cwd = process.cwd(), configPath, override) => {
         case ".mjs":
             config = await loadJsConfig(cfg);
             break;
+        case ".ts":
+        case ".cts":
+        case ".mts":
+            config = await loadTsConfig(cfg);
+            break;
         default:
             config = DEFAULT_CONFIG;
     }
@@ -283,6 +304,10 @@ export const readRawConfig = async (cwd = process.cwd(), configPath) => {
         case ".cjs":
         case ".mjs":
             return loadJsConfig(cfg);
+        case ".ts":
+        case ".cts":
+        case ".mts":
+            return loadTsConfig(cfg);
         default:
             return DEFAULT_CONFIG;
     }

package/dist/index.d.ts

@@ -5,6 +5,7 @@ export * from "./utils/path.js";
 export * from "./utils/new.js";
 export * from "./utils/flaky.js";
 export * from "./utils/environment.js";
+export * from "./utils/resultsDir.js";
 export * from "./history.js";
 export * from "./known.js";
 export { resolveConfig, readConfig, readRawConfig, getPluginInstance } from "./config.js";

package/dist/index.js

@@ -4,6 +4,7 @@ export * from "./utils/path.js";
 export * from "./utils/new.js";
 export * from "./utils/flaky.js";
 export * from "./utils/environment.js";
+export * from "./utils/resultsDir.js";
 export * from "./history.js";
 export * from "./known.js";
 export { resolveConfig, readConfig, readRawConfig, getPluginInstance } from "./config.js";

package/dist/known.d.ts

@@ -1,4 +1,8 @@
-import type { KnownTestFailure } from "@allurereport/core-api";
+import type { KnownIssuesConfig, KnownTestFailure, TestResult } from "@allurereport/core-api";
 import type { AllureStore } from "@allurereport/plugin-api";
+export declare const DEFAULT_KNOWN_ISSUES_PATH = "known-issues.json";
+export declare const hasKnownIssueRules: (knownIssues?: KnownIssuesConfig) => boolean;
+export declare const getKnownIssueByRules: (testResult: TestResult, knownIssues: KnownIssuesConfig | undefined, environmentId?: string) => KnownTestFailure | undefined;
+export declare const resolveExactIssuesFilePath: (pathOrDir: string | undefined, label: string) => Promise<string | undefined>;
 export declare const readKnownIssues: (knownIssuePath: string) => Promise<KnownTestFailure[]>;
 export declare const writeKnownIssues: (store: AllureStore, knownIssuesPath?: string) => Promise<void>;

package/dist/known.js

@@ -1,9 +1,66 @@
-import { readFile, writeFile } from "node:fs/promises";
-import { resolve } from "node:path";
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { dirname, extname, resolve } from "node:path";
 import { isFileNotFoundError } from "./utils/misc.js";
-const failedStatuses = new Set(["failed", "broken"]);
+export const DEFAULT_KNOWN_ISSUES_PATH = "known-issues.json";
+export const hasKnownIssueRules = (knownIssues) => (knownIssues?.rules?.length ?? 0) > 0;
+const messageMatches = (rule, testResult) => {
+    if (!rule.messageRegexp) {
+        return true;
+    }
+    const message = testResult.error?.message;
+    return typeof message === "string" && new RegExp(rule.messageRegexp).test(message);
+};
+const testCaseIdMatches = (rule, testResult) => {
+    const { id, allureId, externalId } = testResult.testCase ?? {};
+    return !rule.testCaseId || [id, allureId, externalId].includes(rule.testCaseId);
+};
+const retryHashMatches = (rule, testResult) => {
+    return !rule.retryHash || rule.retryHash === testResult.retryHash;
+};
+const environmentMatches = (rule, testResult) => {
+    return !rule.environmentId || rule.environmentId === testResult.environment;
+};
+export const getKnownIssueByRules = (testResult, knownIssues, environmentId) => {
+    if (!testResult.historyId || !hasKnownIssueRules(knownIssues)) {
+        return undefined;
+    }
+    const matchedRule = knownIssues.rules.find((rule) => [messageMatches, testCaseIdMatches, environmentMatches, retryHashMatches].every((matcher) => matcher(rule, testResult)));
+    if (!matchedRule) {
+        return undefined;
+    }
+    return {
+        historyId: testResult.historyId,
+        reason: matchedRule.decision.reason,
+        links: matchedRule.decision.links,
+        error: testResult.error,
+    };
+};
+export const resolveExactIssuesFilePath = async (pathOrDir, label) => {
+    if (!pathOrDir) {
+        return undefined;
+    }
+    const path = resolve(pathOrDir);
+    if (extname(path).toLowerCase() !== ".json") {
+        throw new Error(`Invalid ${label} path ${JSON.stringify(pathOrDir)}: expected exact .json file path`);
+    }
+    try {
+        const pathStats = await stat(path);
+        if (pathStats.isDirectory()) {
+            throw new Error(`Invalid ${label} path ${JSON.stringify(pathOrDir)}: expected file, got directory`);
+        }
+    }
+    catch (e) {
+        if (!isFileNotFoundError(e)) {
+            throw e;
+        }
+    }
+    return path;
+};
 export const readKnownIssues = async (knownIssuePath) => {
-    const path = resolve(knownIssuePath);
+    const path = await resolveExactIssuesFilePath(knownIssuePath, "known issues");
+    if (!path) {
+        return [];
+    }
     try {
         const content = await readFile(path, { encoding: "utf-8" });
         return JSON.parse(content);
@@ -15,18 +72,15 @@ export const readKnownIssues = async (knownIssuePath) => {
         throw e;
     }
 };
-export const writeKnownIssues = async (store, knownIssuesPath) => {
-    if (!knownIssuesPath) {
+const writeKnownIssueRecords = async (knownIssues, knownIssuesPath) => {
+    const path = await resolveExactIssuesFilePath(knownIssuesPath, "known issues");
+    if (!path) {
         return;
     }
-    const testResults = await store.allTestResults();
-    const knownIssues = testResults
-        .filter((tr) => failedStatuses.has(tr.status))
-        .filter((tr) => tr.historyId)
-        .map(({ historyId, links }) => ({
-        historyId: historyId,
-        issues: links.filter((l) => l.type === "issue"),
-        comment: "automatically generated from failure by allure known-issue command",
-    }));
-    await writeFile(knownIssuesPath, JSON.stringify(knownIssues));
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `${JSON.stringify(knownIssues)}\n`, "utf-8");
+};
+export const writeKnownIssues = async (store, knownIssuesPath) => {
+    const knownIssues = await store.allKnownIssues();
+    await writeKnownIssueRecords(knownIssues, knownIssuesPath);
 };

package/dist/qualityGate/qualityGate.d.ts

@@ -4,8 +4,11 @@ export declare const stringifyQualityGateResults: (results: QualityGateValidatio
 export declare const convertQualityGateResultsToTestErrors: (results: QualityGateValidationResult[]) => TestError[];
 export declare class QualityGateState {
     #private;
-    setResult(rule: string, value: any): void;
+    setResult(rule: string, value: any, testResults?: string[]): void;
     getResult(rule: string): any;
+    getTestResults(rule: string): string[];
+    markTestResultsProcessed(testResults: TestResult[]): void;
+    isTestResultProcessed(trId: string): boolean;
 }
 export declare class QualityGate {
     private readonly config;

package/dist/qualityGate/qualityGate.js

@@ -3,7 +3,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 _QualityGateState_state;
+var _QualityGateState_state, _QualityGateState_processedTestResultIds;
 import { gray, red } from "yoctocolors";
 import { qualityGateDefaultRules } from "./rules.js";
 export const stringifyQualityGateResults = (results) => {
@@ -30,21 +30,43 @@ export const convertQualityGateResultsToTestErrors = (results) => {
 export class QualityGateState {
     constructor() {
         _QualityGateState_state.set(this, {});
+        _QualityGateState_processedTestResultIds.set(this, new Set());
     }
-    setResult(rule, value) {
-        __classPrivateFieldGet(this, _QualityGateState_state, "f")[rule] = value;
+    setResult(rule, value, testResults = []) {
+        const previousTestResults = __classPrivateFieldGet(this, _QualityGateState_state, "f")[rule]?.testResults ?? [];
+        __classPrivateFieldGet(this, _QualityGateState_state, "f")[rule] = {
+            result: value,
+            testResults: [...new Set([...previousTestResults, ...testResults])],
+        };
     }
     getResult(rule) {
-        return __classPrivateFieldGet(this, _QualityGateState_state, "f")[rule];
+        return __classPrivateFieldGet(this, _QualityGateState_state, "f")[rule]?.result;
+    }
+    getTestResults(rule) {
+        return [...(__classPrivateFieldGet(this, _QualityGateState_state, "f")[rule]?.testResults ?? [])];
+    }
+    markTestResultsProcessed(testResults) {
+        testResults.forEach(({ id }) => __classPrivateFieldGet(this, _QualityGateState_processedTestResultIds, "f").add(id));
+    }
+    isTestResultProcessed(trId) {
+        return __classPrivateFieldGet(this, _QualityGateState_processedTestResultIds, "f").has(trId);
     }
 }
-_QualityGateState_state = new WeakMap();
+_QualityGateState_state = new WeakMap(), _QualityGateState_processedTestResultIds = new WeakMap();
 export class QualityGate {
     constructor(config) {
         this.config = config;
     }
     async validate(payload) {
         const { state, trs, knownIssues, environment } = payload;
+        const trsToValidateById = new Map();
+        for (const tr of trs) {
+            if (tr.isRetry || state?.isTestResultProcessed(tr.id)) {
+                continue;
+            }
+            trsToValidateById.set(tr.id, tr);
+        }
+        const trsToValidate = trsToValidateById.values().toArray();
         const { rules, use = [...qualityGateDefaultRules] } = this.config;
         const results = [];
         let fastFailed = false;
@@ -58,6 +80,7 @@ export class QualityGate {
             if (fastFailed) {
                 break;
             }
+            const filteredTrs = ruleset.filter ? trsToValidate.filter(ruleset.filter) : trsToValidate;
             for (const [key, expected] of Object.entries(ruleset)) {
                 if (key === "filter" || key === "id" || key === "fastFail") {
                     continue;
@@ -66,13 +89,12 @@ export class QualityGate {
                 if (!rule) {
                     throw new Error(`Rule ${key} is not provided. Make sure you have provided it in the "use" field of the quality gate config!`);
                 }
-                const trsToValidate = ruleset.filter ? trs.filter(ruleset.filter) : trs;
                 const ruleId = ruleset.id ? [ruleset.id, rule.rule].join("/") : rule.rule;
                 const result = await rule.validate({
-                    trs: trsToValidate,
+                    trs: filteredTrs,
                     state: {
                         getResult: () => state?.getResult?.(ruleId),
-                        setResult: (value) => state?.setResult?.(ruleId, value),
+                        setResult: (value, testResults) => state?.setResult?.(ruleId, value, testResults),
                     },
                     expected,
                     knownIssues,
@@ -84,12 +106,13 @@ export class QualityGate {
                 results.push({
                     ...result,
                     expected,
-                    rule: ruleset.id ? [ruleset.id, rule.rule].join("/") : rule.rule,
+                    rule: ruleId,
                     message: rule.message({
                         actual: result.actual,
                         expected,
                     }),
                     environment,
+                    testResults: [...new Set([...(state?.getTestResults(ruleId) ?? []), ...result.testResults])],
                 });
                 if (ruleset.fastFail) {
                     fastFailed = true;
@@ -97,6 +120,7 @@ export class QualityGate {
                 }
             }
         }
+        state?.markTestResultsProcessed(trsToValidate);
         return {
             fastFailed,
             results,

package/dist/qualityGate/rules.d.ts

@@ -1,8 +1,16 @@
 import { type QualityGateRule } from "@allurereport/plugin-api";
 export declare const maxFailuresRule: QualityGateRule<number>;
 export declare const minTestsCountRule: QualityGateRule<number>;
-export declare const successRateRule: QualityGateRule<number>;
+export declare const successRateRule: QualityGateRule<number, {
+    totalCount: number;
+    unknownCount: number;
+    passedCount: number;
+}>;
 export declare const maxDurationRule: QualityGateRule<number>;
-export declare const allTestsContainEnvRule: QualityGateRule<string>;
+export declare const allTestsContainEnvRule: QualityGateRule<string, number>;
 export declare const environmentsTestedRule: QualityGateRule<string[]>;
-export declare const qualityGateDefaultRules: (QualityGateRule<number> | QualityGateRule<string> | QualityGateRule<string[]>)[];
+export declare const qualityGateDefaultRules: (QualityGateRule<number> | QualityGateRule<number, {
+    totalCount: number;
+    unknownCount: number;
+    passedCount: number;
+}> | QualityGateRule<string, number> | QualityGateRule<string[]>)[];

package/dist/qualityGate/rules.js

@@ -1,17 +1,19 @@
-import { filterSuccessful, filterUnknownByKnownIssues, filterUnsuccessful } from "@allurereport/core-api";
+import { filterSuccessful, filterUnsuccessful } from "@allurereport/core-api";
 import { bold } from "yoctocolors";
 export const maxFailuresRule = {
     rule: "maxFailures",
     message: ({ actual, expected }) => `The number of failed tests ${bold(String(actual))} exceeds the allowed threshold value ${bold(String(expected))}`,
-    validate: async ({ trs, knownIssues, expected, state }) => {
-        const knownIssuesHistoryIds = new Set(knownIssues.map(({ historyId }) => historyId));
-        const unknown = filterUnknownByKnownIssues(trs, knownIssuesHistoryIds);
+    validate: async ({ trs, expected, state }) => {
+        const previous = state.getResult() ?? 0;
+        const unknown = trs.filter((tr) => !tr.known);
         const failedTrs = unknown.filter(filterUnsuccessful);
-        const actual = failedTrs.length + (state.getResult() ?? 0);
-        state.setResult(actual);
+        const testResults = failedTrs.map((tr) => tr.id);
+        const actual = previous + failedTrs.length;
+        state.setResult(actual, testResults);
         return {
             success: actual <= expected,
             actual,
+            testResults,
         };
     },
 };
@@ -20,47 +22,64 @@ export const minTestsCountRule = {
     message: ({ actual, expected }) => `The total number of tests ${bold(String(actual))} is less than the expected threshold value ${bold(String(expected))}`,
     validate: async ({ trs, expected, state }) => {
         const actual = trs.length + (state.getResult() ?? 0);
-        state.setResult(actual);
+        state.setResult(actual, []);
         return {
             success: actual >= expected,
             actual,
+            testResults: [],
         };
     },
 };
 export const successRateRule = {
     rule: "successRate",
     message: ({ actual, expected }) => `Success rate ${bold(String(actual))} is less, than expected ${bold(String(expected))}`,
-    validate: async ({ trs, knownIssues, expected }) => {
-        const knownIssuesHistoryIds = new Set(knownIssues.map(({ historyId }) => historyId));
-        const unknown = filterUnknownByKnownIssues(trs, knownIssuesHistoryIds);
+    validate: async ({ trs, expected, state }) => {
+        const previous = state.getResult() ?? { totalCount: 0, unknownCount: 0, passedCount: 0 };
+        const unknown = trs.filter((tr) => !tr.known);
         const passedTrs = unknown.filter(filterSuccessful);
-        const rate = passedTrs.length === 0 ? 0 : passedTrs.length / unknown.length;
+        const notPassedTrs = unknown.filter((tr) => !filterSuccessful(tr));
+        const totalCount = previous.totalCount + trs.length;
+        const unknownCount = previous.unknownCount + unknown.length;
+        const passedCount = previous.passedCount + passedTrs.length;
+        const testResults = notPassedTrs.map((tr) => tr.id);
+        const rate = totalCount === 0 ? 0 : unknownCount === 0 ? 1 : passedCount / unknownCount;
+        state.setResult({ totalCount, unknownCount, passedCount }, testResults);
         return {
             success: rate >= expected,
             actual: rate,
+            testResults,
         };
     },
 };
 export const maxDurationRule = {
     rule: "maxDuration",
     message: ({ actual, expected }) => `Maximum duration of some tests exceed the defined limit; actual ${bold(String(actual))}, expected ${bold(String(expected))}`,
-    validate: async ({ trs, expected }) => {
-        const actual = Math.max(...trs.map((tr) => tr.duration ?? 0));
+    validate: async ({ trs, expected, state }) => {
+        const previous = state.getResult() ?? 0;
+        const actual = Math.max(previous, ...trs.map((tr) => tr.duration ?? 0));
+        const tooLongTrs = trs.filter((tr) => (tr.duration ?? 0) > expected);
+        const testResults = tooLongTrs.map((tr) => tr.id);
+        state.setResult(actual, testResults);
         return {
             success: actual <= expected,
             actual,
+            testResults,
         };
     },
 };
 export const allTestsContainEnvRule = {
     rule: "allTestsContainEnv",
-    message: ({ actual, expected }) => `Not all tests contain the required environment, ${bold(`"${expected}"`)}; ${bold(actual.length === 1 ? "one" : String(actual))} ${actual.length === 1 ? "test has" : "tests have"} different or missing environment`,
-    validate: async ({ trs, expected }) => {
+    message: ({ actual, expected }) => `Not all tests contain the required "${bold(expected)}" environment, ${bold(actual)} tests have different or missing environment`,
+    validate: async ({ trs, expected, state }) => {
+        const previous = state.getResult() ?? 0;
         const testsWithoutEnv = trs.filter((tr) => (tr.environment ?? "") !== expected);
-        const actual = testsWithoutEnv.length;
+        const testResults = testsWithoutEnv.map((tr) => tr.id);
+        const actual = testsWithoutEnv.length + previous;
+        state.setResult(actual, testResults);
         return {
             success: actual === 0,
             actual,
+            testResults,
         };
     },
 };
@@ -71,11 +90,12 @@ export const environmentsTestedRule = {
         const previouslyTested = new Set(state.getResult() ?? []);
         const batchTested = trs.map((tr) => tr.environment).filter((env) => env != null && env !== "");
         const testedEnvs = new Set([...previouslyTested, ...batchTested]);
-        state.setResult([...testedEnvs]);
+        state.setResult([...testedEnvs], []);
         const missing = expected.filter((env) => !testedEnvs.has(env));
         return {
             success: missing.length === 0,
             actual: missing,
+            testResults: [],
         };
     },
 };

package/dist/report.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 _AllureReport_instances, _AllureReport_ci, _AllureReport_store, _AllureReport_readers, _AllureReport_plugins, _AllureReport_reportFiles, _AllureReport_realtimeChannel, _AllureReport_realtimeUpdateScheduler, _AllureReport_realTime, _AllureReport_hideLabels, _AllureReport_output, _AllureReport_history, _AllureReport_allureServiceClient, _AllureReport_qualityGate, _AllureReport_dump, _AllureReport_categories, _AllureReport_environments, _AllureReport_globalAttachments, _AllureReport_dumpTempDirs, _AllureReport_state, _AllureReport_executionStage, _AllureReport_historyDataPoint, _AllureReport_summaryPath, _AllureReport_summariesByPluginId, _AllureReport_publishedRemoteHrefs, _AllureReport_published, _AllureReport_endGeneratePerfSpan, _AllureReport_publish, _AllureReport_runRealtimeUpdate, _AllureReport_getReportsToPublish, _AllureReport_cleanupFailedRemoteReport, _AllureReport_logPublishError, _AllureReport_applyPublishLinksToSummaries, _AllureReport_cloneSummariesByPluginId, _AllureReport_writeSummaryFiles, _AllureReport_generateRootSummary, _AllureReport_finishGeneratePerfSpan, _AllureReport_finishPerfMetrics, _AllureReport_eachPlugin, _AllureReport_getPluginState;
+var _AllureReport_instances, _AllureReport_ci, _AllureReport_store, _AllureReport_readers, _AllureReport_plugins, _AllureReport_reportFiles, _AllureReport_realtimeChannel, _AllureReport_realtimeUpdateScheduler, _AllureReport_realTime, _AllureReport_hideLabels, _AllureReport_output, _AllureReport_history, _AllureReport_appendHistory, _AllureReport_allureServiceClient, _AllureReport_qualityGate, _AllureReport_dump, _AllureReport_categories, _AllureReport_environments, _AllureReport_globalAttachments, _AllureReport_knownIssuesPath, _AllureReport_dumpTempDirs, _AllureReport_state, _AllureReport_executionStage, _AllureReport_historyDataPoint, _AllureReport_summaryPath, _AllureReport_testResultsRegistryPath, _AllureReport_summariesByPluginId, _AllureReport_publishedRemoteHrefs, _AllureReport_published, _AllureReport_endGeneratePerfSpan, _AllureReport_publish, _AllureReport_runRealtimeUpdate, _AllureReport_restoreStateDumps, _AllureReport_getReportsToPublish, _AllureReport_cleanupFailedRemoteReport, _AllureReport_logPublishError, _AllureReport_applyPublishLinksToSummaries, _AllureReport_cloneSummariesByPluginId, _AllureReport_writeSummaryFiles, _AllureReport_writeTestResultRegistry, _AllureReport_generateRootSummary, _AllureReport_finishGeneratePerfSpan, _AllureReport_finishPerfMetrics, _AllureReport_eachPlugin, _AllureReport_getPluginState;
 import console from "node:console";
 import { randomUUID } from "node:crypto";
 import { once } from "node:events";
@@ -19,8 +19,9 @@ import { tmpdir } from "node:os";
 import { basename, dirname, join, resolve, sep } from "node:path";
 import { promisify } from "node:util";
 import { detect } from "@allurereport/ci";
+import { createProgressLogger } from "@allurereport/cli-commons";
 import { normalizeCategoriesConfig } from "@allurereport/core-api";
-import { AllureStoreDumpFiles, } from "@allurereport/plugin-api";
+import { AllureStoreDumpFiles, createTestResultRegistry, } from "@allurereport/plugin-api";
 import { allure1, allure2, attachments, cucumberjson, junitXml, readXcResultBundle } from "@allurereport/reader";
 import { PathResultFile } from "@allurereport/reader-api";
 import { AllureRemoteHistory, AllureServiceClient, AllureTestOpsClient, KnownError, UnknownError, } from "@allurereport/service";
@@ -30,6 +31,7 @@ import ZipReadStream from "node-stream-zip";
 import pLimit from "p-limit";
 import ZipWriteStream from "zip-stream";
 import { AllureLocalHistory, createHistory } from "./history.js";
+import { writeKnownIssues } from "./known.js";
 import { DefaultPluginState, PluginFiles } from "./plugin.js";
 import { QualityGate } from "./qualityGate/index.js";
 import { DefaultAllureStore } from "./store/store.js";
@@ -42,6 +44,7 @@ const { version } = JSON.parse(readFileSync(new URL("../package.json", import.me
 const INIT_REQUIRED_ERROR_MESSAGE = "report is not initialised. Call the start() method first.";
 const DEFAULT_READ_CONCURRENCY = 64;
 const MAX_READ_CONCURRENCY = 256;
+const TEST_RESULTS_REGISTRY_FILENAME = "test-results.json";
 const readConcurrency = () => {
     const parsed = Number.parseInt(process.env.ALLURE_READ_CONCURRENCY ?? "", 10);
     if (!Number.isFinite(parsed)) {
@@ -80,17 +83,20 @@ export class AllureReport {
         _AllureReport_hideLabels.set(this, void 0);
         _AllureReport_output.set(this, void 0);
         _AllureReport_history.set(this, void 0);
+        _AllureReport_appendHistory.set(this, void 0);
         _AllureReport_allureServiceClient.set(this, void 0);
         _AllureReport_qualityGate.set(this, void 0);
         _AllureReport_dump.set(this, void 0);
         _AllureReport_categories.set(this, void 0);
         _AllureReport_environments.set(this, void 0);
         _AllureReport_globalAttachments.set(this, void 0);
+        _AllureReport_knownIssuesPath.set(this, void 0);
         _AllureReport_dumpTempDirs.set(this, []);
         _AllureReport_state.set(this, void 0);
         _AllureReport_executionStage.set(this, "init");
         _AllureReport_historyDataPoint.set(this, void 0);
         _AllureReport_summaryPath.set(this, void 0);
+        _AllureReport_testResultsRegistryPath.set(this, void 0);
         _AllureReport_summariesByPluginId.set(this, new Map());
         _AllureReport_publishedRemoteHrefs.set(this, new Set());
         _AllureReport_published.set(this, false);
@@ -109,6 +115,7 @@ export class AllureReport {
                 historyPoint = createHistory(this.reportUuid, this.reportName, allTcs, allTrs, this.reportUrl);
                 __classPrivateFieldSet(this, _AllureReport_historyDataPoint, historyPoint, "f");
             }
+            await __classPrivateFieldGet(this, _AllureReport_writeTestResultRegistry, "f").call(this);
             await __classPrivateFieldGet(this, _AllureReport_writeSummaryFiles, "f").call(this);
             await __classPrivateFieldGet(this, _AllureReport_generateRootSummary, "f").call(this);
             if (__classPrivateFieldGet(this, _AllureReport_realTime, "f") || !__classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f")) {
@@ -124,33 +131,21 @@ export class AllureReport {
             const linksByPluginId = {};
             const summariesSnapshot = __classPrivateFieldGet(this, _AllureReport_cloneSummariesByPluginId, "f").call(this);
             const uploadProgressMessage = reportsToPublish.length === 1 ? `Publishing "${reportsToPublish[0].pluginId}" report` : "Publishing reports";
-            const totalFilesToUpload = reportsToPublish.reduce((acc, report) => acc + Object.keys(report.files).length, 0);
-            const progressStep = Math.max(1, Math.ceil(totalFilesToUpload / 20));
+            const totalFilesToUpload = reportsToPublish.reduce((acc, report) => acc + Object.keys(report.files).length, 0) +
+                (__classPrivateFieldGet(this, _AllureReport_testResultsRegistryPath, "f") ? 1 : 0);
             let summariesMutated = false;
             let reportCreated = false;
             let publishErrorMessage = "Report upload has failed, the report won't be published";
-            let uploadedFiles = 0;
-            let nextProgressLogAt = 0;
-            let lastProgressLog = -1;
+            const progressLogger = createProgressLogger({
+                total: totalFilesToUpload,
+                message: uploadProgressMessage,
+                unitLabel: "files uploaded",
+                prefix: "[AllureReport]",
+                silent: !!__classPrivateFieldGet(this, _AllureReport_realTime, "f"),
+            });
             const endPublishPerfSpan = startPerfSpan(PERF_METRIC_NAMES.publishUploadTotal);
-            const logUploadProgress = (force = false) => {
-                if (force && uploadedFiles === lastProgressLog) {
-                    return;
-                }
-                if (!force && uploadedFiles < nextProgressLogAt && uploadedFiles !== totalFilesToUpload) {
-                    return;
-                }
-                if (!force && uploadedFiles === lastProgressLog) {
-                    return;
-                }
-                console.info(`[AllureReport]: ${uploadProgressMessage}: ${uploadedFiles}/${totalFilesToUpload} files uploaded`);
-                lastProgressLog = uploadedFiles;
-                nextProgressLogAt = Math.min(totalFilesToUpload, uploadedFiles + progressStep);
-            };
-            const incrementUploadProgress = (delta = 1) => {
-                uploadedFiles = Math.min(totalFilesToUpload, uploadedFiles + delta);
-                logUploadProgress();
-            };
+            const logUploadProgress = progressLogger.log;
+            const incrementUploadProgress = progressLogger.increment;
             try {
                 logUploadProgress(true);
                 await client.createReport({
@@ -172,6 +167,14 @@ export class AllureReport {
                         linksByPluginId[report.pluginId] = uploadResult.indexHref;
                     }
                 }
+                if (__classPrivateFieldGet(this, _AllureReport_testResultsRegistryPath, "f")) {
+                    publishErrorMessage = "Test results registry upload has failed, the report won't be published";
+                    await client.uploadReport({
+                        reportUuid: this.reportUuid,
+                        files: { [TEST_RESULTS_REGISTRY_FILENAME]: __classPrivateFieldGet(this, _AllureReport_testResultsRegistryPath, "f") },
+                        onProgress: incrementUploadProgress,
+                    });
+                }
                 const changedPluginIds = __classPrivateFieldGet(this, _AllureReport_applyPublishLinksToSummaries, "f").call(this, linksByPluginId);
                 summariesMutated = changedPluginIds.size > 0;
                 if (changedPluginIds.size > 0) {
@@ -225,6 +228,7 @@ export class AllureReport {
                 __classPrivateFieldGet(this, _AllureReport_logPublishError, "f").call(this, publishErrorMessage, err);
             }
             finally {
+                progressLogger.cancel?.();
                 endPublishPerfSpan();
             }
         });
@@ -238,7 +242,7 @@ export class AllureReport {
             }
             try {
                 const entries = (await readdir(resultsDirPath, { withFileTypes: true }))
-                    .filter((dirent) => dirent.isFile())
+                    .filter((dirent) => dirent.isFile() && !dirent.name.endsWith(".tmp"))
                     .sort((a, b) => a.name.localeCompare(b.name));
                 const limit = pLimit(readConcurrency());
                 await Promise.all(entries.map((dirent) => limit(async () => {
@@ -280,6 +284,11 @@ export class AllureReport {
         };
         this.validate = async (params) => {
             const { trs, knownIssues, state, environment } = params;
+            const currentKnownIssues = await __classPrivateFieldGet(this, _AllureReport_store, "f").allKnownIssues();
+            const effectiveKnownIssues = new Map();
+            [...knownIssues, ...currentKnownIssues].forEach((issue) => {
+                effectiveKnownIssues.set(issue.historyId, issue);
+            });
             const qualityGateEnvironment = environment === undefined
                 ? undefined
                 : (environmentIdentityById(__classPrivateFieldGet(this, _AllureReport_environments, "f"), environment)?.name ??
@@ -287,7 +296,7 @@ export class AllureReport {
                     environment);
             return __classPrivateFieldGet(this, _AllureReport_qualityGate, "f").validate({
                 trs: trs.filter(Boolean),
-                knownIssues,
+                knownIssues: [...effectiveKnownIssues.values()],
                 state,
                 environment: qualityGateEnvironment,
             });
@@ -384,7 +393,7 @@ export class AllureReport {
             const addJsonDumpEntry = async (entryName, value) => {
                 await addRequiredDumpEntry(Buffer.from(JSON.stringify(value)), entryName);
             };
-            const dumpJsonEntries = ({ testResults, testCases, fixtures, attachments, environments, reportVariables, checkResults = {}, globalAttachmentIds = [], globalErrors = [], indexAttachmentByTestResult = {}, indexTestResultByHistoryId = {}, indexTestResultByTestCase = {}, indexAttachmentByFixture = {}, indexFixturesByTestResult = {}, indexKnownByHistoryId = {}, qualityGateResults = [], testResultIdsIngestOrder = [], }) => [
+            const dumpJsonEntries = ({ testResults, testCases, fixtures, attachments, environments, reportVariables, checkResults = {}, globalAttachmentIds = [], globalErrors = [], indexAttachmentByTestResult = {}, indexTestResultByHistoryId = {}, indexTestResultByTestCase = {}, indexAttachmentByFixture = {}, indexFixturesByTestResult = {}, knownIssues = {}, qualityGateResults = [], testResultIdsIngestOrder = [], }) => [
                 [AllureStoreDumpFiles.TestResults, testResults],
                 [AllureStoreDumpFiles.TestCases, testCases],
                 [AllureStoreDumpFiles.Fixtures, fixtures],
@@ -392,6 +401,7 @@ export class AllureReport {
                 [AllureStoreDumpFiles.CheckResults, checkResults],
                 [AllureStoreDumpFiles.Environments, environments],
                 [AllureStoreDumpFiles.ReportVariables, reportVariables],
+                [AllureStoreDumpFiles.KnownIssues, knownIssues],
                 [AllureStoreDumpFiles.GlobalAttachments, globalAttachmentIds],
                 [AllureStoreDumpFiles.GlobalErrors, globalErrors],
                 [AllureStoreDumpFiles.IndexAttachmentsByTestResults, indexAttachmentByTestResult],
@@ -399,7 +409,6 @@ export class AllureReport {
                 [AllureStoreDumpFiles.IndexTestResultsByTestCase, indexTestResultByTestCase],
                 [AllureStoreDumpFiles.IndexAttachmentsByFixture, indexAttachmentByFixture],
                 [AllureStoreDumpFiles.IndexFixturesByTestResult, indexFixturesByTestResult],
-                [AllureStoreDumpFiles.IndexKnownByHistoryId, indexKnownByHistoryId],
                 [AllureStoreDumpFiles.QualityGateResults, qualityGateResults],
                 [AllureStoreDumpFiles.TestResultIngestOrder, testResultIdsIngestOrder],
             ];
@@ -467,7 +476,11 @@ export class AllureReport {
             }
             await rename(dumpTempPath, dumpPath);
         };
-        this.restoreState = async (dumps) => measurePerf(PERF_METRIC_NAMES.restoreStateTotal, async () => {
+        this.restoreState = async (dumps) => {
+            __classPrivateFieldGet(this, _AllureReport_store, "f").resetIngestOrder();
+            await __classPrivateFieldGet(this, _AllureReport_restoreStateDumps, "f").call(this, dumps);
+        };
+        _AllureReport_restoreStateDumps.set(this, async (dumps) => measurePerf(PERF_METRIC_NAMES.restoreStateTotal, async () => {
             for (const dump of dumps) {
                 await measurePerf(PERF_METRIC_NAMES.restoreStateDump, async () => {
                     if (!existsSync(dump)) {
@@ -504,7 +517,7 @@ export class AllureReport {
                                         await writeFile(nestedDumpPath, await dumpArchive.entryData(entryName));
                                         nestedDumpPaths.push(nestedDumpPath);
                                     }
-                                    await this.restoreState(nestedDumpPaths);
+                                    await __classPrivateFieldGet(this, _AllureReport_restoreStateDumps, "f").call(this, nestedDumpPaths);
                                     return;
                                 }
                             }
@@ -522,7 +535,7 @@ export class AllureReport {
                             const indexTestResultsByTestCaseEntry = await requiredEntryData(AllureStoreDumpFiles.IndexTestResultsByTestCase);
                             const indexAttachmentsByFixtureEntry = await requiredEntryData(AllureStoreDumpFiles.IndexAttachmentsByFixture);
                             const indexFixturesByTestResultEntry = await requiredEntryData(AllureStoreDumpFiles.IndexFixturesByTestResult);
-                            const indexKnownByHistoryIdEntry = await requiredEntryData(AllureStoreDumpFiles.IndexKnownByHistoryId);
+                            const knownIssuesEntry = await requiredEntryData(AllureStoreDumpFiles.KnownIssues);
                             const qualityGateResultsEntry = await requiredEntryData(AllureStoreDumpFiles.QualityGateResults);
                             const testResultIngestOrderEntry = await optionalEntryData(AllureStoreDumpFiles.TestResultIngestOrder);
                             const attachmentsLinks = JSON.parse(attachmentsEntry.toString("utf8"));
@@ -535,6 +548,7 @@ export class AllureReport {
                                     case AllureStoreDumpFiles.Fixtures:
                                     case AllureStoreDumpFiles.Environments:
                                     case AllureStoreDumpFiles.ReportVariables:
+                                    case AllureStoreDumpFiles.KnownIssues:
                                     case AllureStoreDumpFiles.GlobalAttachments:
                                     case AllureStoreDumpFiles.GlobalErrors:
                                     case AllureStoreDumpFiles.IndexAttachmentsByTestResults:
@@ -542,7 +556,6 @@ export class AllureReport {
                                     case AllureStoreDumpFiles.IndexTestResultsByTestCase:
                                     case AllureStoreDumpFiles.IndexAttachmentsByFixture:
                                     case AllureStoreDumpFiles.IndexFixturesByTestResult:
-                                    case AllureStoreDumpFiles.IndexKnownByHistoryId:
                                     case AllureStoreDumpFiles.QualityGateResults:
                                     case AllureStoreDumpFiles.TestResultIngestOrder:
                                         return acc;
@@ -570,7 +583,7 @@ export class AllureReport {
                                 indexTestResultByTestCase: JSON.parse(indexTestResultsByTestCaseEntry.toString("utf8")),
                                 indexAttachmentByFixture: JSON.parse(indexAttachmentsByFixtureEntry.toString("utf8")),
                                 indexFixturesByTestResult: JSON.parse(indexFixturesByTestResultEntry.toString("utf8")),
-                                indexKnownByHistoryId: JSON.parse(indexKnownByHistoryIdEntry.toString("utf8")),
+                                knownIssues: JSON.parse(knownIssuesEntry.toString("utf8")),
                                 qualityGateResults: JSON.parse(qualityGateResultsEntry.toString("utf8")),
                                 testResultIdsIngestOrder: testResultIngestOrderEntry
                                     ? JSON.parse(testResultIngestOrderEntry.toString("utf8"))
@@ -624,7 +637,7 @@ export class AllureReport {
                     }
                 });
             }
-        });
+        }));
         _AllureReport_getReportsToPublish.set(this, async () => {
             const reports = [];
             for (const { enabled, id, options } of __classPrivateFieldGet(this, _AllureReport_plugins, "f")) {
@@ -691,6 +704,11 @@ export class AllureReport {
                 await context.reportFiles.addFile("summary.json", Buffer.from(JSON.stringify(summary)));
             });
         });
+        _AllureReport_writeTestResultRegistry.set(this, async () => {
+            const testResults = await __classPrivateFieldGet(this, _AllureReport_store, "f").allTestResults({ includeRetries: false });
+            const registry = createTestResultRegistry(testResults);
+            __classPrivateFieldSet(this, _AllureReport_testResultsRegistryPath, await __classPrivateFieldGet(this, _AllureReport_reportFiles, "f").addFile(TEST_RESULTS_REGISTRY_FILENAME, Buffer.from(JSON.stringify(registry))), "f");
+        });
         _AllureReport_generateRootSummary.set(this, async () => {
             const summaries = [...__classPrivateFieldGet(this, _AllureReport_summariesByPluginId, "f").values()].map(clonePluginSummary);
             if (summaries.length > 1) {
@@ -751,16 +769,21 @@ export class AllureReport {
                     outputDirFiles = await readdir(__classPrivateFieldGet(this, _AllureReport_output, "f"));
                 }
                 catch { }
+                if (__classPrivateFieldGet(this, _AllureReport_knownIssuesPath, "f")) {
+                    await writeKnownIssues(__classPrivateFieldGet(this, _AllureReport_store, "f"), __classPrivateFieldGet(this, _AllureReport_knownIssuesPath, "f"));
+                }
                 if (outputDirFiles.length === 0) {
                     return;
                 }
-                const reportPath = join(__classPrivateFieldGet(this, _AllureReport_output, "f"), outputDirFiles[0]);
-                const reportStats = await lstat(reportPath);
-                const outputEntriesStats = await Promise.all(outputDirFiles.map((file) => lstat(join(__classPrivateFieldGet(this, _AllureReport_output, "f"), file))));
-                const outputDirectoryEntries = outputEntriesStats.filter((entry) => entry.isDirectory());
-                if (reportStats.isDirectory() && outputDirectoryEntries.length === 1) {
+                const outputEntries = await Promise.all(outputDirFiles.map(async (file) => ({ file, stats: await lstat(join(__classPrivateFieldGet(this, _AllureReport_output, "f"), file)) })));
+                const outputDirectoryEntries = outputEntries.filter(({ stats }) => stats.isDirectory());
+                if (outputDirectoryEntries.length === 1) {
+                    const reportPath = join(__classPrivateFieldGet(this, _AllureReport_output, "f"), outputDirectoryEntries[0].file);
                     const reportContent = await readdir(reportPath);
                     for (const entry of reportContent) {
+                        if (entry === TEST_RESULTS_REGISTRY_FILENAME) {
+                            continue;
+                        }
                         const currentFilePath = join(reportPath, entry);
                         const newFilePath = resolve(dirname(currentFilePath), "..", entry);
                         await rename(currentFilePath, newFilePath);
@@ -773,7 +796,7 @@ export class AllureReport {
                     }
                     catch { }
                 }
-                if (__classPrivateFieldGet(this, _AllureReport_history, "f")) {
+                if (__classPrivateFieldGet(this, _AllureReport_history, "f") && __classPrivateFieldGet(this, _AllureReport_appendHistory, "f")) {
                     try {
                         await __classPrivateFieldGet(this, _AllureReport_store, "f").appendHistory(__classPrivateFieldGet(this, _AllureReport_historyDataPoint, "f"));
                     }
@@ -870,7 +893,7 @@ export class AllureReport {
                 }
             }
         });
-        const { name, readers = [allure1, allure2, cucumberjson, junitXml, attachments], plugins = [], known, reportFiles, realTime, historyPath, historyLimit, defaultLabels = {}, variables = {}, environment, allowedEnvironments, environments, output, hideLabels, qualityGate, dump, categories, allureService, globalAttachments, } = opts;
+        const { name, readers = [allure1, allure2, cucumberjson, junitXml, attachments], plugins = [], known, knownIssues, knownIssuesPath, reportFiles, realTime, historyPath, historyLimit, appendHistory, defaultLabels = {}, variables = {}, environment, allowedEnvironments, environments, output, hideLabels, qualityGate, dump, categories, allureService, globalAttachments, } = opts;
         const allureServiceAccessToken = allureService?.accessToken;
         if (allureServiceAccessToken) {
             const allureServiceClientConfig = {
@@ -894,6 +917,8 @@ export class AllureReport {
         __classPrivateFieldSet(this, _AllureReport_hideLabels, hideLabels, "f");
         __classPrivateFieldSet(this, _AllureReport_environments, environments ?? {}, "f");
         __classPrivateFieldSet(this, _AllureReport_globalAttachments, globalAttachments, "f");
+        __classPrivateFieldSet(this, _AllureReport_appendHistory, appendHistory ?? true, "f");
+        __classPrivateFieldSet(this, _AllureReport_knownIssuesPath, knownIssuesPath, "f");
         if (qualityGate) {
             __classPrivateFieldSet(this, _AllureReport_qualityGate, new QualityGate(qualityGate), "f");
         }
@@ -918,6 +943,7 @@ export class AllureReport {
             environmentsConfig: environments,
             history: __classPrivateFieldGet(this, _AllureReport_history, "f"),
             known,
+            knownIssuesConfig: knownIssues,
             defaultLabels,
             environment,
             allowedEnvironments,
@@ -940,6 +966,6 @@ export class AllureReport {
         return __classPrivateFieldGet(this, _AllureReport_realtimeChannel, "f").dispatcher;
     }
 }
-_AllureReport_ci = new WeakMap(), _AllureReport_store = new WeakMap(), _AllureReport_readers = new WeakMap(), _AllureReport_plugins = new WeakMap(), _AllureReport_reportFiles = new WeakMap(), _AllureReport_realtimeChannel = new WeakMap(), _AllureReport_realtimeUpdateScheduler = new WeakMap(), _AllureReport_realTime = new WeakMap(), _AllureReport_hideLabels = new WeakMap(), _AllureReport_output = new WeakMap(), _AllureReport_history = new WeakMap(), _AllureReport_allureServiceClient = new WeakMap(), _AllureReport_qualityGate = new WeakMap(), _AllureReport_dump = new WeakMap(), _AllureReport_categories = new WeakMap(), _AllureReport_environments = new WeakMap(), _AllureReport_globalAttachments = new WeakMap(), _AllureReport_dumpTempDirs = new WeakMap(), _AllureReport_state = new WeakMap(), _AllureReport_executionStage = new WeakMap(), _AllureReport_historyDataPoint = new WeakMap(), _AllureReport_summaryPath = new WeakMap(), _AllureReport_summariesByPluginId = new WeakMap(), _AllureReport_publishedRemoteHrefs = new WeakMap(), _AllureReport_published = new WeakMap(), _AllureReport_endGeneratePerfSpan = new WeakMap(), _AllureReport_publish = new WeakMap(), _AllureReport_runRealtimeUpdate = new WeakMap(), _AllureReport_getReportsToPublish = new WeakMap(), _AllureReport_cleanupFailedRemoteReport = new WeakMap(), _AllureReport_logPublishError = new WeakMap(), _AllureReport_applyPublishLinksToSummaries = new WeakMap(), _AllureReport_cloneSummariesByPluginId = new WeakMap(), _AllureReport_writeSummaryFiles = new WeakMap(), _AllureReport_generateRootSummary = new WeakMap(), _AllureReport_finishGeneratePerfSpan = new WeakMap(), _AllureReport_finishPerfMetrics = new WeakMap(), _AllureReport_eachPlugin = new WeakMap(), _AllureReport_instances = new WeakSet(), _AllureReport_getPluginState = function _AllureReport_getPluginState(init, id) {
+_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_appendHistory = 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_knownIssuesPath = new WeakMap(), _AllureReport_dumpTempDirs = new WeakMap(), _AllureReport_state = new WeakMap(), _AllureReport_executionStage = new WeakMap(), _AllureReport_historyDataPoint = new WeakMap(), _AllureReport_summaryPath = new WeakMap(), _AllureReport_testResultsRegistryPath = new WeakMap(), _AllureReport_summariesByPluginId = new WeakMap(), _AllureReport_publishedRemoteHrefs = new WeakMap(), _AllureReport_published = new WeakMap(), _AllureReport_endGeneratePerfSpan = new WeakMap(), _AllureReport_publish = new WeakMap(), _AllureReport_runRealtimeUpdate = new WeakMap(), _AllureReport_restoreStateDumps = new WeakMap(), _AllureReport_getReportsToPublish = new WeakMap(), _AllureReport_cleanupFailedRemoteReport = new WeakMap(), _AllureReport_logPublishError = new WeakMap(), _AllureReport_applyPublishLinksToSummaries = new WeakMap(), _AllureReport_cloneSummariesByPluginId = new WeakMap(), _AllureReport_writeSummaryFiles = new WeakMap(), _AllureReport_writeTestResultRegistry = new WeakMap(), _AllureReport_generateRootSummary = new WeakMap(), _AllureReport_finishGeneratePerfSpan = new WeakMap(), _AllureReport_finishPerfMetrics = new WeakMap(), _AllureReport_eachPlugin = new WeakMap(), _AllureReport_instances = new WeakSet(), _AllureReport_getPluginState = function _AllureReport_getPluginState(init, id) {
     return init ? new DefaultPluginState({}) : __classPrivateFieldGet(this, _AllureReport_state, "f")?.[id];
 };

package/dist/store/convert.js

@@ -236,7 +236,7 @@ const convertLink = (link) => ({
     type: link.type,
 });
 const calculateTestId = (raw) => {
-    const maybeAllureId = raw.labels?.find((label) => label.name === "ALLURE_ID" || label.name === "AS_ID")?.value;
+    const maybeAllureId = raw.labels?.find((label) => (label.name === "ALLURE_ID" || label.name === "AS_ID") && label.value !== "-1")?.value;
     if (maybeAllureId) {
         return [md5(`ALLURE_ID=${maybeAllureId}`), maybeAllureId];
     }

package/dist/store/retrySubstore.d.ts

@@ -4,6 +4,7 @@ export declare const calculateRetryHash: (testCaseId: string | undefined, parame
 export declare class RetrySubstore {
     #private;
     recordIngestOrder(testResultId: string): void;
+    resetIngestOrder(): void;
     restoreIngestOrder(restoredIds: string[] | undefined, hasTestResult: (testResultId: string) => boolean): void;
     ingestOrderIdsForDump(): string[];
     upsert(testResult: TestResult): void;

package/dist/store/retrySubstore.js

@@ -31,8 +31,10 @@ export class RetrySubstore {
         }
         __classPrivateFieldGet(this, _RetrySubstore_testResultIngestIndexById, "f").set(testResultId, __classPrivateFieldGet(this, _RetrySubstore_testResultIngestIndexById, "f").size);
     }
-    restoreIngestOrder(restoredIds, hasTestResult) {
+    resetIngestOrder() {
         __classPrivateFieldGet(this, _RetrySubstore_testResultIngestIndexById, "f").clear();
+    }
+    restoreIngestOrder(restoredIds, hasTestResult) {
         for (const id of restoredIds ?? []) {
             if (!hasTestResult(id) || __classPrivateFieldGet(this, _RetrySubstore_testResultIngestIndexById, "f").has(id)) {
                 continue;

package/dist/store/store.d.ts

@@ -1,20 +1,21 @@
-import { type AllureCheckResult, type AllureHistory, type AttachmentLink, type DefaultLabelsConfig, type EnvironmentIdentity, type EnvironmentsConfig, type GlobalAttachmentLink, 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 GlobalAttachmentLink, type HistoryDataPoint, type HistoryTestResult, type KnownIssuesConfig, 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 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>;
 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 {
     #private;
+    readonly known: Map<string, KnownTestFailure>;
     readonly indexTestResultByTestCase: Map<string, TestResult[]>;
     readonly indexTestResultByEnvironmentId: Map<string, TestResult[]>;
     readonly indexTestResultByHistoryId: Map<string, TestResult[]>;
     readonly indexAttachmentByTestResult: Map<string, AttachmentLink[]>;
     readonly indexAttachmentByFixture: Map<string, AttachmentLink[]>;
     readonly indexFixturesByTestResult: Map<string, TestFixtureResult[]>;
-    readonly indexKnownByHistoryId: Map<string, KnownTestFailure[]>;
     constructor(params?: {
         history?: AllureHistory;
         known?: KnownTestFailure[];
+        knownIssuesConfig?: KnownIssuesConfig;
         realtimeDispatcher?: RealtimeEventsDispatcher;
         realtimeSubscriber?: RealtimeSubscriber;
         defaultLabels?: DefaultLabelsConfig;
@@ -68,6 +69,7 @@ export declare class DefaultAllureStore implements AllureStore, ResultsVisitor {
     attachmentsByTrId(trId: string): Promise<AttachmentLink[]>;
     retriesByTr(tr?: TestResult): Promise<TestResult[]>;
     retriesByTrId(trId: string): Promise<TestResult[]>;
+    resetIngestOrder(): void;
     historyByTr(tr: TestResult): Promise<HistoryTestResult[] | undefined>;
     historyByTrId(trId: string): Promise<HistoryTestResult[] | undefined>;
     fixturesByTrId(trId: string): Promise<TestFixtureResult[]>;
@@ -78,6 +80,7 @@ export declare class DefaultAllureStore implements AllureStore, ResultsVisitor {
         retriesByTrId: Map<string, TestResult[]>;
     }>;
     failedTestResults(): Promise<TestResult[]>;
+    blockingFailedTestResults(): Promise<TestResult[]>;
     unknownFailedTestResults(): Promise<TestResult[]>;
     testResultsByLabel(labelName: string): Promise<{
         _: TestResult[];

package/dist/store/store.js

@@ -9,10 +9,11 @@ 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_retrySubstore, _DefaultAllureStore_testResultIdsByEnvironmentId, _DefaultAllureStore_cachedEnvironmentEntries, _DefaultAllureStore_globalAttachmentIds, _DefaultAllureStore_globalAttachmentIdsByEnv, _DefaultAllureStore_globalErrors, _DefaultAllureStore_globalErrorsByEnv, _DefaultAllureStore_globalExitCode, _DefaultAllureStore_checkResultsById, _DefaultAllureStore_qualityGateResults, _DefaultAllureStore_historyPoints, _DefaultAllureStore_environments, _DefaultAllureStore_mergeEnvironmentIdentity, _DefaultAllureStore_environmentIdForLookup, _DefaultAllureStore_addEnvironments, _DefaultAllureStore_environmentIdByName, _DefaultAllureStore_setTestResultEnvironmentId, _DefaultAllureStore_assertAllowedEnvironmentId, _DefaultAllureStore_assertAllowedStoredEnvironment, _DefaultAllureStore_environmentIdByTestResult, _DefaultAllureStore_assignRetryHash, _DefaultAllureStore_rebuildRetrySubstore, _DefaultAllureStore_resolveGlobalEnvironmentIdentity, _DefaultAllureStore_globalAttachmentId, _DefaultAllureStore_indexGlobalError, _DefaultAllureStore_addGlobalError, _DefaultAllureStore_indexGlobalAttachment, _DefaultAllureStore_addGlobalAttachment, _DefaultAllureStore_restoreAttachmentContent, _DefaultAllureStore_relinkRestoredAttachmentSteps, _DefaultAllureStore_retriesByTr, _DefaultAllureStore_historyByTr;
+var _DefaultAllureStore_instances, _DefaultAllureStore_testResults, _DefaultAllureStore_environmentDisplayNames, _DefaultAllureStore_environmentNameToId, _DefaultAllureStore_attachments, _DefaultAllureStore_attachmentContents, _DefaultAllureStore_testCases, _DefaultAllureStore_metadata, _DefaultAllureStore_history, _DefaultAllureStore_knownIssuesConfig, _DefaultAllureStore_fixtures, _DefaultAllureStore_defaultLabels, _DefaultAllureStore_environment, _DefaultAllureStore_environmentsConfig, _DefaultAllureStore_reportVariables, _DefaultAllureStore_realtimeDispatcher, _DefaultAllureStore_realtimeSubscriber, _DefaultAllureStore_allowedEnvironmentIds, _DefaultAllureStore_retrySubstore, _DefaultAllureStore_testResultIdsByEnvironmentId, _DefaultAllureStore_cachedEnvironmentEntries, _DefaultAllureStore_globalAttachmentIds, _DefaultAllureStore_globalAttachmentIdsByEnv, _DefaultAllureStore_globalErrors, _DefaultAllureStore_globalErrorsByEnv, _DefaultAllureStore_globalExitCode, _DefaultAllureStore_checkResultsById, _DefaultAllureStore_qualityGateResults, _DefaultAllureStore_historyPoints, _DefaultAllureStore_environments, _DefaultAllureStore_historyIdMatches, _DefaultAllureStore_mergeEnvironmentIdentity, _DefaultAllureStore_environmentIdForLookup, _DefaultAllureStore_addEnvironments, _DefaultAllureStore_environmentIdByName, _DefaultAllureStore_setTestResultEnvironmentId, _DefaultAllureStore_assertAllowedEnvironmentId, _DefaultAllureStore_assertAllowedStoredEnvironment, _DefaultAllureStore_environmentIdByTestResult, _DefaultAllureStore_assignRetryHash, _DefaultAllureStore_setKnownIssue, _DefaultAllureStore_classifyKnownIssue, _DefaultAllureStore_rebuildRetrySubstore, _DefaultAllureStore_resolveGlobalEnvironmentIdentity, _DefaultAllureStore_globalAttachmentId, _DefaultAllureStore_indexGlobalError, _DefaultAllureStore_addGlobalError, _DefaultAllureStore_indexGlobalAttachment, _DefaultAllureStore_addGlobalAttachment, _DefaultAllureStore_restoreAttachmentContent, _DefaultAllureStore_relinkRestoredAttachmentSteps, _DefaultAllureStore_retriesByTr, _DefaultAllureStore_historyByTr;
 import { extname } from "node:path";
 import { DEFAULT_ENVIRONMENT, DEFAULT_ENVIRONMENT_IDENTITY, compareBy, createDictionary, getHistoryIdCandidates, getWorstStatus, normalizeHistoryDataPoint, ordinal, reverse, selectHistoryTestResults, validateEnvironmentId, validateEnvironmentName, } from "@allurereport/core-api";
 import { md5, } from "@allurereport/plugin-api";
+import { getKnownIssueByRules } from "../known.js";
 import { environmentIdentityById, normalizeEnvironmentDescriptorMap, resolveEnvironmentIdentity, resolveStoredEnvironmentIdentity, validateAllowedEnvironmentId, } from "../utils/environment.js";
 import { isFlaky } from "../utils/flaky.js";
 import { getStatusTransition } from "../utils/new.js";
@@ -63,7 +64,8 @@ export class DefaultAllureStore {
         _DefaultAllureStore_testCases.set(this, void 0);
         _DefaultAllureStore_metadata.set(this, void 0);
         _DefaultAllureStore_history.set(this, void 0);
-        _DefaultAllureStore_known.set(this, void 0);
+        _DefaultAllureStore_knownIssuesConfig.set(this, void 0);
+        this.known = new Map();
         _DefaultAllureStore_fixtures.set(this, void 0);
         _DefaultAllureStore_defaultLabels.set(this, {});
         _DefaultAllureStore_environment.set(this, void 0);
@@ -81,7 +83,6 @@ export class DefaultAllureStore {
         this.indexAttachmentByTestResult = new Map();
         this.indexAttachmentByFixture = new Map();
         this.indexFixturesByTestResult = new Map();
-        this.indexKnownByHistoryId = new Map();
         _DefaultAllureStore_globalAttachmentIds.set(this, []);
         _DefaultAllureStore_globalAttachmentIdsByEnv.set(this, new Map());
         _DefaultAllureStore_globalErrors.set(this, []);
@@ -91,7 +92,7 @@ export class DefaultAllureStore {
         _DefaultAllureStore_qualityGateResults.set(this, []);
         _DefaultAllureStore_historyPoints.set(this, []);
         _DefaultAllureStore_environments.set(this, []);
-        const { history, known = [], realtimeDispatcher, realtimeSubscriber, defaultLabels = {}, environment, allowedEnvironments, environmentsConfig = {}, reportVariables = {}, } = params ?? {};
+        const { history, known = [], knownIssuesConfig, realtimeDispatcher, realtimeSubscriber, defaultLabels = {}, environment, allowedEnvironments, environmentsConfig = {}, reportVariables = {}, } = params ?? {};
         const errors = [];
         const { normalized: normalizedEnvironmentsConfig, identities, errors: configErrors, } = normalizeEnvironmentDescriptorMap(environmentsConfig, "environmentsConfig");
         errors.push(...configErrors);
@@ -116,8 +117,8 @@ export class DefaultAllureStore {
         __classPrivateFieldSet(this, _DefaultAllureStore_metadata, new Map(), "f");
         __classPrivateFieldSet(this, _DefaultAllureStore_fixtures, new Map(), "f");
         __classPrivateFieldSet(this, _DefaultAllureStore_history, history, "f");
-        __classPrivateFieldSet(this, _DefaultAllureStore_known, [...known], "f");
-        __classPrivateFieldGet(this, _DefaultAllureStore_known, "f").forEach((ktf) => index(this.indexKnownByHistoryId, ktf.historyId, ktf));
+        __classPrivateFieldSet(this, _DefaultAllureStore_knownIssuesConfig, knownIssuesConfig, "f");
+        known.forEach((ktf) => this.known.set(ktf.historyId, ktf));
         __classPrivateFieldSet(this, _DefaultAllureStore_realtimeDispatcher, realtimeDispatcher, "f");
         __classPrivateFieldSet(this, _DefaultAllureStore_realtimeSubscriber, realtimeSubscriber, "f");
         __classPrivateFieldSet(this, _DefaultAllureStore_defaultLabels, defaultLabels, "f");
@@ -329,6 +330,7 @@ export class DefaultAllureStore {
             testResult.transition = getStatusTransition(testResult, trHistory);
             testResult.flaky = isFlaky(testResult, trHistory);
         }
+        testResult.known = __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_classifyKnownIssue).call(this, testResult, environmentIdentity.id);
         __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f").set(testResult.id, testResult);
         __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_setTestResultEnvironmentId).call(this, testResult, environmentIdentity.id);
         __classPrivateFieldGet(this, _DefaultAllureStore_retrySubstore, "f").recordIngestOrder(testResult.id);
@@ -511,7 +513,7 @@ export class DefaultAllureStore {
         }, []);
     }
     async allKnownIssues() {
-        return __classPrivateFieldGet(this, _DefaultAllureStore_known, "f");
+        return [...this.known.values()].flat();
     }
     async allNewTestResults(filter, history) {
         if (!__classPrivateFieldGet(this, _DefaultAllureStore_history, "f") && !history) {
@@ -580,6 +582,9 @@ export class DefaultAllureStore {
         const tr = __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f").get(trId);
         return __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_retriesByTr).call(this, tr);
     }
+    resetIngestOrder() {
+        __classPrivateFieldGet(this, _DefaultAllureStore_retrySubstore, "f").resetIngestOrder();
+    }
     async historyByTr(tr) {
         return __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_historyByTr).call(this, tr);
     }
@@ -624,16 +629,12 @@ export class DefaultAllureStore {
         }
         return failedTrs;
     }
-    async unknownFailedTestResults() {
+    async blockingFailedTestResults() {
         const failedTestResults = await this.failedTestResults();
-        if (!__classPrivateFieldGet(this, _DefaultAllureStore_known, "f")?.length) {
-            return failedTestResults;
-        }
-        const knownHistoryIds = new Set(__classPrivateFieldGet(this, _DefaultAllureStore_known, "f").map((ktf) => ktf.historyId));
-        return failedTestResults.filter((tr) => {
-            const historyIdCandidates = getHistoryIdCandidates(tr);
-            return (historyIdCandidates.length > 0 && historyIdCandidates.every((historyId) => !knownHistoryIds.has(historyId)));
-        });
+        return failedTestResults.filter((tr) => !tr.known);
+    }
+    async unknownFailedTestResults() {
+        return this.blockingFailedTestResults();
     }
     async testResultsByLabel(labelName) {
         const results = createDictionary();
@@ -793,7 +794,7 @@ export class DefaultAllureStore {
             indexTestResultByTestCase: {},
             indexAttachmentByFixture: {},
             indexFixturesByTestResult: {},
-            indexKnownByHistoryId: {},
+            knownIssues: {},
             qualityGateResults: __classPrivateFieldGet(this, _DefaultAllureStore_qualityGateResults, "f"),
             testResultIdsIngestOrder: __classPrivateFieldGet(this, _DefaultAllureStore_retrySubstore, "f").ingestOrderIdsForDump(),
         };
@@ -812,13 +813,13 @@ export class DefaultAllureStore {
         this.indexFixturesByTestResult.forEach((fixtures, trId) => {
             storeDump.indexFixturesByTestResult[trId] = fixtures.map((f) => f.id);
         });
-        this.indexKnownByHistoryId.forEach((known, historyId) => {
-            storeDump.indexKnownByHistoryId[historyId] = known;
+        this.known.forEach((known, historyId) => {
+            storeDump.knownIssues[historyId] = known;
         });
         return storeDump;
     }
     async restoreState(stateDump, attachmentsContents = {}) {
-        const { testResults, attachments, testCases, fixtures, reportVariables, environments, globalAttachmentIds = [], globalErrors = [], checkResults, indexAttachmentByTestResult = {}, indexTestResultByHistoryId = {}, indexTestResultByTestCase = {}, indexAttachmentByFixture = {}, indexFixturesByTestResult = {}, indexKnownByHistoryId = {}, qualityGateResults = [], testResultIdsIngestOrder = [], } = stateDump;
+        const { testResults, attachments, testCases, fixtures, reportVariables, environments, globalAttachmentIds = [], globalErrors = [], checkResults, indexAttachmentByTestResult = {}, indexTestResultByHistoryId = {}, indexTestResultByTestCase = {}, indexAttachmentByFixture = {}, indexFixturesByTestResult = {}, knownIssues = {}, qualityGateResults = [], testResultIdsIngestOrder = [], } = stateDump;
         const storedEnvironmentAliases = environments.flatMap((environmentValue) => {
             if (typeof environmentValue === "string") {
                 return [{ id: environmentValue, name: environmentValue }];
@@ -868,6 +869,7 @@ export class DefaultAllureStore {
             envNameToId.set(id, id);
         }
         Object.values(testResults).forEach((testResult) => {
+            testResult.known ?? (testResult.known = false);
             __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f").set(testResult.id, testResult);
             const storedEnvKey = typeof testResult.environment === "string" ? testResult.environment : undefined;
             const envId = (storedEnvKey ? envNameToId.get(storedEnvKey) : undefined) ?? __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_environmentIdByTestResult).call(this, testResult);
@@ -883,6 +885,7 @@ 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(this.known, knownIssues);
         Object.entries(attachmentsContents).forEach(([id, content]) => {
             __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_restoreAttachmentContent).call(this, id, content);
         });
@@ -971,15 +974,10 @@ export class DefaultAllureStore {
             }
             existingFixtures.push(...fxs);
         });
-        Object.entries(indexKnownByHistoryId).forEach(([historyId, knownFailures]) => {
-            const existingKnown = this.indexKnownByHistoryId.get(historyId);
-            if (!existingKnown) {
-                this.indexKnownByHistoryId.set(historyId, knownFailures);
-                return;
-            }
-            existingKnown.push(...knownFailures);
-        });
         __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_rebuildRetrySubstore).call(this);
+        for (const testResult of __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f").values()) {
+            testResult.known = __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_classifyKnownIssue).call(this, testResult, __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_environmentIdByTestResult).call(this, testResult));
+        }
         qualityGateResults.forEach((result, index) => {
             __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_assertAllowedStoredEnvironment).call(this, {
                 environment: result.environment,
@@ -991,7 +989,9 @@ 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_retrySubstore = new WeakMap(), _DefaultAllureStore_testResultIdsByEnvironmentId = new WeakMap(), _DefaultAllureStore_cachedEnvironmentEntries = new WeakMap(), _DefaultAllureStore_globalAttachmentIds = new WeakMap(), _DefaultAllureStore_globalAttachmentIdsByEnv = new WeakMap(), _DefaultAllureStore_globalErrors = new WeakMap(), _DefaultAllureStore_globalErrorsByEnv = new WeakMap(), _DefaultAllureStore_globalExitCode = new WeakMap(), _DefaultAllureStore_checkResultsById = 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_knownIssuesConfig = 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_retrySubstore = new WeakMap(), _DefaultAllureStore_testResultIdsByEnvironmentId = new WeakMap(), _DefaultAllureStore_cachedEnvironmentEntries = new WeakMap(), _DefaultAllureStore_globalAttachmentIds = new WeakMap(), _DefaultAllureStore_globalAttachmentIdsByEnv = new WeakMap(), _DefaultAllureStore_globalErrors = new WeakMap(), _DefaultAllureStore_globalErrorsByEnv = new WeakMap(), _DefaultAllureStore_globalExitCode = new WeakMap(), _DefaultAllureStore_checkResultsById = new WeakMap(), _DefaultAllureStore_qualityGateResults = new WeakMap(), _DefaultAllureStore_historyPoints = new WeakMap(), _DefaultAllureStore_environments = new WeakMap(), _DefaultAllureStore_instances = new WeakSet(), _DefaultAllureStore_historyIdMatches = function _DefaultAllureStore_historyIdMatches(historyIdCandidates, indexByHistoryId) {
+    return historyIdCandidates.find((historyId) => indexByHistoryId.has(historyId));
+}, _DefaultAllureStore_mergeEnvironmentIdentity = function _DefaultAllureStore_mergeEnvironmentIdentity(existingEnvironment, incomingEnvironment) {
     const configuredEnvironment = environmentIdentityById(__classPrivateFieldGet(this, _DefaultAllureStore_environmentsConfig, "f"), incomingEnvironment.id);
     if (configuredEnvironment) {
         return configuredEnvironment;
@@ -1093,6 +1093,23 @@ _DefaultAllureStore_testResults = new WeakMap(), _DefaultAllureStore_environment
     const environmentId = options?.environmentId ?? __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_environmentIdByTestResult).call(this, testResult);
     const parametersHash = options?.parametersHash ?? calculateParametersHash(testResult.parameters);
     testResult.retryHash = calculateRetryHash(testResult.testCase?.id, parametersHash, environmentId);
+}, _DefaultAllureStore_setKnownIssue = function _DefaultAllureStore_setKnownIssue(knownIssue) {
+    this.known.set(knownIssue.historyId, knownIssue);
+}, _DefaultAllureStore_classifyKnownIssue = function _DefaultAllureStore_classifyKnownIssue(testResult, environmentId) {
+    if (testResult.status !== "failed" && testResult.status !== "broken") {
+        return false;
+    }
+    const historyIdCandidates = getHistoryIdCandidates(testResult);
+    if (historyIdCandidates.length === 0) {
+        return false;
+    }
+    const ruleKnownIssue = getKnownIssueByRules(testResult, __classPrivateFieldGet(this, _DefaultAllureStore_knownIssuesConfig, "f"), environmentId);
+    if (ruleKnownIssue) {
+        __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_setKnownIssue).call(this, ruleKnownIssue);
+        return true;
+    }
+    const knownHistoryId = __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_historyIdMatches).call(this, historyIdCandidates, this.known);
+    return !!knownHistoryId;
 }, _DefaultAllureStore_rebuildRetrySubstore = function _DefaultAllureStore_rebuildRetrySubstore() {
     __classPrivateFieldGet(this, _DefaultAllureStore_retrySubstore, "f").reset();
     for (const [, testResult] of __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f")) {

package/dist/utils/resultsDir.d.ts

@@ -0,0 +1 @@
+export declare const normalizeResultsDir: (value?: string | string[]) => string[];

package/dist/utils/resultsDir.js

@@ -0,0 +1,7 @@
+export const normalizeResultsDir = (value) => {
+    if (value === undefined) {
+        return [];
+    }
+    const values = Array.isArray(value) ? value : [value];
+    return values.filter((entry) => entry.length > 0);
+};

package/package.json

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