playwright-ctrf-json-reporter 0.0.24 → 0.0.25-next-0

package/dist/autoconfig.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Auto-configuration for Playwright CTRF runtime
+ * This file automatically sets up the Playwright runtime when imported
+ */
+export {};

package/dist/autoconfig.js

@@ -0,0 +1,19 @@
+/**
+ * Auto-configuration for Playwright CTRF runtime
+ * This file automatically sets up the Playwright runtime when imported
+ */
+import { test } from '@playwright/test';
+import { setGlobalCtrfRuntime } from 'ctrf';
+import { CtrfPlaywrightRuntime } from './playwright-runtime';
+/**
+ * Check if we're in a Playwright test context and auto-register the runtime
+ */
+try {
+    // This will throw if not in a test context
+    test.info();
+    // If we get here, we're in a test context
+    setGlobalCtrfRuntime(new CtrfPlaywrightRuntime());
+}
+catch {
+    // Not in test context yet - the runtime will be set up when tests start running
+}

package/dist/ctrf-runtime/facade.d.ts

@@ -0,0 +1,14 @@
+/**
+ * CTRF framework-agnostic facade functions
+ * These functions call into the global runtime that's set by framework-specific packages
+ * Simplified API focusing on test.extra enrichment
+ */
+/**
+ * Test-related CTRF functions
+ */
+export declare const test: {
+    /**
+     * Add extra metadata to a test
+     */
+    addExtra: (key: string, value: unknown) => Promise<void>;
+};

package/dist/ctrf-runtime/facade.js

@@ -0,0 +1,28 @@
+/**
+ * CTRF framework-agnostic facade functions
+ * These functions call into the global runtime that's set by framework-specific packages
+ * Simplified API focusing on test.extra enrichment
+ */
+import { getGlobalCtrfRuntimeWithAutoconfig } from './runtime';
+const callRuntimeMethod = (method, ...args) => {
+    const runtime = getGlobalCtrfRuntimeWithAutoconfig();
+    if (runtime && typeof runtime.then !== 'function') {
+        // @ts-ignore
+        return runtime[method](...args);
+    }
+    return runtime.then((ctrfRuntime) => {
+        // @ts-ignore
+        return ctrfRuntime[method](...args);
+    });
+};
+/**
+ * Test-related CTRF functions
+ */
+export const test = {
+    /**
+     * Add extra metadata to a test
+     */
+    addExtra: (key, value) => {
+        return callRuntimeMethod('addExtra', key, value);
+    }
+};

package/dist/ctrf-runtime/runtime.d.ts

@@ -0,0 +1,25 @@
+/**
+ * CTRF runtime system (framework-agnostic)
+ * Similar to Allure's global runtime pattern
+ */
+/**
+ * Interface that framework-specific runtimes must implement
+ */
+export interface CtrfRuntime {
+    addExtra(key: string, value: unknown): Promise<void>;
+}
+/**
+ * Set the global CTRF runtime (called by framework-specific packages)
+ */
+export declare const setGlobalCtrfRuntime: (runtime: CtrfRuntime) => void;
+/**
+ * Get the current global CTRF runtime
+ */
+export declare const getGlobalCtrfRuntime: () => CtrfRuntime;
+/**
+ * Get the global CTRF runtime with auto-configuration attempt
+ * This tries to auto-detect and configure framework-specific runtimes
+ * Copied from Allure's pattern exactly
+ */
+export declare const getGlobalCtrfRuntimeWithAutoconfig: () => CtrfRuntime | Promise<CtrfRuntime>;
+export { test } from './facade';

package/dist/ctrf-runtime/runtime.js

