@heal-dev/heal-playwright-tracer 1.0.0

package/dist/infrastructure/ndjson-exporter-adapter/ndjson-exporter.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * Copyright: (c) Myia SAS 2026.
+ * This file and its contents are licensed under the AGPLv3 License.
+ * Please see the LICENSE file at the root of this repository
+ */
+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.NdjsonExporter = void 0;
+// NdjsonExporter — HealTraceExporter adapter that appends one JSON record
+// per line to a file on disk.
+//
+// Designed to be crash-safe: every `write()` calls `fs.writeSync()`
+// so the record is on disk before the call returns. If the test
+// process is SIGKILL'd one instruction later the file still
+// contains every record written up to that point. This is the
+// durable record of truth; the live agent path (AgentHttpExporter) is
+// best-effort and may lose its tail on crash.
+//
+// The file descriptor is opened in the constructor and closed by
+// `close()`. Callers MUST call `close()` at test teardown; omitting
+// it leaks the fd but does not lose data (writes were already
+// flushed line-by-line).
+const fs = __importStar(require("fs"));
+class NdjsonExporter {
+    constructor(filePath) {
+        this.closed = false;
+        // O_APPEND so concurrent appenders (not expected, but cheap) are
+        // safe and so truncation on reopen never happens.
+        this.fd = fs.openSync(filePath, 'a');
+    }
+    write(record) {
+        if (this.closed)
+            return;
+        fs.writeSync(this.fd, JSON.stringify(record) + '\n');
+    }
+    close() {
+        if (this.closed)
+            return Promise.resolve();
+        this.closed = true;
+        fs.closeSync(this.fd);
+        return Promise.resolve();
+    }
+}
+exports.NdjsonExporter = NdjsonExporter;

package/dist/infrastructure/perf-hooks-clock-adapter/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Copyright: (c) Myia SAS 2026.
+ * This file and its contents are licensed under the AGPLv3 License.
+ * Please see the LICENSE file at the root of this repository
+ */
+export { PerfHooksClock } from './perf-hooks-clock';

package/dist/infrastructure/perf-hooks-clock-adapter/index.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * Copyright: (c) Myia SAS 2026.
+ * This file and its contents are licensed under the AGPLv3 License.
+ * Please see the LICENSE file at the root of this repository
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PerfHooksClock = void 0;
+var perf_hooks_clock_1 = require("./perf-hooks-clock");
+Object.defineProperty(exports, "PerfHooksClock", { enumerable: true, get: function () { return perf_hooks_clock_1.PerfHooksClock; } });

package/dist/infrastructure/perf-hooks-clock-adapter/perf-hooks-clock.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright: (c) Myia SAS 2026.
+ * This file and its contents are licensed under the AGPLv3 License.
+ * Please see the LICENSE file at the root of this repository
+ */
+import type { Clock } from '../../domain/trace-event-recorder/port/clock';
+export declare class PerfHooksClock implements Clock {
+    private readonly performance;
+    now(): number;
+    wallNow(): number;
+}

package/dist/infrastructure/perf-hooks-clock-adapter/perf-hooks-clock.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * Copyright: (c) Myia SAS 2026.
+ * This file and its contents are licensed under the AGPLv3 License.
+ * Please see the LICENSE file at the root of this repository
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PerfHooksClock = void 0;
+class PerfHooksClock {
+    constructor() {
+        // Lazy require so pulling this adapter in doesn't eagerly load
+        // perf_hooks in environments that don't need it.
+        this.performance = require('perf_hooks').performance;
+    }
+    now() {
+        return this.performance.now();
+    }
+    wallNow() {
+        return Date.now();
+    }
+}
+exports.PerfHooksClock = PerfHooksClock;

package/dist/infrastructure/playwright-locator-screenshot-adapter/assertion-wrapper.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Copyright: (c) Myia SAS 2026.
+ * This file and its contents are licensed under the AGPLv3 License.
+ * Please see the LICENSE file at the root of this repository
+ */
+export declare function wrapExpect<E extends (...args: unknown[]) => unknown>(origExpect: E): E;

