reporting-labs 0.6.9 → 0.6.11

package/dist/wdio/finalize.js

@@ -0,0 +1,203 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reportingLabsComplete = reportingLabsComplete;
+/**
+ * Combines the per-runner partials written by the WDIO reporter into the one report —
+ * index.html, report.json and (best-effort) report.pdf. Call it from `onComplete` in wdio.conf:
+ *
+ *   import { reportingLabsComplete } from 'reporting-labs/wdio';
+ *   export const config = {
+ *     reporters: [[ReportingLabsWdioReporter, { outputFolder: 'reporting-labs' }]],
+ *     async onComplete() { await reportingLabsComplete({ outputFolder: 'reporting-labs', title: 'My suite' }); },
+ *   };
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const template_1 = require("../template");
+const mask_1 = require("../mask");
+const env_1 = require("./env");
+async function reportingLabsComplete(options = {}) {
+    const outputFolder = options.outputFolder || 'reporting-labs';
+    const partsDir = path.join(outputFolder, '.rl-wdio');
+    if (!fs.existsSync(partsDir))
+        return undefined;
+    const files = fs.readdirSync(partsDir).filter(f => f.endsWith('.json'));
+    if (!files.length)
+        return undefined;
+    const masker = (0, mask_1.makeMasker)(options.maskKeys || [], { knownValues: options.maskValues || [], fromEnv: options.maskFromEnv !== false });
+    const tests = [];
+    let startTime = Number.MAX_SAFE_INTEGER;
+    let endTime = 0;
+    let runStatus = 'passed';
+    const workers = files.length;
+    for (const f of files) {
+        let part;
+        try {
+            part = JSON.parse(fs.readFileSync(path.join(partsDir, f), 'utf8'));
+        }
+        catch {
+            continue;
+        }
+        if (typeof part.startTime === 'number')
+            startTime = Math.min(startTime, part.startTime);
+        if (typeof part.endTime === 'number')
+            endTime = Math.max(endTime, part.endTime);
+        if (part.runStatus === 'failed')
+            runStatus = 'failed';
+        for (const t of part.tests || [])
+            tests.push(t);
+    }
+    if (startTime === Number.MAX_SAFE_INTEGER)
+        startTime = Date.now();
+    if (!endTime)
+        endTime = Date.now();
+    const stats = { passed: 0, failed: 0, skipped: 0, flaky: 0, timedOut: 0, interrupted: 0, total: tests.length };
+    for (const t of tests)
+        stats[t.outcome]++;
+    const projects = [...new Set(tests.map(t => t.project).filter(Boolean))];
+    const base = process.cwd();
+    const dims = (options.dimensions ?? ['priority', 'severity', 'feature', 'owner']).map(d => d.toLowerCase());
+    const histOn = options.history?.enabled ?? true;
+    const histFile = path.resolve(base, options.history?.file ?? 'reporting-labs.history.json');
+    let entries = [];
+    if (histOn) {
+        try {
+            entries = JSON.parse(fs.readFileSync(histFile, 'utf8'));
+        }
+        catch { /* first run */ }
+    }
+    const failedCount = stats.failed + stats.timedOut + stats.interrupted;
+    const code = (o) => o === 'passed' ? 'p' : o === 'flaky' ? 'k' : o === 'skipped' ? 's' : 'f';
+    const perTest = {};
+    for (const t of tests) {
+        const last = t.results[t.results.length - 1];
+        perTest[t.key] = [code(t.outcome), Math.round(last?.duration ?? t.duration)];
+    }
+    const current = {
+        time: startTime, duration: endTime - startTime,
+        passed: stats.passed, failed: failedCount, flaky: stats.flaky, skipped: stats.skipped, total: stats.total,
+        label: options.metadata?.build ?? (0, env_1.ciRunLabel)(process.env) ?? options.metadata?.branch, tests: perTest,
+    };
+    const history = [...entries, current].slice(-(options.history?.keep ?? 30));
+    if (histOn) {
+        try {
+            fs.writeFileSync(histFile, JSON.stringify(history, null, 1));
+        }
+        catch { /* read-only fs */ }
+    }
+    const metadata = Object.fromEntries(Object.entries(options.metadata ?? {}).map(([k, v]) => [k, masker.maskStr(String(v))]));
+    const bdd = options.bdd ?? tests.some(t => t.results.some(r => r.steps.some(st => /^(Given|When|Then|And|But)\b/.test(st.title))));
+    const data = {
+        title: masker.maskStr(options.title ?? 'Test report'),
+        generatedAt: Date.now(),
+        startTime,
+        duration: endTime - startTime,
+        metadata,
+        projects,
+        workers,
+        stats,
+        tests,
+        history,
+        bdd,
+        rootDir: base,
+        env: (0, env_1.collectEnv)(base, Object.fromEntries(Object.entries(options.env ?? {}).map(([k, v]) => [k, masker.maskStr(String(v))])), [...new Set(projects)], workers, options.metadata?.branch).map(r => ({ ...r, v: masker.maskStr(r.v) })),
+        runStatus,
+        globalErrors: [],
+        globalOutput: [],
+        options: {
+            logo: options.logo,
+            accent: options.accent,
+            theme: options.theme ?? 'auto',
+            palette: options.palette ?? 'lab',
+            embedFonts: options.embedFonts ?? true,
+            sections: options.sections ?? [],
+            widgets: { runStrip: true, outcome: true, attention: true, dimensions: true, timeline: true, durations: true, tags: true, slowest: true, projects: true, flaky: true, environment: true, skipped: true },
+            dimensions: dims,
+            dimensionOrder: {
+                priority: ['P0', 'P1', 'P2', 'P3', 'P4'],
+                severity: ['blocker', 'critical', 'major', 'high', 'medium', 'normal', 'minor', 'low', 'trivial'],
+                ...(options.dimensionOrder ?? {}),
+            },
+            project: options.project,
+            links: Object.fromEntries(Object.entries(options.links ?? {}).map(([k, v]) => [k.toLowerCase(), typeof v === 'string' ? v : v.url])),
+            customCss: options.customCss ?? '',
+            editorLinks: options.editorLinks ?? !process.env.CI,
+        },
+    };
+    fs.mkdirSync(outputFolder, { recursive: true });
+    const htmlFile = path.join(outputFolder, options.outputFile ?? 'index.html');
+    fs.writeFileSync(htmlFile, (0, template_1.renderHtml)(data), 'utf8');
+    if (options.emitJson !== false)
+        fs.writeFileSync(path.join(outputFolder, options.jsonFile ?? 'report.json'), JSON.stringify(data), 'utf8');
+    // tidy the partials
+    try {
+        fs.rmSync(partsDir, { recursive: true, force: true });
+    }
+    catch { /* leave them */ }
+    if (options.announce !== false) {
+        console.log(`\n  reporting-labs: report written to ${path.relative(process.cwd(), htmlFile)}`);
+    }
+    if (options.pdf !== false)
+        await writePdf(htmlFile, outputFolder, options);
+    if (options.announce !== false)
+        console.log('');
+    return htmlFile;
+}
+/** Render the report's print layout to a PDF with the Chromium Playwright ships. Best-effort. */
+async function writePdf(htmlFile, outputFolder, options) {
+    const name = (typeof options.pdf === 'object' && options.pdf?.file) || 'report.pdf';
+    const pdfFile = path.join(outputFolder, name);
+    try {
+        const { chromium } = await import('@playwright/test');
+        const { pathToFileURL } = await import('url');
+        const browser = await chromium.launch();
+        try {
+            const page = await browser.newPage();
+            await page.goto(pathToFileURL(htmlFile).href, { waitUntil: 'load' });
+            await page.evaluate(() => window.reportingLabsPreparePrint?.());
+            await page.pdf({ path: pdfFile, printBackground: true, preferCSSPageSize: true });
+        }
+        finally {
+            await browser.close();
+        }
+        if (options.announce !== false)
+            console.log(`  reporting-labs: PDF written to ${path.relative(process.cwd(), pdfFile)}`);
+    }
+    catch (e) {
+        if (options.announce !== false)
+            console.log(`  reporting-labs: PDF skipped — ${String(e.message).split('\n')[0]}`);
+    }
+}

