@allurereport/reader 3.0.0-beta.9 → 3.0.1

package/dist/xcresult/xcresulttool/legacy/xcModel.d.ts

@@ -0,0 +1,357 @@
+export type XcObject<T extends string> = {
+    _type: {
+        _name: T;
+    };
+};
+export type XcValue<Type extends string> = XcObject<Type> & {
+    _value: string;
+};
+export type XcArray<Element> = XcObject<"Array"> & {
+    _values: Element[];
+};
+export type XcSortedKeyValueArrayPair = XcObject<"SortedKeyValueArrayPair"> & {
+    key: XcString;
+    value: XcObject<string>;
+};
+export type XcSortedKeyValueArray = XcObject<"SortedKeyValueArray"> & {
+    storage: XcArray<XcSortedKeyValueArrayPair>;
+};
+export type XcBool = XcValue<"Bool">;
+export type XcData = XcValue<"Data">;
+export type XcDate = XcValue<"Date">;
+export type XcDouble = XcValue<"Double">;
+export type XcInt = XcValue<"Int">;
+export type XcInt16 = XcValue<"Int16">;
+export type XcInt32 = XcValue<"Int32">;
+export type XcInt64 = XcValue<"Int64">;
+export type XcInt8 = XcValue<"Int8">;
+export type XcString = XcValue<"String">;
+export type XcUInt16 = XcValue<"UInt16">;
+export type XcUInt32 = XcValue<"UInt32">;
+export type XcUInt64 = XcValue<"UInt64">;
+export type XcUInt8 = XcValue<"UInt8">;
+export type XcURL = XcValue<"URL">;
+export type XcReference = XcObject<"Reference"> & {
+    id: XcString;
+    targetType?: XcTypeDefinition;
+};
+export type XcActionsInvocationRecord = XcObject<"ActionsInvocationRecord"> & {
+    metadataRef?: XcReference;
+    metrics: XcResultMetrics;
+    issues: XcResultIssueSummaries;
+    actions: XcArray<XcActionRecord>;
+    archive?: XcArchiveInfo;
+};
+export type XcResultMetrics = XcObject<"ResultMetrics"> & {
+    analyzerWarningCount: XcInt;
+    errorCount: XcInt;
+    testsCount: XcInt;
+    testsFailedCount: XcInt;
+    testsSkippedCount: XcInt;
+    warningCount: XcInt;
+    totalCoveragePercentage?: XcDouble;
+};
+export type XcResultIssueSummaries = XcObject<"ResultIssueSummaries"> & {
+    analyzerWarningSummaries: XcArray<XcIssueSummary>;
+    errorSummaries: XcArray<XcIssueSummary>;
+    testFailureSummaries: XcArray<XcTestFailureIssueSummary>;
+    warningSummaries: XcArray<XcIssueSummary>;
+    testWarningSummaries: XcArray<XcTestIssueSummary>;
+};
+export type XcActionRecord = XcObject<"ActionRecord"> & {
+    schemeCommandName: XcString;
+    schemeTaskName: XcString;
+    title?: XcString;
+    startedTime: XcDate;
+    endedTime: XcDate;
+    runDestination: XcActionRunDestinationRecord;
+    buildResult: XcActionResult;
+    actionResult: XcActionResult;
+    testPlanName?: XcString;
+};
+export type XcArchiveInfo = XcObject<"ArchiveInfo"> & {
+    path?: XcString;
+};
+export type XcTypeDefinition = XcObject<"TypeDefinition"> & {
+    name: XcString;
+    supertype?: XcTypeDefinition;
+};
+export type XcIssueSummary<Type extends string = "IssueSummary"> = XcObject<Type> & {
+    issueType: XcString;
+    message: XcString;
+    producingTarget?: XcString;
+    documentLocationInCreatingWorkspace?: XcDocumentLocation;
+};
+export type XcTestFailureIssueSummary = XcIssueSummary<"TestFailureIssueSummary"> & {
+    testCaseName: XcString;
+};
+export type XcTestIssueSummary = XcIssueSummary<"TestIssueSummary"> & {
+    testCaseName: XcString;
+};
+export type XcActionRunDestinationRecord = XcObject<"ActionRunDestinationRecord"> & {
+    displayName: XcString;
+    targetArchitecture: XcString;
+    targetDeviceRecord: XcActionDeviceRecord;
+    localComputerRecord: XcActionDeviceRecord;
+    targetSDKRecord: XcActionSDKRecord;
+};
+export type XcActionResult = XcObject<"ActionResult"> & {
+    resultName: XcString;
+    status: XcString;
+    metrics: XcResultMetrics;
+    issues: XcResultIssueSummaries;
+    coverage: XcCodeCoverageInfo;
+    timelineRef?: XcReference;
+    logRef?: XcReference;
+    testsRef?: XcReference;
+    diagnosticsRef?: XcReference;
+    consoleLogRef?: XcReference;
+};
+export type XcDocumentLocation = XcObject<"DocumentLocation"> & {
+    url: XcString;
+    concreteTypeName: XcString;
+};
+export type XcActionDeviceRecord = XcObject<"ActionDeviceRecord"> & {
+    name: XcString;
+    isConcreteDevice: XcBool;
+    operatingSystemVersion: XcString;
+    operatingSystemVersionWithBuildNumber: XcString;
+    nativeArchitecture: XcString;
+    modelName: XcString;
+    modelCode: XcString;
+    modelUTI: XcString;
+    identifier: XcString;
+    isWireless: XcBool;
+    cpuKind: XcString;
+    cpuCount?: XcInt;
+    cpuSpeedInMhz?: XcInt;
+    busSpeedInMhz?: XcInt;
+    ramSizeInMegabytes?: XcInt;
+    physicalCPUCoresPerPackage?: XcInt;
+    logicalCPUCoresPerPackage?: XcInt;
+    platformRecord: XcActionPlatformRecord;
+};
+export type XcActionSDKRecord = XcObject<"ActionSDKRecord"> & {
+    name: XcString;
+    identifier: XcString;
+    operatingSystemVersion: XcString;
+    isInternal: XcBool;
+};
+export type XcCodeCoverageInfo = XcObject<"CodeCoverageInfo"> & {
+    hasCoverageData: XcBool;
+    reportRef?: XcReference;
+    archiveRef?: XcReference;
+};
+export type XcActionPlatformRecord = XcObject<"ActionPlatformRecord"> & {
+    identifier: XcString;
+    userDescription: XcString;
+};
+export type XcActionTestPlanRunSummaries = XcObject<"ActionTestPlanRunSummaries"> & {
+    summaries: XcArray<XcActionTestPlanRunSummary>;
+};
+export type XcActionAbstractTestSummary<Type extends string> = XcObject<Type> & {
+    name?: XcString;
+};
+export type XcActionTestPlanRunSummary = XcActionAbstractTestSummary<"ActionTestPlanRunSummary"> & {
+    testableSummaries: XcArray<XcActionTestableSummary>;
+};
+export type XcActionTestableSummary = XcActionAbstractTestSummary<"ActionTestableSummary"> & {
+    identifierURL?: XcString;
+    projectRelativePath?: XcString;
+    targetName?: XcString;
+    testKind?: XcString;
+    tests: XcArray<XcActionTestSummaryIdentifiableObject>;
+    diagnosticsDirectoryName?: XcString;
+    failureSummaries: XcArray<XcActionTestFailureSummary>;
+    testLanguage?: XcString;
+    testRegion?: XcString;
+};
+export type XcActionTestSummaryIdentifiableObjectBase<Type extends string> = XcActionAbstractTestSummary<Type> & {
+    identifier?: XcString;
+    identifierURL?: XcString;
+};
+export type XcActionTestMetadata = XcActionTestSummaryIdentifiableObjectBase<"ActionTestMetadata"> & {
+    testStatus: XcString;
+    duration?: XcDouble;
+    summaryRef?: XcReference;
+    performanceMetricsCount?: XcInt;
+    failureSummariesCount?: XcInt;
+    activitySummariesCount?: XcInt;
+};
+export type XcActionTestSummaryGroup = XcActionTestSummaryIdentifiableObjectBase<"ActionTestSummaryGroup"> & {
+    duration: XcDouble;
+    subtests: XcArray<XcActionTestSummaryIdentifiableObject>;
+    skipNoticeSummary?: XcActionTestNoticeSummary;
+    summary?: XcString;
+    documentation: XcArray<XcTestDocumentation>;
+    trackedIssues: XcArray<XcIssueTrackingMetadata>;
+    tags: XcArray<XcTestTag>;
+};
+export type XcActionTestSummary = XcActionTestSummaryIdentifiableObjectBase<"ActionTestSummary"> & {
+    testStatus: XcString;
+    duration: XcDouble;
+    performanceMetrics: XcArray<XcActionTestPerformanceMetricSummary>;
+    failureSummaries: XcArray<XcActionTestFailureSummary>;
+    expectedFailures: XcArray<XcActionTestExpectedFailure>;
+    skipNoticeSummary?: XcActionTestNoticeSummary;
+    activitySummaries: XcArray<XcActionTestActivitySummary>;
+    repetitionPolicySummary?: XcActionTestRepetitionPolicySummary;
+    arguments: XcArray<XcTestArgument>;
+    configuration?: XcActionTestConfiguration;
+    warningSummaries: XcArray<XcActionTestIssueSummary>;
+    summary?: XcString;
+    documentation: XcArray<XcTestDocumentation>;
+    trackedIssues: XcArray<XcIssueTrackingMetadata>;
+    tags: XcArray<XcTestTag>;
+};
+export type XcActionTestSummaryIdentifiableObject = XcActionTestMetadata | XcActionTestSummary | XcActionTestSummaryGroup;
+export declare const XcActionTestSummaryIdentifiableObjectTypes: readonly ["ActionTestMetadata", "ActionTestSummary", "ActionTestSummaryGroup"];
+export type XcActionTestFailureSummary = XcObject<"ActionTestFailureSummary"> & {
+    message?: XcString;
+    fileName: XcString;
+    lineNumber: XcInt;
+    isPerformanceFailure: XcBool;
+    uuid: XcString;
+    issueType?: XcString;
+    detailedDescription?: XcString;
+    attachments: XcArray<XcActionTestAttachment>;
+    associatedError?: XcTestAssociatedError;
+    sourceCodeContext?: XcSourceCodeContext;
+    timestamp?: XcDate;
+    isTopLevelFailure: XcBool;
+    expression?: XcTestExpression;
+};
+export type XcActionTestAttachment = XcObject<"ActionTestAttachment"> & {
+    uniformTypeIdentifier: XcString;
+    name?: XcString;
+    uuid?: XcString;
+    timestamp?: XcDate;
+    userInfo?: XcSortedKeyValueArray;
+    lifetime: XcString;
+    inActivityIdentifier: XcInt;
+    filename?: XcString;
+    payloadRef?: XcReference;
+    payloadSize: XcInt;
+};
+export type XcTestAssociatedError = XcObject<"TestAssociatedError"> & {
+    domain?: XcString;
+    code?: XcInt;
+    userInfo?: XcSortedKeyValueArray;
+};
+export type XcSourceCodeContext = XcObject<"SourceCodeContext"> & {
+    location?: XcSourceCodeLocation;
+    callStack: XcArray<XcSourceCodeFrame>;
+};
+export type XcTestExpression = XcObject<"TestExpression"> & {
+    sourceCode: XcString;
+    value?: XcTestValue;
+    subexpressions: XcArray<XcTestExpression>;
+};
+export type XcSourceCodeLocation = XcObject<"SourceCodeLocation"> & {
+    filePath?: XcString;
+    lineNumber?: XcInt;
+};
+export type XcSourceCodeFrame = XcObject<"SourceCodeFrame"> & {
+    addressString?: XcString;
+    symbolInfo?: XcSourceCodeSymbolInfo;
+};
+export type XcSourceCodeSymbolInfo = XcObject<"SourceCodeSymbolInfo"> & {
+    imageName?: XcString;
+    symbolName?: XcString;
+    location?: XcSourceCodeLocation;
+};
+export type XcActionTestPerformanceMetricSummary = XcObject<"ActionTestPerformanceMetricSummary"> & {
+    displayName: XcString;
+    unitOfMeasurement: XcString;
+    measurements: XcArray<XcDouble>;
+    identifier?: XcString;
+    baselineName?: XcString;
+    baselineAverage?: XcDouble;
+    maxPercentRegression?: XcDouble;
+    maxPercentRelativeStandardDeviation?: XcDouble;
+    maxRegression?: XcDouble;
+    maxStandardDeviation?: XcDouble;
+    polarity?: XcString;
+};
+export type XcActionTestExpectedFailure = XcObject<"ActionTestExpectedFailure"> & {
+    uuid: XcString;
+    failureReason?: XcString;
+    failureSummary?: XcActionTestFailureSummary;
+    isTopLevelFailure: XcBool;
+};
+export type XcActionTestNoticeSummary = XcObject<"ActionTestNoticeSummary"> & {
+    message?: XcString;
+    fileName: XcString;
+    lineNumber: XcInt;
+    timestamp?: XcDate;
+};
+export type XcActionTestActivitySummary = XcObject<"ActionTestActivitySummary"> & {
+    title: XcString;
+    activityType: XcString;
+    uuid: XcString;
+    start?: XcDate;
+    finish?: XcDate;
+    attachments: XcArray<XcActionTestAttachment>;
+    subactivities: XcArray<XcActionTestActivitySummary>;
+    failureSummaryIDs: XcArray<XcString>;
+    expectedFailureIDs: XcArray<XcString>;
+    warningSummaryIDs: XcArray<XcString>;
+};
+export type XcActionTestRepetitionPolicySummary = XcObject<"ActionTestRepetitionPolicySummary"> & {
+    iteration?: XcInt;
+    totalIterations?: XcInt;
+    repetitionMode?: XcString;
+};
+export type XcTestArgument = XcObject<"TestArgument"> & {
+    parameter?: XcTestParameter;
+    identifier?: XcString;
+    description: XcString;
+    debugDescription?: XcString;
+    typeName?: XcString;
+    value: XcTestValue;
+};
+export type XcActionTestConfiguration = XcObject<"ActionTestConfiguration"> & {
+    values: XcSortedKeyValueArray;
+};
+export type XcActionTestIssueSummary = XcObject<"ActionTestIssueSummary"> & {
+    message?: XcString;
+    fileName: XcString;
+    lineNumber: XcInt;
+    uuid: XcString;
+    issueType?: XcString;
+    detailedDescription?: XcString;
+    attachments: XcArray<XcActionTestAttachment>;
+    associatedError?: XcTestAssociatedError;
+    sourceCodeContext?: XcSourceCodeContext;
+    timestamp?: XcDate;
+};
+export type XcTestDocumentation = XcObject<"TestDocumentation"> & {
+    content: XcString;
+    format: XcString;
+};
+export type XcIssueTrackingMetadata = XcObject<"IssueTrackingMetadata"> & {
+    identifier: XcString;
+    url?: XcURL;
+    comment?: XcString;
+    summary: XcString;
+};
+export type XcTestTag = XcObject<"TestTag"> & {
+    identifier: XcString;
+    name: XcString;
+    anchors: XcArray<XcString>;
+};
+export type XcTestParameter = XcObject<"TestParameter"> & {
+    label: XcString;
+    name?: XcString;
+    typeName?: XcString;
+    fullyQualifiedTypeName?: XcString;
+};
+export type XcTestValue = XcObject<"TestValue"> & {
+    description: XcString;
+    debugDescription?: XcString;
+    typeName?: XcString;
+    fullyQualifiedTypeName?: XcString;
+    label?: XcString;
+    isCollection: XcBool;
+    children: XcArray<XcTestValue>;
+};