package/dist/infrastructure/playwright-locator-screenshot-adapter/assertion-wrapper.js

@@ -0,0 +1,109 @@
+"use strict";
+/**
+ * Copyright: (c) Myia SAS 2026.
+ * This file and its contents are licensed under the AGPLv3 License.
+ * Please see the LICENSE file at the root of this repository
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapExpect = wrapExpect;
+const overlay_helpers_1 = require("./overlay-helpers");
+const locator_patch_1 = require("./locator-patch");
+// Duck-type: a Playwright Locator always has both `.boundingBox` and
+// `.page` as functions. FrameLocator / ElementHandle / Page won't match.
+// We don't use `instanceof` because the Locator class is created lazily
+// inside Playwright and isn't reliably exported for runtime checks.
+function isLocator(target) {
+    if (!target || typeof target !== 'object')
+        return false;
+    const obj = target;
+    return typeof obj.boundingBox === 'function' && typeof obj.page === 'function';
+}
+// Assertion methods in Playwright all start with `to` (toBeVisible,
+// toHaveText, …). Every other property we see on the assertion
+// instance — `not`, symbol keys, internal fields — we leave alone.
+function isAssertionMethodName(prop) {
+    return typeof prop === 'string' && prop.startsWith('to');
+}
+function wrapAssertion(assertion, locator) {
+    return new Proxy(assertion, {
+        get(target, prop, _receiver) {
+            // Read against `target` (not the proxy) so getters like `.not`
+            // see the original `this` and don't recurse through the proxy.
+            const value = Reflect.get(target, prop, target);
+            if (prop === 'not' && value && typeof value === 'object') {
+                return wrapAssertion(value, locator);
+            }
+            if (isAssertionMethodName(prop) && typeof value === 'function') {
+                return async function patchedAssertion(...args) {
+                    const page = typeof locator.page === 'function'
+                        ? locator.page()
+                        : null;
+                    let drawnNodeId = null;
+                    const session = (0, locator_patch_1.getActiveCaptureSession)();
+                    if (page && session) {
+                        try {
+                            drawnNodeId = await session.captureWithHighlight(page, locator, `assert-${prop}`);
+                        }
+                        catch (_) {
+                            // Capture is best-effort: never block the assertion.
+                        }
+                    }
+                    try {
+                        return await value.apply(target, args);
+                    }
+                    finally {
+                        if (drawnNodeId && page) {
+                            try {
+                                await (0, overlay_helpers_1.removeOverlay)(page, drawnNodeId);
+                            }
+                            catch (_) {
+                                // Page gone — nothing to clean.
+                            }
+                        }
+                    }
+                };
+            }
+            return value;
+        },
+    });
+}
+// Build a callable wrapping `origFn(target, ...)`-shaped functions —
+// used for both `expect` and `expect.soft`.
+function wrapExpectCallable(origFn) {
+    const wrapped = function wrappedExpect(target, ...rest) {
+        const assertion = origFn.call(this, target, ...rest);
+        if (isLocator(target) && assertion && typeof assertion === 'object') {
+            return wrapAssertion(assertion, target);
+        }
+        return assertion;
+    };
+    return wrapped;
+}
+function wrapExpect(origExpect) {
+    const wrapped = wrapExpectCallable(origExpect);
+    // Copy static properties across so `wrapped.soft`, `wrapped.poll`,
+    // `wrapped.configure`, `wrapped.extend`, etc. remain callable. `soft`
+    // shares the `(target, ...)` contract so we wrap it the same way the
+    // top-level expect is wrapped; everything else is forwarded as-is.
+    for (const key of Reflect.ownKeys(origExpect)) {
+        if (key === 'length' || key === 'name' || key === 'prototype')
+            continue;
+        const descriptor = Object.getOwnPropertyDescriptor(origExpect, key);
+        if (!descriptor)
+            continue;
+        if (key === 'soft' &&
+            'value' in descriptor &&
+            typeof descriptor.value === 'function') {
+            const softFn = descriptor.value;
+            descriptor.value = wrapExpectCallable(softFn);
+        }
+        try {
+            Object.defineProperty(wrapped, key, descriptor);
+        }
+        catch (_) {
+            // Some descriptors may be non-configurable on the target; skip
+            // them — the caller can still reach them via the original expect.
+        }
+    }
+    return wrapped;
+}

package/dist/infrastructure/playwright-locator-screenshot-adapter/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright: (c) Myia SAS 2026.
+ * This file and its contents are licensed under the AGPLv3 License.
+ * Please see the LICENSE file at the root of this repository
+ */
+import type { Page } from 'playwright';
+export declare function startLocatorScreenshotCapture(samplePage: Page, outputDir: string, onScreenshotWritten: (filename: string) => void): () => void;
+export { wrapExpect } from './assertion-wrapper';
+export { ScreenshotCaptureSession } from './screenshot-capture-session';