package/dist/wdio/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * reportingLabs for WebdriverIO.
+ *
+ *   // wdio.conf.ts
+ *   import ReportingLabsReporter, { reportingLabsComplete } from 'reporting-labs/wdio';
+ *
+ *   export const config = {
+ *     reporters: [[ReportingLabsReporter, { outputFolder: 'reporting-labs' }]],
+ *     async onComplete() { await reportingLabsComplete({ outputFolder: 'reporting-labs', title: 'My suite' }); },
+ *   };
+ */
+import ReportingLabsWdioReporter from './reporter';
+export { ReportingLabsWdioReporter };
+export type { ReportingLabsWdioOptions } from './reporter';
+export { reportingLabsComplete } from './finalize';
+export type { ReportingLabsCompleteOptions } from './finalize';
+export default ReportingLabsWdioReporter;

package/dist/wdio/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reportingLabsComplete = exports.ReportingLabsWdioReporter = void 0;
+/**
+ * reportingLabs for WebdriverIO.
+ *
+ *   // wdio.conf.ts
+ *   import ReportingLabsReporter, { reportingLabsComplete } from 'reporting-labs/wdio';
+ *
+ *   export const config = {
+ *     reporters: [[ReportingLabsReporter, { outputFolder: 'reporting-labs' }]],
+ *     async onComplete() { await reportingLabsComplete({ outputFolder: 'reporting-labs', title: 'My suite' }); },
+ *   };
+ */
+const reporter_1 = __importDefault(require("./reporter"));
+exports.ReportingLabsWdioReporter = reporter_1.default;
+var finalize_1 = require("./finalize");
+Object.defineProperty(exports, "reportingLabsComplete", { enumerable: true, get: function () { return finalize_1.reportingLabsComplete; } });
+exports.default = reporter_1.default;