package/dist/xcresult/xcresulttool/legacy/xcModel.js

@@ -0,0 +1,5 @@
+export const XcActionTestSummaryIdentifiableObjectTypes = [
+    "ActionTestMetadata",
+    "ActionTestSummary",
+    "ActionTestSummaryGroup",
+];

package/dist/xcresult/xcresulttool/model.d.ts

@@ -0,0 +1,17 @@
+import type { ResultFile } from "@allurereport/plugin-api";
+import type { RawTestResult } from "@allurereport/reader-api";
+export declare abstract class XcresultParser {
+    protected readonly xcResultPath: string;
+    protected readonly createAttachmentFile: AttachmentFileFactory | undefined;
+    constructor(options: ParsingOptions);
+    abstract parse(): AsyncGenerator<ResultFile | RawTestResult, void, unknown>;
+}
+export type ParsingState = {
+    suites: readonly string[];
+    bundle?: string;
+};
+export type ParsingOptions = {
+    xcResultPath: string;
+    createAttachmentFile?: AttachmentFileFactory;
+};
+export type AttachmentFileFactory = (attachmentUuid: string, uniqueFileName: string) => Promise<ResultFile | undefined>;

package/dist/xcresult/xcresulttool/model.js

@@ -0,0 +1,6 @@
+export class XcresultParser {
+    constructor(options) {
+        this.xcResultPath = options.xcResultPath;
+        this.createAttachmentFile = options.createAttachmentFile;
+    }
+}