package/dist/infrastructure/playwright-locator-screenshot-adapter/index.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * Copyright: (c) Myia SAS 2026.
+ * This file and its contents are licensed under the AGPLv3 License.
+ * Please see the LICENSE file at the root of this repository
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScreenshotCaptureSession = exports.wrapExpect = void 0;
+exports.startLocatorScreenshotCapture = startLocatorScreenshotCapture;
+const locator_patch_1 = require("./locator-patch");
+const screenshot_capture_session_1 = require("./screenshot-capture-session");
+function startLocatorScreenshotCapture(samplePage, outputDir, onScreenshotWritten) {
+    (0, locator_patch_1.ensureLocatorPrototypePatched)(samplePage);
+    const session = new screenshot_capture_session_1.ScreenshotCaptureSession(outputDir, onScreenshotWritten);
+    (0, locator_patch_1.setActiveCaptureSession)(session);
+    return () => (0, locator_patch_1.setActiveCaptureSession)(null);
+}
+var assertion_wrapper_1 = require("./assertion-wrapper");
+Object.defineProperty(exports, "wrapExpect", { enumerable: true, get: function () { return assertion_wrapper_1.wrapExpect; } });
+var screenshot_capture_session_2 = require("./screenshot-capture-session");
+Object.defineProperty(exports, "ScreenshotCaptureSession", { enumerable: true, get: function () { return screenshot_capture_session_2.ScreenshotCaptureSession; } });

package/dist/infrastructure/playwright-locator-screenshot-adapter/locator-patch.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright: (c) Myia SAS 2026.
+ * This file and its contents are licensed under the AGPLv3 License.
+ * Please see the LICENSE file at the root of this repository
+ */
+import type { Page } from 'playwright';
+import type { ScreenshotCaptureSession } from './screenshot-capture-session';
+export declare const HIGHLIGHTED_LOCATOR_ACTIONS: string[];
+export declare function setActiveCaptureSession(session: ScreenshotCaptureSession | null): void;
+export declare function getActiveCaptureSession(): ScreenshotCaptureSession | null;
+export declare function ensureLocatorPrototypePatched(samplePage: Page): void;