package/dist/wdio/reporter.d.ts

@@ -0,0 +1,67 @@
+/**
+ * reportingLabs reporter for WebdriverIO.
+ *
+ * WDIO drives a reporter by emitting lifecycle events onto it and reading `isSynchronised`, so this
+ * class is a plain EventEmitter — it needs no `@wdio/reporter` at runtime and stays CommonJS, which
+ * loads on every Node version. One instance runs per runner (per spec / worker); it collects that
+ * runner's suites, tests, WebDriver-command steps, errors and (on failure) a screenshot, then writes
+ * a partial JSON. `reportingLabsComplete()` (a one-line `onComplete` hook) combines every partial into
+ * the one report — the same index.html, report.json and report.pdf the Playwright reporter produces.
+ *
+ * Nothing here touches the Playwright reporter; it only reuses the shared, pure helpers.
+ */
+import { EventEmitter } from 'node:events';
+declare const META_KEYS: string[];
+export interface ReportingLabsWdioOptions {
+    outputFolder?: string;
+    title?: string;
+    screenshot?: 'on-failure' | 'always' | 'off';
+    maskKeys?: string[];
+    maskValues?: string[];
+    maskFromEnv?: boolean;
+    [k: string]: unknown;
+}
+export default class ReportingLabsWdioReporter extends EventEmitter {
+    options: ReportingLabsWdioOptions;
+    outputStream: {
+        write: (_c: unknown) => boolean;
+    };
+    private masker;
+    private startTime;
+    private suiteStack;
+    private rlTests;
+    private specs;
+    private cur?;
+    private elTypes;
+    private cid;
+    private capsName;
+    private runStatus;
+    private pending;
+    private endInfo?;
+    private written;
+    constructor(options?: ReportingLabsWdioOptions);
+    /** WDIO polls this before tearing a worker down; we hold it open until the partial is written. */
+    get isSynchronised(): boolean;
+    write(_content: unknown): void;
+    private safe;
+    private onRunnerStart;
+    private onSuiteStart;
+    private onSuiteEnd;
+    private onTestStart;
+    private onBeforeCommand;
+    private onAfterCommand;
+    private endTest;
+    /** Best-effort screenshot of the live session on failure. Async — gated by isSynchronised so the
+     *  partial is written only once it resolves. */
+    private maybeShot;
+    private toError;
+    private onRunnerEnd;
+    private tryWrite;
+    private rel;
+}
+/** Pull meta (priority/severity/owner/...) from WDIO tags like `@priority:P1`, `@P1`, `@critical`. */
+export declare function metaFromTags(tags: string[], dims: string[]): {
+    meta: Record<string, string>;
+    clean: string[];
+};
+export { META_KEYS };