package/dist/xcresult/xcresulttool/utils.d.ts

@@ -0,0 +1,3 @@
+import type { AttachmentFileFactory } from "./model.js";
+export declare const parseWithExportedAttachments: (xcResultPath: string, fn: (createAttachmentFile: AttachmentFileFactory) => Promise<void>) => Promise<void>;
+export declare const mapWellKnownAttachmentName: (name: string | undefined, timestamp: number | undefined) => string | undefined;

package/dist/xcresult/xcresulttool/utils.js

@@ -0,0 +1,74 @@
+import { BufferResultFile } from "@allurereport/reader-api";
+import console from "node:console";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { exportAttachments } from "./cli.js";
+const AUTO_VIDEO_CAPTURE_NAME = "kXCTAttachmentScreenRecording";
+const AUTO_SCREENSHOT_CAPTURE_NAME = "kXCTAttachmentLegacyScreenImageData";
+export const parseWithExportedAttachments = async (xcResultPath, fn) => {
+    let attachmentsDir;
+    try {
+        attachmentsDir = await mkdtemp(path.join(tmpdir(), "allure-reader-xcresult-"));
+        await exportAttachments(xcResultPath, attachmentsDir);
+        await fn(createAttachmentFileFactoryFn(attachmentsDir));
+    }
+    finally {
+        if (attachmentsDir) {
+            try {
+                await rm(attachmentsDir, { recursive: true, force: true });
+            }
+            catch (e) {
+                console.error("when parsing", xcResultPath, "- can't remove the tmp dir", attachmentsDir, ":", e);
+            }
+        }
+    }
+};
+export const mapWellKnownAttachmentName = (name, timestamp) => {
+    switch (name) {
+        case AUTO_VIDEO_CAPTURE_NAME:
+            return "Screen Recording";
+        case AUTO_SCREENSHOT_CAPTURE_NAME:
+            return timestamp ? `Screenshot at ${timestampToString(timestamp)}` : "Screenshot";
+        default:
+            return name;
+    }
+};
+const timestampToString = (timestamp) => {
+    const date = new Date(timestamp);
+    return date.toLocaleString(undefined, {
+        year: "numeric",
+        month: "numeric",
+        day: "numeric",
+        hour: "numeric",
+        minute: "numeric",
+        second: "numeric",
+        fractionalSecondDigits: 3,
+    });
+};
+const createAttachmentFileFactoryFn = (attachmentsDir) => async (attachmentUuid, uniqueFileName) => {
+    const fileExtension = path.extname(uniqueFileName);
+    const attachmentFilePath = path.join(attachmentsDir, attachmentUuid);
+    const [firstAttemptOk, firstAttemptResult] = await tryReadFile(attachmentFilePath, uniqueFileName);
+    if (firstAttemptOk) {
+        return firstAttemptResult;
+    }
+    const errors = [firstAttemptResult];
+    if (firstAttemptResult?.code === "ENOENT" && fileExtension) {
+        const attachmentPathWithExt = `${attachmentFilePath}${fileExtension}`;
+        const [secondAttemptOk, secondAttemptResult] = await tryReadFile(attachmentPathWithExt, uniqueFileName);
+        if (secondAttemptOk) {
+            return secondAttemptResult;
+        }
+        errors.push(secondAttemptResult);
+    }
+    console.error("Can't read attachment", attachmentUuid, "in", attachmentsDir, ":", ...errors);
+};
+const tryReadFile = async (attachmentPath, attachmentName) => {
+    try {
+        return [true, new BufferResultFile(await readFile(attachmentPath), attachmentName)];
+    }
+    catch (e) {
+        return [false, e];
+    }
+};