package/dist/infrastructure/playwright-locator-screenshot-adapter/locator-patch.js

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * Copyright: (c) Myia SAS 2026.
+ * This file and its contents are licensed under the AGPLv3 License.
+ * Please see the LICENSE file at the root of this repository
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HIGHLIGHTED_LOCATOR_ACTIONS = void 0;
+exports.setActiveCaptureSession = setActiveCaptureSession;
+exports.getActiveCaptureSession = getActiveCaptureSession;
+exports.ensureLocatorPrototypePatched = ensureLocatorPrototypePatched;
+const overlay_helpers_1 = require("./overlay-helpers");
+// Locator action methods that will be highlighted and screenshotted.
+// User-facing actions only — not queries, not waits, not assertions.
+// If Playwright adds new action methods, append them here.
+exports.HIGHLIGHTED_LOCATOR_ACTIONS = [
+    'click',
+    'dblclick',
+    'tap',
+    'fill',
+    'clear',
+    'hover',
+    'press',
+    'pressSequentially',
+    'type',
+    'check',
+    'uncheck',
+    'setChecked',
+    'focus',
+    'blur',
+    'selectOption',
+    'selectText',
+    'setInputFiles',
+    'dragTo',
+    'scrollIntoViewIfNeeded',
+];
+const PATCHED = Symbol.for('heal-playwright-tracer.locator-patched');
+// Active-session registry. The fixture sets this at test start and
+// clears it at teardown; the patched methods read it on every call.
+let activeSession = null;
+function setActiveCaptureSession(session) {
+    activeSession = session;
+}
+function getActiveCaptureSession() {
+    return activeSession;
+}
+// Idempotent proto patch. Call once per process with any Page-like
+// object that produces a Locator via `locator('body')` — we grab the
+// prototype from it and overwrite every action method.
+function ensureLocatorPrototypePatched(samplePage) {
+    const proto = Object.getPrototypeOf(samplePage.locator('body'));
+    if (!proto || proto[PATCHED])
+        return;
+    proto[PATCHED] = true;
+    for (const name of exports.HIGHLIGHTED_LOCATOR_ACTIONS) {
+        const orig = proto[name];
+        if (typeof orig !== 'function')
+            continue;
+        proto[name] = async function patched(...args) {
+            const self = this;
+            const pg = typeof self.page === 'function' ? self.page() : null;
+            const session = activeSession;
+            const drawnNodeId = pg && session ? await session.captureWithHighlight(pg, self, name) : null;
+            try {
+                return await orig.apply(self, args);
+            }
+            finally {
+                if (drawnNodeId && pg) {
+                    try {
+                        await (0, overlay_helpers_1.removeOverlay)(pg, drawnNodeId);
+                    }
+                    catch (_) {
+                        // Page closed / navigated / element detached — nothing to clean.
+                    }
+                }
+            }
+        };
+    }
+}