@@ -0,0 +1,53 @@
+/**
+ * CTRF runtime system (framework-agnostic)
+ * Similar to Allure's global runtime pattern
+ */
+/**
+ * No-op runtime that logs warnings when no framework runtime is available
+ */
+class NoopCtrfRuntime {
+    warn(method) {
+        console.warn(`CTRF: ${method} called but no framework runtime is available. Make sure you have configured a CTRF reporter for your test framework.`);
+    }
+    async addExtra() {
+        this.warn('addExtra');
+    }
+}
+const CTRF_RUNTIME_KEY = 'ctrfRuntime';
+const noopRuntime = new NoopCtrfRuntime();
+/**
+ * Set the global CTRF runtime (called by framework-specific packages)
+ */
+export const setGlobalCtrfRuntime = (runtime) => {
+    ;
+    globalThis[CTRF_RUNTIME_KEY] = runtime;
+};
+/**
+ * Get the current global CTRF runtime
+ */
+export const getGlobalCtrfRuntime = () => {
+    const runtime = globalThis?.[CTRF_RUNTIME_KEY];
+    return runtime ?? noopRuntime;
+};
+/**
+ * Get the global CTRF runtime with auto-configuration attempt
+ * This tries to auto-detect and configure framework-specific runtimes
+ * Copied from Allure's pattern exactly
+ */
+export const getGlobalCtrfRuntimeWithAutoconfig = () => {
+    const runtime = getGlobalCtrfRuntime();
+    if (runtime !== noopRuntime) {
+        return runtime;
+    }
+    // protection from bundlers tree-shaking visiting (webpack, rollup)
+    const pwAutoconfigModuleName = 'playwright-ctrf-json-reporter/autoconfig';
+    return import(pwAutoconfigModuleName)
+        .then(() => {
+        return getGlobalCtrfRuntime();
+    })
+        .catch(() => {
+        return noopRuntime;
+    });
+};
+// Export facade functions (framework-agnostic API)
+export { test } from './facade';

package/dist/generate-report.d.ts