package/dist/wdio/reporter.js

@@ -0,0 +1,332 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.META_KEYS = void 0;
+exports.metaFromTags = metaFromTags;
+/**
+ * reportingLabs reporter for WebdriverIO.
+ *
+ * WDIO drives a reporter by emitting lifecycle events onto it and reading `isSynchronised`, so this
+ * class is a plain EventEmitter — it needs no `@wdio/reporter` at runtime and stays CommonJS, which
+ * loads on every Node version. One instance runs per runner (per spec / worker); it collects that
+ * runner's suites, tests, WebDriver-command steps, errors and (on failure) a screenshot, then writes
+ * a partial JSON. `reportingLabsComplete()` (a one-line `onComplete` hook) combines every partial into
+ * the one report — the same index.html, report.json and report.pdf the Playwright reporter produces.
+ *
+ * Nothing here touches the Playwright reporter; it only reuses the shared, pure helpers.
+ */
+const node_events_1 = require("node:events");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const mask_1 = require("../mask");
+const explain_1 = require("../explain");
+const META_KEYS = ['priority', 'severity', 'feature', 'owner', 'epic', 'story', 'issue', 'bug', 'component', 'module', 'team', 'sprint', 'testcase', 'tms', 'requirement'];
+exports.META_KEYS = META_KEYS;
+/** WebDriver command name → readable step verb. Commands not listed (reads, internals) are not steps. */
+const CMD = {
+    navigateTo: 'open', url: 'open', back: 'back', forward: 'forward', refresh: 'refresh',
+    elementClick: 'click', click: 'click', doubleClick: 'double click',
+    elementSendKeys: 'set value', setValue: 'set value', addValue: 'add value', elementClear: 'clear', clearValue: 'clear',
+    findElement: 'find', findElements: 'find all', findElementFromElement: 'find', findElementsFromElement: 'find all',
+    switchToFrame: 'switch to frame', switchToParentFrame: 'switch to parent frame', switchToWindow: 'switch to window',
+    acceptAlert: 'accept alert', dismissAlert: 'dismiss alert', sendAlertText: 'type into alert',
+    performActions: 'perform actions', executeScript: 'execute script', executeAsyncScript: 'execute async script',
+    setWindowRect: 'resize window', maximizeWindow: 'maximize window', minimizeWindow: 'minimize window', fullscreenWindow: 'fullscreen window',
+    uploadFile: 'upload file', addCookie: 'add cookie', deleteCookie: 'delete cookie', deleteAllCookies: 'delete all cookies',
+};
+class ReportingLabsWdioReporter extends node_events_1.EventEmitter {
+    constructor(options = {}) {
+        super();
+        this.outputStream = { write: (_c) => true };
+        this.startTime = Date.now();
+        this.suiteStack = [];
+        this.rlTests = [];
+        this.specs = [];
+        this.elTypes = {};
+        this.cid = '';
+        this.capsName = '';
+        this.runStatus = 'passed';
+        this.pending = 0;
+        this.written = false;
+        this.setMaxListeners(0);
+        this.options = options || {};
+        this.masker = (0, mask_1.makeMasker)(this.options.maskKeys || [], { knownValues: this.options.maskValues || [], fromEnv: this.options.maskFromEnv !== false });
+        this.on('runner:start', (r) => this.safe(() => this.onRunnerStart(r)));
+        this.on('suite:start', (s) => this.safe(() => this.onSuiteStart(s)));
+        this.on('suite:end', () => this.safe(() => this.onSuiteEnd()));
+        this.on('test:start', (t) => this.safe(() => this.onTestStart(t)));
+        this.on('test:pass', (t) => this.safe(() => this.endTest(t, 'passed')));
+        this.on('test:fail', (t) => this.safe(() => { this.runStatus = 'failed'; this.endTest(t, 'failed'); }));
+        this.on('test:skip', (t) => this.safe(() => this.endTest(t, 'skipped', t.pendingReason)));
+        this.on('test:pending', (t) => this.safe(() => this.endTest(t, 'skipped', t.pendingReason)));
+        this.on('client:beforeCommand', (c) => this.safe(() => this.onBeforeCommand(c)));
+        this.on('client:afterCommand', (c) => this.safe(() => this.onAfterCommand(c)));
+        this.on('runner:end', () => this.safe(() => this.onRunnerEnd()));
+    }
+    /** WDIO polls this before tearing a worker down; we hold it open until the partial is written. */
+    get isSynchronised() {
+        return this.written || (this.pending === 0 && !this.endInfo);
+    }
+    write(_content) { }
+    safe(fn) { try {
+        fn();
+    }
+    catch { /* a reporter bug must never fail the run */ } }
+    onRunnerStart(runner) {
+        this.startTime = Date.now();
+        this.cid = runner.cid || '';
+        this.specs = runner.specs || [];
+        this.capsName = capsName(runner.capabilities);
+    }
+    onSuiteStart(suite) {
+        if (suite.title)
+            this.suiteStack.push(suite.title);
+    }
+    onSuiteEnd() { this.suiteStack.pop(); }
+    onTestStart(test) {
+        const now = Date.now();
+        const result = {
+            retry: test.retries || 0, status: 'passed', duration: 0, startTime: now, workerIndex: numericCid(this.cid),
+            errors: [], steps: [], attachments: [], stdout: [], stderr: [], logs: [], data: [], api: [],
+        };
+        const file = this.rel(test.file || this.specs[0] || '');
+        const tagSource = [test.title || '', ...this.suiteStack].join(' ');
+        const tags = (tagSource.match(/@[A-Za-z][\w:.=-]*/g) || []);
+        const { meta } = metaFromTags(tags, META_KEYS);
+        const t = {
+            id: test.uid || `${file}:${test.title}`,
+            key: '', title: this.masker.maskStr(test.title || ''), path: this.suiteStack.map(s => this.masker.maskStr(s)),
+            file, line: 0, project: this.capsName, tags, annotations: [], meta,
+            outcome: 'passed', duration: 0, results: [result], retries: test.retries,
+        };
+        t.key = `${t.project}::${t.file}::${[...t.path, t.title].join(' › ')}`;
+        this.cur = { test: t, result, stepStack: [] };
+    }
+    onBeforeCommand(cmd) {
+        if (!this.cur)
+            return;
+        // a value typed into a password / secret field is masked: WDIO reads the element's `type` property
+        // right before typing, so look up what we learned for this element id.
+        const fieldType = this.elTypes[elementId(cmd.endpoint)] || '';
+        const title = cmdTitle(cmd, this.masker, fieldType);
+        if (!title)
+            return;
+        const step = { title, category: 'wdio', duration: 0, steps: [] };
+        step._start = Date.now();
+        const parent = this.cur.stepStack[this.cur.stepStack.length - 1];
+        (parent ? parent.steps : this.cur.result.steps).push(step);
+        this.cur.stepStack.push(step);
+    }
+    onAfterCommand(cmd) {
+        // record element input types so the next sendKeys to that element can be masked
+        if (cmd && cmd.command === 'getElementProperty' && /\/property\/type$/.test(cmd.endpoint || '')) {
+            const id = elementId(cmd.endpoint);
+            const v = cmd.result?.value;
+            if (id && typeof v === 'string')
+                this.elTypes[id] = v;
+        }
+        if (!this.cur)
+            return;
+        const step = this.cur.stepStack.pop();
+        if (step) {
+            step.duration = Date.now() - (step._start || Date.now());
+            delete step._start;
+        }
+    }
+    endTest(test, status, skipReason) {
+        if (!this.cur)
+            this.onTestStart(test); // a skipped / pending test may never fire test:start
+        if (!this.cur)
+            return;
+        const { test: t, result } = this.cur;
+        this.cur.stepStack.length = 0;
+        result.status = status;
+        result.duration = test.duration ?? (Date.now() - result.startTime);
+        let outcome = status;
+        if (status === 'passed' && (test.retries || 0) > 0)
+            outcome = 'flaky';
+        t.outcome = outcome;
+        t.duration = result.duration;
+        if (skipReason) {
+            t.note = skipReason;
+            t.annotations.push({ type: 'skip', description: skipReason });
+        }
+        if (status === 'failed') {
+            const errs = (test.errors && test.errors.length ? test.errors : (test.error ? [test.error] : []));
+            for (const e of errs)
+                result.errors.push(this.toError(e));
+            this.maybeShot(result);
+        }
+        this.rlTests.push(t);
+        this.cur = undefined;
+    }
+    /** Best-effort screenshot of the live session on failure. Async — gated by isSynchronised so the
+     *  partial is written only once it resolves. */
+    maybeShot(result) {
+        if (this.options.screenshot === 'off')
+            return;
+        const b = global.browser;
+        if (!b || typeof b.takeScreenshot !== 'function')
+            return;
+        this.pending++;
+        Promise.resolve()
+            .then(() => b.takeScreenshot())
+            .then((b64) => { if (b64)
+            result.attachments.push({ name: 'screenshot', contentType: 'image/png', src: 'data:image/png;base64,' + b64 }); })
+            .catch(() => { })
+            .finally(() => { this.pending--; this.tryWrite(); });
+    }
+    toError(e) {
+        const message = this.masker.maskStr(stripAnsi(String(e?.message ?? e ?? '')));
+        const stack = e?.stack ? this.masker.maskStr(stripAnsi(String(e.stack))) : undefined;
+        const d = { message };
+        const ex = (0, explain_1.explainError)(message);
+        if (ex)
+            d.explain = ex;
+        if (stack && stack !== message)
+            d.stack = stack;
+        return d;
+    }
+    onRunnerEnd() {
+        this.endInfo = { endTime: Date.now() };
+        this.tryWrite();
+    }
+    tryWrite() {
+        if (!this.endInfo || this.pending > 0 || this.written)
+            return;
+        this.written = true;
+        try {
+            const dir = path.join(this.options.outputFolder || 'reporting-labs', '.rl-wdio');
+            fs.mkdirSync(dir, { recursive: true });
+            const part = { startTime: this.startTime, endTime: this.endInfo.endTime, runStatus: this.runStatus, tests: this.rlTests };
+            const name = `${(this.cid || 'runner').replace(/[^a-z0-9_-]/gi, '_')}-${process.pid}.json`;
+            fs.writeFileSync(path.join(dir, name), JSON.stringify(part));
+        }
+        catch { /* best-effort; finalize will simply see fewer parts */ }
+    }
+    rel(file) {
+        if (!file)
+            return file;
+        try {
+            return path.relative(process.cwd(), file).split(path.sep).join('/');
+        }
+        catch {
+            return file;
+        }
+    }
+}
+exports.default = ReportingLabsWdioReporter;
+function numericCid(cid) {
+    const m = /^(\d+)/.exec(cid || '');
+    return m ? parseInt(m[1], 10) : 0;
+}
+function capsName(caps) {
+    if (!caps)
+        return '';
+    const name = (caps.browserName || caps['appium:deviceName'] || caps.platformName || '');
+    const ver = (caps.browserVersion || caps.version || '');
+    return [name, ver].filter(Boolean).join(' ').trim();
+}
+function stripAnsi(s) { return s.replace(/\x1b\[[0-9;]*m/g, ''); }
+function elementId(endpoint) {
+    const m = /\/element\/([^/]+)\//.exec(endpoint || '');
+    return m ? m[1] : '';
+}
+function cmdTitle(cmd, masker, fieldType = '') {
+    const name = cmd.command || endpointCommand(cmd.endpoint);
+    if (!name)
+        return null;
+    const verb = CMD[name];
+    if (!verb)
+        return null;
+    const body = (cmd.body || {});
+    if (name === 'navigateTo' || name === 'url')
+        return `open ${short(String(body.url ?? ''))}`;
+    if (name === 'findElement' || name === 'findElements' || name === 'findElementFromElement' || name === 'findElementsFromElement') {
+        return `${verb} ${String(body.using ?? '')}: ${short(String(body.value ?? ''))}`.trim();
+    }
+    if (name === 'elementSendKeys' || name === 'setValue' || name === 'addValue') {
+        let text = Array.isArray(body.text) ? body.text.join('') : String(body.text ?? body.value ?? '');
+        text = /password|hidden/i.test(fieldType) ? '****' : masker.maskStr(text);
+        return `${verb} "${short(text)}"`;
+    }
+    if (name === 'executeScript' || name === 'executeAsyncScript') {
+        return `${verb} ${short(String(body.script ?? '').replace(/\s+/g, ' '))}`;
+    }
+    if (name === 'sendAlertText')
+        return 'type into alert';
+    return verb;
+}
+function endpointCommand(endpoint) {
+    if (!endpoint)
+        return null;
+    if (/\/url$/.test(endpoint))
+        return 'navigateTo';
+    if (/\/click$/.test(endpoint))
+        return 'elementClick';
+    if (/\/value$/.test(endpoint))
+        return 'elementSendKeys';
+    if (/\/clear$/.test(endpoint))
+        return 'elementClear';
+    if (/\/elements$/.test(endpoint))
+        return 'findElements';
+    if (/\/element$/.test(endpoint))
+        return 'findElement';
+    return null;
+}
+function short(s, max = 80) { return s.length <= max ? s : s.slice(0, max - 1) + '…'; }
+/** Pull meta (priority/severity/owner/...) from WDIO tags like `@priority:P1`, `@P1`, `@critical`. */
+function metaFromTags(tags, dims) {
+    const meta = {};
+    const clean = [];
+    for (const raw of tags) {
+        const tag = String(raw).replace(/^@/, '');
+        const m = /^([a-z_-]+)[:=](.+)$/i.exec(tag);
+        if (m && dims.includes(m[1].toLowerCase())) {
+            meta[m[1].toLowerCase()] = m[2];
+            continue;
+        }
+        if (/^P[0-4]$/i.test(tag) && dims.includes('priority') && !meta.priority) {
+            meta.priority = tag.toUpperCase();
+            continue;
+        }
+        if (/^(blocker|critical|major|minor|trivial)$/i.test(tag) && dims.includes('severity') && !meta.severity) {
+            meta.severity = tag.toLowerCase();
+            continue;
+        }
+        clean.push(raw);
+    }
+    return { meta, clean };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "reporting-labs",
-  "version": "0.6.9",
-  "description": "reportingLabs – beautiful, customizable single-file HTML test reports. One line of config. Playwright adapter included, more runners on the way.",
+  "version": "0.6.11",
+  "description": "reportingLabs \u2013 beautiful, customizable single-file HTML test reports. One line of config. Playwright adapter included, more runners on the way.",
   "keywords": [
     "test-report",
     "html-report",
@@ -29,6 +29,10 @@
     "./auto": {
       "types": "./dist/auto.d.ts",
       "default": "./dist/auto.js"
+    },
+    "./wdio": {
+      "types": "./dist/wdio/index.d.ts",
+      "default": "./dist/wdio/index.js"
     }
   },
   "bin": {
@@ -69,5 +73,10 @@
   },
   "engines": {
     "node": ">=18"
+  },
+  "peerDependenciesMeta": {
+    "@playwright/test": {
+      "optional": true
+    }
   }
 }