package/dist/xcresult/xcresulttool/xcModel.d.ts

@@ -0,0 +1,96 @@
+export type XcTests = {
+    testPlanConfigurations: XcConfiguration[];
+    devices: XcDevice[];
+    testNodes: XcTestNode[];
+};
+export type XcConfiguration = {
+    configurationId: string;
+    configurationName: string;
+};
+export type XcDevice = {
+    deviceId?: string;
+    deviceName: string;
+    architecture: string;
+    modelName: string;
+    platform?: string;
+    osVersion: string;
+};
+export type XcTestNode = {
+    nodeIdentifier?: string;
+    nodeType: XcTestNodeType;
+    name: string;
+    details?: string;
+    duration?: string;
+    result?: XcTestResult;
+    tags?: string[];
+    children?: XcTestNode[];
+};
+export declare const XcTestNodeTypeValues: readonly ["Test Plan", "Unit test bundle", "UI test bundle", "Test Suite", "Test Case", "Device", "Test Plan Configuration", "Arguments", "Repetition", "Test Case Run", "Failure Message", "Source Code Reference", "Attachment", "Expression", "Test Value"];
+export type XcTestNodeType = (typeof XcTestNodeTypeValues)[number];
+export declare const XcTestResultValues: readonly ["Passed", "Failed", "Skipped", "Expected Failure", "unknown"];
+export type XcTestResult = (typeof XcTestResultValues)[number];
+export type XcTestDetails = {
+    testIdentifier: string;
+    testName: string;
+    testDescription: string;
+    duration: string;
+    startTime?: number;
+    testPlanConfiguration: XcConfiguration[];
+    devices: XcDevice[];
+    arguments?: XcTestResultArgument[];
+    testRuns: XcTestNode[];
+    testResult: XcTestResult;
+    hasPerformanceMetrics: boolean;
+    hasMediaAttachments: boolean;
+    tags?: string[];
+    bugs?: XcBug[];
+    functionName?: string;
+};
+export type XcTestResultArgument = {
+    value: string;
+};
+export type XcBug = {
+    url?: string;
+    identifier?: string;
+    title?: string;
+};
+export type XcActivities = {
+    testIdentifier: string;
+    testName: string;
+    testRuns: XcTestRunActivity[];
+};
+export type XcTestRunActivity = {
+    device: XcDevice;
+    testPlanConfiguration: XcConfiguration;
+    arguments?: XcTestRunArgument[];
+    activities: XcActivityNode[];
+};
+export type XcTestRunArgument = {
+    value: string;
+};
+export type XcActivityNode = {
+    title: string;
+    startTime?: number;
+    attachments?: XcAttachment[];
+    childActivities?: XcActivityNode[];
+};
+export type XcAttachment = {
+    name: string;
+    payloadId?: string;
+    uuid: string;
+    timestamp: number;
+    lifetime?: string;
+};
+export type XcTestAttachmentDetails = {
+    attachments: XcTestAttachment[];
+    testIdentifier: string;
+};
+export type XcTestAttachment = {
+    configurationName: string;
+    deviceId: string;
+    deviceName: string;
+    exportedFileName: string;
+    isAssociatedWithFailure: boolean;
+    suggestedHumanReadableName: string;
+    timestamp: number;
+};