@@ -29,9 +29,11 @@ declare class GenerateCtrfReport implements Reporter {
     readonly defaultOutputDir = "ctrf";
     private suite;
     private startTime;
+    private testMetadata;
     constructor(config?: Partial<ReporterConfigOptions>);
     onBegin(_config: FullConfig, suite: Suite): void;
     onEnd(): void;
+    onTestEnd(test: TestCase, result: TestResult): void;
     printsToStdio(): boolean;
     processSuite(suite: Suite): void;
     processTest(testCase: TestCase): void;

package/dist/generate-report.js

@@ -1,41 +1,43 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
-const crypto_1 = __importDefault(require("crypto"));
+import path from 'path';
+import fs from 'fs';
+import crypto from 'crypto';
+import { extractCtrfMetadata, ensurePlaywrightRuntime } from './playwright-runtime';
 class GenerateCtrfReport {
+    ctrfReport;
+    ctrfEnvironment;
+    reporterConfigOptions;
+    reporterName = 'playwright-ctrf-json-reporter';
+    defaultOutputFile = 'ctrf-report.json';
+    defaultOutputDir = 'ctrf';
+    suite;
+    startTime;
+    testMetadata = new Map();
     constructor(config) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
-        this.reporterName = 'playwright-ctrf-json-reporter';
-        this.defaultOutputFile = 'ctrf-report.json';
-        this.defaultOutputDir = 'ctrf';
+        ensurePlaywrightRuntime();
         this.reporterConfigOptions = {
-            outputFile: (_a = config === null || config === void 0 ? void 0 : config.outputFile) !== null && _a !== void 0 ? _a : this.defaultOutputFile,
-            outputDir: (_b = config === null || config === void 0 ? void 0 : config.outputDir) !== null && _b !== void 0 ? _b : this.defaultOutputDir,
-            minimal: (_c = config === null || config === void 0 ? void 0 : config.minimal) !== null && _c !== void 0 ? _c : false,
-            screenshot: (_d = config === null || config === void 0 ? void 0 : config.screenshot) !== null && _d !== void 0 ? _d : false,
-            annotations: (_e = config === null || config === void 0 ? void 0 : config.annotations) !== null && _e !== void 0 ? _e : false,
-            testType: (_f = config === null || config === void 0 ? void 0 : config.testType) !== null && _f !== void 0 ? _f : 'e2e',
-            appName: (_g = config === null || config === void 0 ? void 0 : config.appName) !== null && _g !== void 0 ? _g : undefined,
-            appVersion: (_h = config === null || config === void 0 ? void 0 : config.appVersion) !== null && _h !== void 0 ? _h : undefined,
-            osPlatform: (_j = config === null || config === void 0 ? void 0 : config.osPlatform) !== null && _j !== void 0 ? _j : undefined,
-            osRelease: (_k = config === null || config === void 0 ? void 0 : config.osRelease) !== null && _k !== void 0 ? _k : undefined,
-            osVersion: (_l = config === null || config === void 0 ? void 0 : config.osVersion) !== null && _l !== void 0 ? _l : undefined,
-            buildName: (_m = config === null || config === void 0 ? void 0 : config.buildName) !== null && _m !== void 0 ? _m : undefined,
-            buildNumber: (_o = config === null || config === void 0 ? void 0 : config.buildNumber) !== null && _o !== void 0 ? _o : undefined,
-            buildUrl: (_p = config === null || config === void 0 ? void 0 : config.buildUrl) !== null && _p !== void 0 ? _p : undefined,
-            repositoryName: (_q = config === null || config === void 0 ? void 0 : config.repositoryName) !== null && _q !== void 0 ? _q : undefined,
-            repositoryUrl: (_r = config === null || config === void 0 ? void 0 : config.repositoryUrl) !== null && _r !== void 0 ? _r : undefined,
-            branchName: (_s = config === null || config === void 0 ? void 0 : config.branchName) !== null && _s !== void 0 ? _s : undefined,
-            testEnvironment: (_t = config === null || config === void 0 ? void 0 : config.testEnvironment) !== null && _t !== void 0 ? _t : undefined,
+            outputFile: config?.outputFile ?? this.defaultOutputFile,
+            outputDir: config?.outputDir ?? this.defaultOutputDir,
+            minimal: config?.minimal ?? false,
+            screenshot: config?.screenshot ?? false,
+            annotations: config?.annotations ?? false,
+            testType: config?.testType ?? 'e2e',
+            appName: config?.appName ?? undefined,
+            appVersion: config?.appVersion ?? undefined,
+            osPlatform: config?.osPlatform ?? undefined,
+            osRelease: config?.osRelease ?? undefined,
+            osVersion: config?.osVersion ?? undefined,
+            buildName: config?.buildName ?? undefined,
+            buildNumber: config?.buildNumber ?? undefined,
+            buildUrl: config?.buildUrl ?? undefined,
+            repositoryName: config?.repositoryName ?? undefined,
+            repositoryUrl: config?.repositoryUrl ?? undefined,
+            branchName: config?.branchName ?? undefined,
+            testEnvironment: config?.testEnvironment ?? undefined,
         };
         this.ctrfReport = {
             reportFormat: 'CTRF',
             specVersion: '0.0.0',
-            reportId: crypto_1.default.randomUUID(),
+            reportId: crypto.randomUUID(),
             timestamp: new Date().toISOString(),
             generatedBy: 'playwright-ctrf-json-reporter',
             results: {
@@ -58,18 +60,17 @@ class GenerateCtrfReport {
         this.ctrfEnvironment = {};
     }
     onBegin(_config, suite) {
-        var _a, _b, _c;
         this.suite = suite;
         this.startTime = Date.now();
         this.ctrfReport.results.summary.start = this.startTime;
-        if (!fs_1.default.existsSync((_a = this.reporterConfigOptions.outputDir) !== null && _a !== void 0 ? _a : this.defaultOutputDir)) {
-            fs_1.default.mkdirSync((_b = this.reporterConfigOptions.outputDir) !== null && _b !== void 0 ? _b : this.defaultOutputDir, { recursive: true });
+        if (!fs.existsSync(this.reporterConfigOptions.outputDir ?? this.defaultOutputDir)) {
+            fs.mkdirSync(this.reporterConfigOptions.outputDir ?? this.defaultOutputDir, { recursive: true });
         }
         this.setEnvironmentDetails(this.reporterConfigOptions);
         if (this.hasEnvironmentDetails(this.ctrfEnvironment)) {
             this.ctrfReport.results.environment = this.ctrfEnvironment;
         }
-        this.setFilename((_c = this.reporterConfigOptions.outputFile) !== null && _c !== void 0 ? _c : this.defaultOutputFile);
+        this.setFilename(this.reporterConfigOptions.outputFile ?? this.defaultOutputFile);
     }
     onEnd() {
         this.ctrfReport.results.summary.stop = Date.now();
@@ -81,6 +82,11 @@ class GenerateCtrfReport {
         }
         this.writeReportToFile(this.ctrfReport);
     }
+    onTestEnd(test, result) {
+        // Extract CTRF metadata from test attachments
+        const metadata = extractCtrfMetadata(result.attachments);
+        this.testMetadata.set(test.id, metadata);
+    }
     printsToStdio() {
         return false;
     }
@@ -111,9 +117,10 @@ class GenerateCtrfReport {
         }
     }
     updateCtrfTestResultsFromTestResult(testCase, testResult, ctrfReport) {
-        var _a, _b, _c, _d, _e, _f;
+        // Get stored metadata for this test
+        const metadata = this.testMetadata.get(testCase.id);
         const test = {
-            name: testCase.title,
+            name: testCase.title, // Use the original test title
             status: testResult.status === testCase.expectedStatus
                 ? 'passed'
                 : this.mapPlaywrightStatusToCtrf(testResult.status),
@@ -126,8 +133,8 @@ class GenerateCtrfReport {
             test.trace = this.extractFailureDetails(testResult).trace;
             test.snippet = this.extractFailureDetails(testResult).snippet;
             test.rawStatus = testResult.status;
-            test.tags = (_a = testCase.tags) !== null && _a !== void 0 ? _a : [];
-            test.type = (_b = this.reporterConfigOptions.testType) !== null && _b !== void 0 ? _b : 'e2e';
+            test.tags = testCase.tags ?? [];
+            test.type = this.reporterConfigOptions.testType ?? 'e2e';
             test.filePath = testCase.location.file;
             test.retries = testResult.retry;
             test.flaky = testResult.status === 'passed' && testResult.retry > 0;
@@ -141,14 +148,24 @@ class GenerateCtrfReport {
                 test.screenshot = this.extractScreenshotBase64(testResult);
             }
             test.suite = this.buildSuitePath(testCase);
-            if (((_c = this.extractMetadata(testResult)) === null || _c === void 0 ? void 0 : _c.name) !== undefined ||
-                ((_d = this.extractMetadata(testResult)) === null || _d === void 0 ? void 0 : _d.version) !== undefined)
-                test.browser = `${(_e = this.extractMetadata(testResult)) === null || _e === void 0 ? void 0 : _e.name} ${(_f = this.extractMetadata(testResult)) === null || _f === void 0 ? void 0 : _f.version}`;
+            if (this.extractMetadata(testResult)?.name !== undefined ||
+                this.extractMetadata(testResult)?.version !== undefined)
+                test.browser = `${this.extractMetadata(testResult)?.name} ${this.extractMetadata(testResult)?.version}`;
             test.attachments = this.filterValidAttachments(testResult.attachments);
-            test.stdout = testResult.stdout.map((item) => Buffer.isBuffer(item) ? item.toString() : String(item));
-            test.stderr = testResult.stderr.map((item) => Buffer.isBuffer(item) ? item.toString() : String(item));
+            test.stdout = testResult.stdout.map((item) => item && typeof item.toString === 'function' ? item.toString() : String(item));
+            test.stderr = testResult.stderr.map((item) => item && typeof item.toString === 'function' ? item.toString() : String(item));
+            // Initialize extra object
+            let extraData = {};
             if (this.reporterConfigOptions.annotations !== undefined) {
-                test.extra = { annotations: testCase.annotations };
+                extraData.annotations = testCase.annotations;
+            }
+            // Merge CTRF metadata extra data
+            if (metadata?.extra) {
+                extraData = { ...extraData, ...metadata.extra };
+            }
+            // Only set extra if there's data
+            if (Object.keys(extraData).length > 0) {
+                test.extra = extraData;
             }
             if (testCase.results.length > 1) {
                 const retryResults = testCase.results.slice(0, -1);
@@ -237,8 +254,8 @@ class GenerateCtrfReport {
     }
     extractMetadata(testResult) {
         const metadataAttachment = testResult.attachments.find((attachment) => attachment.name === 'metadata.json');
-        if ((metadataAttachment === null || metadataAttachment === void 0 ? void 0 : metadataAttachment.body) !== null &&
-            (metadataAttachment === null || metadataAttachment === void 0 ? void 0 : metadataAttachment.body) !== undefined) {
+        if (metadataAttachment?.body !== null &&
+            metadataAttachment?.body !== undefined) {
             try {
                 const metadataRaw = metadataAttachment.body.toString('utf-8');
                 return JSON.parse(metadataRaw);
@@ -276,11 +293,10 @@ class GenerateCtrfReport {
         return pathComponents.join(' > ');
     }
     extractScreenshotBase64(testResult) {
-        var _a;
         const screenshotAttachment = testResult.attachments.find((attachment) => attachment.name === 'screenshot' &&
             (attachment.contentType === 'image/jpeg' ||
                 attachment.contentType === 'image/png'));
-        return (_a = screenshotAttachment === null || screenshotAttachment === void 0 ? void 0 : screenshotAttachment.body) === null || _a === void 0 ? void 0 : _a.toString('base64');
+        return screenshotAttachment?.body?.toString('base64');
     }
     extractFailureDetails(testResult) {
         if ((testResult.status === 'failed' ||
@@ -309,11 +325,10 @@ class GenerateCtrfReport {
         return count;
     }
     writeReportToFile(data) {
-        var _a, _b;
-        const filePath = path_1.default.join((_a = this.reporterConfigOptions.outputDir) !== null && _a !== void 0 ? _a : this.defaultOutputDir, (_b = this.reporterConfigOptions.outputFile) !== null && _b !== void 0 ? _b : this.defaultOutputFile);
+        const filePath = path.join(this.reporterConfigOptions.outputDir ?? this.defaultOutputDir, this.reporterConfigOptions.outputFile ?? this.defaultOutputFile);
         const str = JSON.stringify(data, null, 2);
         try {
-            fs_1.default.writeFileSync(filePath, str + '\n');
+            fs.writeFileSync(filePath, str + '\n');
             console.log(`${this.reporterName}: successfully written ctrf json to %s/%s`, this.reporterConfigOptions.outputDir, this.reporterConfigOptions.outputFile);
         }
         catch (error) {
@@ -321,7 +336,6 @@ class GenerateCtrfReport {
         }
     }
     processStep(test, step) {
-        var _a;
         if (step.category === 'test.step') {
             const stepStatus = step.error === undefined
                 ? this.mapPlaywrightStatusToCtrf('passed')
@@ -330,7 +344,7 @@ class GenerateCtrfReport {
                 name: step.title,
                 status: stepStatus,
             };
-            (_a = test.steps) === null || _a === void 0 ? void 0 : _a.push(currentStep);
+            test.steps?.push(currentStep);
         }
         const childSteps = step.steps;
         if (childSteps.length > 0) {
@@ -342,14 +356,11 @@ class GenerateCtrfReport {
     filterValidAttachments(attachments) {
         return attachments
             .filter((attachment) => attachment.path !== undefined)
-            .map((attachment) => {
-            var _a;
-            return ({
-                name: attachment.name,
-                contentType: attachment.contentType,
-                path: (_a = attachment.path) !== null && _a !== void 0 ? _a : '',
-            });
-        });
+            .map((attachment) => ({
+            name: attachment.name,
+            contentType: attachment.contentType,
+            path: attachment.path ?? '',
+        }));
     }
 }
-exports.default = GenerateCtrfReport;
+export default GenerateCtrfReport;

package/dist/index.d.ts

@@ -1 +1 @@
-export { default } from './generate-report';
+export { default } from './generate-report.js';

package/dist/index.js

@@ -1,8 +1 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = void 0;
-var generate_report_1 = require("./generate-report");
-Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(generate_report_1).default; } });
+export { default } from './generate-report.js';

package/dist/playwright-runtime.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Playwright-specific CTRF runtime
+ * This implements the CtrfRuntime interface using Playwright test attachments
+ */
+import type { CtrfRuntime } from 'ctrf';
+/**
+ * Playwright-specific CTRF runtime implementation
+ */
+export declare class CtrfPlaywrightRuntime implements CtrfRuntime {
+    private sendMessage;
+    addExtra(key: string, value: unknown): Promise<void>;
+}
+/**
+ * Extracted metadata from test attachments
+ */
+export interface ExtractedCtrfMetadata {
+    extra?: Record<string, unknown>;
+}
+/**
+ * Extracts CTRF metadata from Playwright test attachments
+ * This is used by the reporter to get metadata from test attachments
+ */
+export declare function extractCtrfMetadata(attachments: Array<{
+    name: string;
+    contentType: string;
+    body?: any;
+}>): ExtractedCtrfMetadata;
+/**
+ * Force initialize the Playwright runtime
+ * This can be called by the reporter to ensure runtime is available
+ */
+export declare function ensurePlaywrightRuntime(): void;

package/dist/playwright-runtime.js

@@ -0,0 +1,82 @@
+/**
+ * Playwright-specific CTRF runtime
+ * This implements the CtrfRuntime interface using Playwright test attachments
+ */
+import { test } from '@playwright/test';
+import { setGlobalCtrfRuntime } from 'ctrf';
+/**
+ * CTRF metadata content type for Playwright attachments
+ */
+const CTRF_RUNTIME_MESSAGE_CONTENT_TYPE = 'application/x-ctrf-runtime-message';
+/**
+ * Playwright-specific CTRF runtime implementation
+ */
+export class CtrfPlaywrightRuntime {
+    async sendMessage(message) {
+        try {
+            const testInfo = test.info();
+            await testInfo.attach(`CTRF Runtime Message (${message.type})`, {
+                contentType: CTRF_RUNTIME_MESSAGE_CONTENT_TYPE,
+                body: JSON.stringify(message)
+            });
+        }
+        catch (error) {
+            console.warn('CTRF: Failed to send runtime message. Make sure this is called within a Playwright test context.');
+        }
+    }
+    async addExtra(key, value) {
+        await this.sendMessage({
+            type: 'test_metadata',
+            data: { extra: { [key]: value } }
+        });
+    }
+}
+/**
+ * Auto-configure the Playwright CTRF runtime
+ * This is called when this module is imported
+ */
+function initializePlaywrightRuntime() {
+    // Always set up the Playwright runtime when this module is loaded
+    // This ensures the runtime is available before any test code runs
+    setGlobalCtrfRuntime(new CtrfPlaywrightRuntime());
+}
+// Auto-initialize as soon as this module is loaded
+initializePlaywrightRuntime();
+/**
+ * Extracts CTRF metadata from Playwright test attachments
+ * This is used by the reporter to get metadata from test attachments
+ */
+export function extractCtrfMetadata(attachments) {
+    const result = {
+        extra: {}
+    };
+    for (const attachment of attachments) {
+        try {
+            if (attachment.contentType === CTRF_RUNTIME_MESSAGE_CONTENT_TYPE && attachment.body) {
+                const message = JSON.parse(attachment.body.toString('utf-8'));
+                if (message.type === 'test_metadata' && message.data.extra) {
+                    // Simple merge for metadata
+                    for (const [key, value] of Object.entries(message.data.extra)) {
+                        result.extra[key] = value;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Silently ignore parsing errors for non-CTRF attachments
+            console.warn(`Failed to parse CTRF runtime message from attachment ${attachment.name}:`, error);
+        }
+    }
+    // Clean up empty extra object
+    if (result.extra && Object.keys(result.extra).length === 0) {
+        delete result.extra;
+    }
+    return result;
+}
+/**
+ * Force initialize the Playwright runtime
+ * This can be called by the reporter to ensure runtime is available
+ */
+export function ensurePlaywrightRuntime() {
+    setGlobalCtrfRuntime(new CtrfPlaywrightRuntime());
+}

package/dist/runtime.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Extracted metadata from test attachments
+ */
+export interface ExtractedCtrfMetadata {
+    extra?: Record<string, unknown>;
+    displayName?: string;
+}
+/**
+ * Facade functions that call the global runtime
+ */
+export declare const displayName: (name: string) => Promise<void>;
+export declare const addExtra: (key: string, value: unknown) => Promise<void>;
+export declare const tags: (...tagList: string[]) => Promise<void>;
+export declare const priority: (level: string) => Promise<void>;
+export declare const severity: (level: string) => Promise<void>;
+export declare const link: (url: string, name?: string) => Promise<void>;
+/**
+ * Convenience method for setting multiple tags at once
+ */
+export declare const tag: (tagName: string) => Promise<void>;
+/**
+ * Extracts CTRF metadata from Playwright test attachments
+ */
+export declare function extractCtrfMetadata(attachments: Array<{
+    name: string;
+    contentType: string;
+    body?: any;
+}>): ExtractedCtrfMetadata;

package/dist/runtime.js

@@ -0,0 +1,165 @@
+/**
+ * CTRF metadata content type for Playwright attachments
+ */
+const CTRF_RUNTIME_MESSAGE_CONTENT_TYPE = 'application/x-ctrf-runtime-message';
+/**
+ * Gets the current test info from Playwright's global context
+ */
+function getCurrentTestInfo() {
+    // In Playwright tests, 'test' is available globally
+    try {
+        // Access Playwright's global test object
+        const globalTest = globalThis.test;
+        if (globalTest && typeof globalTest.info === 'function') {
+            return globalTest.info();
+        }
+        // Fallback: try to get from playwright/test module
+        // This will work when the runtime is loaded in a test context
+        const { test } = require('@playwright/test');
+        return test.info();
+    }
+    catch (error) {
+        throw new Error('CTRF runtime must be used within a Playwright test context. Make sure to import this module only in test files.');
+    }
+}
+/**
+ * Global CTRF runtime for Playwright using message-based communication
+ */
+class CtrfPlaywrightRuntime {
+    async sendMessage(message) {
+        const testInfo = getCurrentTestInfo();
+        await testInfo.attach(`CTRF Runtime Message (${message.type})`, {
+            contentType: CTRF_RUNTIME_MESSAGE_CONTENT_TYPE,
+            body: JSON.stringify(message)
+        });
+    }
+    async displayName(name) {
+        await this.sendMessage({
+            type: 'display_name',
+            data: { name }
+        });
+    }
+    async addExtra(key, value) {
+        await this.sendMessage({
+            type: 'test_metadata',
+            data: { extra: { [key]: value } }
+        });
+    }
+    async tags(...tags) {
+        await this.sendMessage({
+            type: 'test_metadata',
+            data: { extra: { tags } }
+        });
+    }
+    async priority(level) {
+        await this.sendMessage({
+            type: 'test_metadata',
+            data: { extra: { priority: level } }
+        });
+    }
+    async severity(level) {
+        await this.sendMessage({
+            type: 'test_metadata',
+            data: { extra: { severity: level } }
+        });
+    }
+    async link(url, name) {
+        const linkData = name ? { url, name } : { url };
+        await this.sendMessage({
+            type: 'test_metadata',
+            data: { extra: { links: [linkData] } }
+        });
+    }
+}
+/**
+ * Global CTRF runtime instance
+ */
+const globalCtrfRuntime = new CtrfPlaywrightRuntime();
+/**
+ * Facade functions that call the global runtime
+ */
+export const displayName = (name) => {
+    return globalCtrfRuntime.displayName(name);
+};
+export const addExtra = (key, value) => {
+    return globalCtrfRuntime.addExtra(key, value);
+};
+export const tags = (...tagList) => {
+    return globalCtrfRuntime.tags(...tagList);
+};
+export const priority = (level) => {
+    return globalCtrfRuntime.priority(level);
+};
+export const severity = (level) => {
+    return globalCtrfRuntime.severity(level);
+};
+export const link = (url, name) => {
+    return globalCtrfRuntime.link(url, name);
+};
+/**
+ * Convenience method for setting multiple tags at once
+ */
+export const tag = (tagName) => {
+    return tags(tagName);
+};
+/**
+ * Extracts CTRF metadata from Playwright test attachments
+ */
+export function extractCtrfMetadata(attachments) {
+    const result = {
+        extra: {}
+    };
+    for (const attachment of attachments) {
+        try {
+            if (attachment.contentType === CTRF_RUNTIME_MESSAGE_CONTENT_TYPE && attachment.body) {
+                const message = JSON.parse(attachment.body.toString('utf-8'));
+                switch (message.type) {
+                    case 'display_name':
+                        result.displayName = message.data.name;
+                        break;
+                    case 'test_metadata':
+                        if (message.data.extra) {
+                            // Handle different metadata types
+                            for (const [key, value] of Object.entries(message.data.extra)) {
+                                if (key === 'links' && Array.isArray(value)) {
+                                    // Accumulate links
+                                    if (!result.extra.links) {
+                                        result.extra.links = [];
+                                    }
+                                    if (Array.isArray(result.extra.links)) {
+                                        result.extra.links.push(...value);
+                                    }
+                                }
+                                else if (key === 'tags' && Array.isArray(value)) {
+                                    // Merge tags
+                                    if (!result.extra.tags) {
+                                        result.extra.tags = [];
+                                    }
+                                    if (Array.isArray(result.extra.tags)) {
+                                        result.extra.tags.push(...value);
+                                    }
+                                    else {
+                                        result.extra.tags = value;
+                                    }
+                                }
+                                else {
+                                    // Simple merge for other metadata
+                                    result.extra[key] = value;
+                                }
+                            }
+                        }
+                        break;
+                }
+            }
+        }
+        catch (error) {
+            // Silently ignore parsing errors for non-CTRF attachments
+            console.warn(`Failed to parse CTRF runtime message from attachment ${attachment.name}:`, error);
+        }
+    }
+    // Clean up empty extra object
+    if (result.extra && Object.keys(result.extra).length === 0) {
+        delete result.extra;
+    }
+    return result;
+}

package/package.json

@@ -1,15 +1,33 @@
 {
   "name": "playwright-ctrf-json-reporter",
-  "version": "0.0.24",
+  "version": "0.0.25-next-0",
   "description": "A Playwright JSON test reporter to create test results reports",
+  "type": "module",
   "main": "dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "engines": {
+    "node": ">=20.19.0"
+  },
   "scripts": {
-    "build": "tsc",
-    "test": "jest",
+    "build": "tsc -p .",
+    "build:check": "tsc -p . -noEmit",
+    "build:watch": "tsc -p . --watch",
+    "clean": "rm -rf dist && rm -rf coverage && rm -rf ctrf",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
     "lint": "eslint . --ext .ts --fix",
-    "lint-check": "eslint . --ext .ts",
+    "lint:check": "eslint . --ext .ts",
     "format": "prettier --write .",
-    "format-check": "prettier --check ."
+    "format:check": "prettier --check .",
+    "docs": "typedoc",
+    "docs:watch": "typedoc --watch",
+    "all": "npm run build:check && npm run test:coverage && npm run lint && npm run format && npm run build"
   },
   "repository": "github:ctrf-io/playwright-ctrf-json-report",
   "homepage": "https://ctrf.io",
@@ -20,20 +38,20 @@
   "author": "Matthew Thomas",
   "license": "MIT",
   "devDependencies": {
+    "@d2t/vitest-ctrf-json-reporter": "^1.3.0",
+    "@eslint/js": "^9.32.0",
     "@playwright/test": "^1.55.0",
-    "@types/jest": "^29.5.6",
-    "@types/node": "^20.8.7",
-    "@typescript-eslint/eslint-plugin": "^6.12.0",
-    "eslint": "^8.54.0",
-    "eslint-config-prettier": "^9.0.0",
-    "eslint-config-standard-with-typescript": "^40.0.0",
-    "eslint-plugin-import": "^2.29.0",
-    "eslint-plugin-n": "^16.3.1",
-    "eslint-plugin-prettier": "^5.0.1",
-    "eslint-plugin-promise": "^6.1.1",
-    "jest": "^29.7.0",
-    "prettier": "^3.1.0",
-    "ts-jest": "^29.1.1",
-    "typescript": "^5.3.2"
+    "@types/node": "^24.7.2",
+    "@vitest/coverage-v8": "^3.2.4",
+    "eslint": "^9.32.0",
+    "prettier": "^3.5.3",
+    "typedoc": "^0.28.9",
+    "typedoc-plugin-markdown": "^4.8.0",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.38.0",
+    "vitest": "^3.2.4"
+  },
+  "dependencies": {
+    "ctrf": "0.0.16-next.1"
   }
 }