package/dist/infrastructure/playwright-locator-screenshot-adapter/overlay-helpers.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright: (c) Myia SAS 2026.
+ * This file and its contents are licensed under the AGPLv3 License.
+ * Please see the LICENSE file at the root of this repository
+ */
+import type { Page } from 'playwright';
+interface Box {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export declare function drawOverlay(page: Page, nodeId: string, box: Box): Promise<void>;
+export declare function removeOverlay(page: Page, nodeId: string): Promise<void>;
+export {};

package/dist/infrastructure/playwright-locator-screenshot-adapter/overlay-helpers.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * Copyright: (c) Myia SAS 2026.
+ * This file and its contents are licensed under the AGPLv3 License.
+ * Please see the LICENSE file at the root of this repository
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.drawOverlay = drawOverlay;
+exports.removeOverlay = removeOverlay;
+const DRAW_BORDER_SIZE = 4;
+const DRAW_COLOR = 'magenta';
+async function drawOverlay(page, nodeId, box) {
+    await page.evaluate((params) => {
+        const node = document.createElement('canvas');
+        node.id = params.nodeId;
+        node.style.pointerEvents = 'none';
+        node.style.position = 'absolute';
+        node.style.left = params.box.x + window.scrollX + 'px';
+        node.style.top = params.box.y + window.scrollY + 'px';
+        node.style.width = params.box.width + 'px';
+        node.style.height = params.box.height + 'px';
+        node.style.border = params.borderSize + 'px solid ' + params.color;
+        node.style.zIndex = '2147483647';
+        document.body.appendChild(node);
+    }, { nodeId, box, borderSize: DRAW_BORDER_SIZE, color: DRAW_COLOR });
+}
+async function removeOverlay(page, nodeId) {
+    await page.evaluate((id) => {
+        const el = document.getElementById(id);
+        if (el)
+            el.remove();
+    }, nodeId);
+}

package/dist/infrastructure/playwright-locator-screenshot-adapter/screenshot-capture-session.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright: (c) Myia SAS 2026.
+ * This file and its contents are licensed under the AGPLv3 License.
+ * Please see the LICENSE file at the root of this repository
+ */
+import type { Page } from 'playwright';
+interface Box {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface CapturableTarget {
+    boundingBox?: () => Promise<Box | null>;
+}
+export declare class ScreenshotCaptureSession {
+    private readonly outputDir;
+    private readonly onScreenshotWritten;
+    private seq;
+    private readonly cdpSessionCache;
+    constructor(outputDir: string, onScreenshotWritten: (filename: string) => void);
+    captureWithHighlight(page: Page, target: CapturableTarget, actionName: string): Promise<string | null>;
+    private takeScreenshot;
+    private getCDPSession;
+}
+export {};

package/dist/infrastructure/playwright-locator-screenshot-adapter/screenshot-capture-session.js

@@ -0,0 +1,125 @@
+"use strict";
+/**
+ * Copyright: (c) Myia SAS 2026.
+ * This file and its contents are licensed under the AGPLv3 License.
+ * Please see the LICENSE file at the root of this repository
+ */
+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.ScreenshotCaptureSession = void 0;
+// ScreenshotCaptureSession — one test's worth of locator-screenshot
+// capture: output directory, monotonic per-test sequence, CDP cache,
+// and the callback that stamps the filename onto the active
+// statement. The fixture creates one at test start and drops it at
+// test teardown (via `setActiveCaptureSession`).
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const overlay_helpers_1 = require("./overlay-helpers");
+class ScreenshotCaptureSession {
+    constructor(outputDir, onScreenshotWritten) {
+        this.outputDir = outputDir;
+        this.onScreenshotWritten = onScreenshotWritten;
+        this.seq = 0;
+        // Per-page CDP session cache. `page.screenshot()` in headed mode forces
+        // the configured viewport via `Emulation.setDeviceMetricsOverride`,
+        // which visibly resizes the OS window on every capture. Going through
+        // a raw CDP `Page.captureScreenshot` skips that override entirely. On
+        // Firefox/WebKit `newCDPSession` throws; we cache `null` so we stop
+        // retrying and fall back to `page.screenshot`.
+        this.cdpSessionCache = new WeakMap();
+    }
+    // Draw → screenshot → stamp. Returns the overlay node id if one is
+    // drawn (caller must call `removeOverlay` in finally), or null if
+    // nothing was drawn.
+    async captureWithHighlight(page, target, actionName) {
+        if (typeof target.boundingBox !== 'function')
+            return null;
+        let box;
+        try {
+            box = await target.boundingBox();
+        }
+        catch (_) {
+            return null;
+        }
+        if (!box)
+            return null;
+        const seq = ++this.seq;
+        const nodeId = `_heal_draw_area_tracer_${seq}`;
+        try {
+            await (0, overlay_helpers_1.drawOverlay)(page, nodeId, box);
+        }
+        catch (_) {
+            return null;
+        }
+        try {
+            const filename = `highlight-${seq}-${actionName}.png`;
+            const fullPath = path.join(this.outputDir, filename);
+            await this.takeScreenshot(page, fullPath);
+            this.onScreenshotWritten(filename);
+        }
+        catch (_) {
+            // Overlay is drawn; caller must still clean it up in its finally.
+        }
+        return nodeId;
+    }
+    async takeScreenshot(page, fullPath) {
+        const cdp = await this.getCDPSession(page);
+        if (cdp) {
+            const { data } = await cdp.send('Page.captureScreenshot', { format: 'png' });
+            await fs.promises.writeFile(fullPath, Buffer.from(data, 'base64'));
+            return;
+        }
+        await page.screenshot({ path: fullPath });
+    }
+    async getCDPSession(page) {
+        if (this.cdpSessionCache.has(page))
+            return this.cdpSessionCache.get(page) ?? null;
+        try {
+            const ctx = typeof page.context === 'function' ? page.context() : null;
+            if (!ctx || typeof ctx.newCDPSession !== 'function') {
+                this.cdpSessionCache.set(page, null);
+                return null;
+            }
+            const session = await ctx.newCDPSession(page);
+            this.cdpSessionCache.set(page, session);
+            return session;
+        }
+        catch (_) {
+            this.cdpSessionCache.set(page, null);
+            return null;
+        }
+    }
+}
+exports.ScreenshotCaptureSession = ScreenshotCaptureSession;

package/dist/infrastructure/playwright-step-tracking-adapter/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Copyright: (c) Myia SAS 2026.
+ * This file and its contents are licensed under the AGPLv3 License.
+ * Please see the LICENSE file at the root of this repository
+ */
+export { PlaywrightStepTrackingAdapter } from './playwright-step-tracking-adapter';
+export type { StepHooks } from './playwright-step-tracking-adapter';

package/dist/infrastructure/playwright-step-tracking-adapter/index.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * Copyright: (c) Myia SAS 2026.
+ * This file and its contents are licensed under the AGPLv3 License.
+ * Please see the LICENSE file at the root of this repository
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlaywrightStepTrackingAdapter = void 0;
+var playwright_step_tracking_adapter_1 = require("./playwright-step-tracking-adapter");
+Object.defineProperty(exports, "PlaywrightStepTrackingAdapter", { enumerable: true, get: function () { return playwright_step_tracking_adapter_1.PlaywrightStepTrackingAdapter; } });

package/dist/infrastructure/playwright-step-tracking-adapter/playwright-step-tracking-adapter.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Copyright: (c) Myia SAS 2026.
+ * This file and its contents are licensed under the AGPLv3 License.
+ * Please see the LICENSE file at the root of this repository
+ */
+export interface StepHooks {
+    pushStep(name: string): void;
+    popStep(): void;
+}
+export declare class PlaywrightStepTrackingAdapter {
+    private readonly hooks;
+    constructor(hooks: StepHooks);
+    patch(base: unknown): void;
+}

package/dist/infrastructure/playwright-step-tracking-adapter/playwright-step-tracking-adapter.js

@@ -0,0 +1,51 @@
+"use strict";
+/**
+ * Copyright: (c) Myia SAS 2026.
+ * This file and its contents are licensed under the AGPLv3 License.
+ * Please see the LICENSE file at the root of this repository
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlaywrightStepTrackingAdapter = void 0;
+// Feature: thread test.step titles onto the runtime step stack.
+//
+// `test.step("foo", async () => {...})` becomes:
+//   runtime.pushStep("foo");
+//   try { await body(); } finally { runtime.popStep(); }
+//
+// Every enter event emitted inside the body then carries `step: "foo"`
+// and `stepPath: [...]` so the resulting trace can be grouped by step.
+//
+// Idempotent — the patch runs once per process and guards against
+// double-wrapping via a Symbol marker placed on the patched target.
+//
+// The runtime hooks are passed in by the composition root (the
+// fixture) — this adapter is pure Playwright plumbing and must not
+// reach back into application or domain modules.
+const PATCHED = Symbol.for('heal-playwright-tracer.step-tracking.patched');
+class PlaywrightStepTrackingAdapter {
+    constructor(hooks) {
+        this.hooks = hooks;
+    }
+    patch(base) {
+        const target = base;
+        if (target[PATCHED])
+            return;
+        const origStep = target.step;
+        if (typeof origStep !== 'function')
+            return;
+        target[PATCHED] = true;
+        const hooks = this.hooks;
+        target.step = function patchedStep(title, body, opts) {
+            return origStep.call(this, title, async (...args) => {
+                hooks.pushStep(title);
+                try {
+                    return await body(...args);
+                }
+                finally {
+                    hooks.popStep();
+                }
+            }, opts);
+        };
+    }
+}
+exports.PlaywrightStepTrackingAdapter = PlaywrightStepTrackingAdapter;