package/dist/xcresult/xcresulttool/xcModel.js

@@ -0,0 +1,18 @@
+export const XcTestNodeTypeValues = [
+    "Test Plan",
+    "Unit test bundle",
+    "UI test bundle",
+    "Test Suite",
+    "Test Case",
+    "Device",
+    "Test Plan Configuration",
+    "Arguments",
+    "Repetition",
+    "Test Case Run",
+    "Failure Message",
+    "Source Code Reference",
+    "Attachment",
+    "Expression",
+    "Test Value",
+];
+export const XcTestResultValues = ["Passed", "Failed", "Skipped", "Expected Failure", "unknown"];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/reader",
-  "version": "3.0.0-beta.9",
+  "version": "3.0.1",
   "description": "Collection of utilities which helps to process different kind of test results as Allure Results",
   "keywords": [
     "allure",
@@ -26,20 +26,22 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@allurereport/core-api": "3.0.0-beta.9",
-    "@allurereport/plugin-api": "3.0.0-beta.9",
-    "@allurereport/reader-api": "3.0.0-beta.9",
+    "@allurereport/core-api": "3.0.1",
+    "@allurereport/plugin-api": "3.0.1",
+    "@allurereport/reader-api": "3.0.1",
     "fast-xml-parser": "^4.5.0"
   },
   "devDependencies": {
     "@stylistic/eslint-plugin": "^2.6.1",
+    "@types/archiver": "^6.0.3",
     "@types/eslint": "^8.56.11",
     "@types/node": "^20.17.9",
     "@typescript-eslint/eslint-plugin": "^8.0.0",
     "@typescript-eslint/parser": "^8.0.0",
-    "@vitest/runner": "^2.1.8",
-    "allure-js-commons": "^3.0.9",
-    "allure-vitest": "^3.0.9",
+    "@vitest/runner": "^2.1.9",
+    "allure-js-commons": "^3.3.3",
+    "allure-vitest": "^3.3.3",
+    "archiver": "^7.0.1",
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-import": "^2.29.1",
@@ -49,6 +51,6 @@
     "eslint-plugin-prefer-arrow": "^1.2.3",
     "rimraf": "^6.0.1",
     "typescript": "^5.6.3",
-    "vitest": "^2.1.8"
+    "vitest": "^2.1.9"
   }
 }