@heal-dev/heal-playwright-tracer 1.0.0

package/dist/application/playwright-fixture/index.js

@@ -0,0 +1,234 @@
+"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.reset = exports.expect = exports.test = void 0;
+// Composition root for the heal-playwright-tracer auto-fixture.
+//
+// Each feature owns its own setup/cleanup; this file is the shopping
+// list. Reading top-to-bottom tells you everything the tracer does to
+// a test and in what order.
+//
+// Built-in features wired here (always-on, OSS):
+//   - runtime (side-effect import installs globalThis.__heal_enter/__heal_ok/__heal_throw)
+//   - step-tracking       → new PlaywrightStepTrackingAdapter(hooks).patch(test)
+//   - test-context        → testContextAdapter.capture(testInfo)
+//   - locator-screenshots → startLocatorScreenshotCapture(page, outDir)
+//   - test-stdout-capture → new StdoutCaptureSession()
+//   - NDJSON exporter         → default trace output to `heal-data/heal-traces.ndjson`
+//
+// User-extensible features (wired via `configureTracer(...)` from the
+// host `playwright.config.ts`):
+//   - exporters       → each factory returns a `HealTraceExporter` composed
+//                   into a tee alongside the default NDJSON exporter
+//   - lifecycles  → each entry exposes `setup(ctx)` + `teardown()`;
+//                   setups run in declaration order at test start,
+//                   teardowns in reverse order in `finally` (LIFO)
+//   - onTestTeardown(fn) → runtime registration, drained before
+//                   lifecycle teardowns so SDKs still see any globals
+//                   a lifecycle installed
+//
+// Output shape (per test): `heal-data/heal-traces.ndjson` — one
+// HealTraceRecord per line. See
+// `../../domain/trace-event-recorder/model/statement-trace-schema.ts`
+// for the contract.
+//
+// Env toggles:
+//   HEAL_TRACE_NDJSON   default on; set to `0`/`false`/`off` to disable.
+//
+// Any backend integration (HTTP shipping, APM bindings,
+// telemetry-session setup, …) lives in user code and plugs in via
+// `configureTracer`. The fixture knows nothing about any specific
+// backend.
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const test_1 = require("@playwright/test");
+// Side-effect: installs `globalThis.__heal_enter/__heal_ok/__heal_throw`.
+const trace_event_recorder_runtime_1 = require("../trace-event-recorder-runtime");
+Object.defineProperty(exports, "reset", { enumerable: true, get: function () { return trace_event_recorder_runtime_1.reset; } });
+const playwright_locator_screenshot_adapter_1 = require("../../infrastructure/playwright-locator-screenshot-adapter");
+const projectors_1 = require("../../domain/trace-event-recorder/service/projectors");
+const ndjson_exporter_adapter_1 = require("../../infrastructure/ndjson-exporter-adapter");
+const service_1 = require("../../domain/trace-event-recorder/service");
+const playwright_step_tracking_adapter_1 = require("../../infrastructure/playwright-step-tracking-adapter");
+const playwright_test_context_adapter_1 = require("../../infrastructure/playwright-test-context-adapter");
+const playwright_locator_screenshot_adapter_2 = require("../../infrastructure/playwright-locator-screenshot-adapter");
+const stdout_capture_adapter_1 = require("../../infrastructure/stdout-capture-adapter");
+const heal_config_1 = require("../heal-config");
+// Wrap `expect` so any assertion made against a Locator gets a
+// highlight screenshot stamped onto the active statement, the same
+// way locator actions do. Non-locator assertions fall through.
+const expect = (0, playwright_locator_screenshot_adapter_1.wrapExpect)(test_1.expect);
+exports.expect = expect;
+// All artifacts this package produces live under this subdirectory of
+// `testInfo.outputDir`, so they stay segregated from Playwright's own
+// output (screenshot/trace/video attachments).
+const HEAL_DATA_SUBDIR = 'heal-data';
+const NDJSON_FILENAME = 'heal-traces.ndjson';
+function envFlag(name, defaultOn) {
+    const raw = process.env[name];
+    if (raw == null || raw === '')
+        return defaultOn;
+    const v = raw.toLowerCase();
+    if (v === '0' || v === 'false' || v === 'off' || v === 'no')
+        return false;
+    return true;
+}
+function buildHealTraceExporter(healDataDir, ctx) {
+    const legs = [];
+    if (envFlag('HEAL_TRACE_NDJSON', true)) {
+        legs.push(new ndjson_exporter_adapter_1.NdjsonExporter(path.join(healDataDir, NDJSON_FILENAME)));
+    }
+    const { exporters = [] } = (0, heal_config_1.getTracerConfig)();
+    for (const factory of exporters) {
+        try {
+            legs.push(factory(ctx));
+        }
+        catch (err) {
+            console.error('[heal-playwright-tracer] exporter factory failed:', err);
+        }
+    }
+    if (legs.length === 0) {
+        // Neither leg active — return a no-op exporter so the projector
+        // still runs without doing anything user-visible.
+        return { write() { }, async close() { } };
+    }
+    return legs.length === 1 ? legs[0] : new service_1.CompositeHealTraceExporter(legs);
+}
+// Composition-root singletons — one per process.
+const testContextAdapter = new playwright_test_context_adapter_1.PlaywrightTestContextAdapter({ setContext: trace_event_recorder_runtime_1.setContext });
+const stepTrackingAdapter = new playwright_step_tracking_adapter_1.PlaywrightStepTrackingAdapter({ pushStep: trace_event_recorder_runtime_1.pushStep, popStep: trace_event_recorder_runtime_1.popStep });
+exports.test = test_1.test.extend({
+    _traceAuto: [
+        async ({ page }, use, testInfo) => {
+            const captured = testContextAdapter.capture(testInfo);
+            const healDataDir = path.join(testInfo.outputDir, HEAL_DATA_SUBDIR);
+            fs.mkdirSync(healDataDir, { recursive: true });
+            const tracerCtx = {
+                testInfo,
+                healDataDir,
+                transport: {
+                    testId: captured.testId,
+                    attempt: captured.attempt,
+                    rootDir: testInfo.outputDir,
+                },
+            };
+            // Fresh output pipeline per test: build a HealTraceExporter (default
+            // NDJSON leg + any user-configured exporters), wrap it in a
+            // projector, install on the recorder, then reset() — which
+            // clears projector state and emits the test-header record via
+            // the buildMetaEvent call inside the recorder.
+            const output = buildHealTraceExporter(healDataDir, tracerCtx);
+            const projector = new projectors_1.StatementProjector(output);
+            (0, trace_event_recorder_runtime_1.setExporter)(projector);
+            (0, trace_event_recorder_runtime_1.reset)();
+            // Defensive: clear any teardown hooks that leaked from a
+            // previous test that crashed before drain ran.
+            (0, heal_config_1.resetTeardownHooks)();
+            const stopScreenshots = (0, playwright_locator_screenshot_adapter_2.startLocatorScreenshotCapture)(page, healDataDir, trace_event_recorder_runtime_1.setCurrentStatementScreenshot);
+            const stdoutSession = new stdout_capture_adapter_1.StdoutCaptureSession();
+            // Instantiate user-configured lifecycles for this test. Each
+            // factory runs fresh per test so any closure state the factory
+            // declares is isolated between tests. Setup failures are
+            // isolated: a lifecycle whose `setup` throws is NOT pushed onto
+            // `activeLifecycles`, so its `teardown` will not run. Later
+            // lifecycles still get a chance to set up.
+            const activeLifecycles = [];
+            const { lifecycles = [] } = (0, heal_config_1.getTracerConfig)();
+            for (const factory of lifecycles) {
+                try {
+                    const lc = factory();
+                    await lc.setup(tracerCtx);
+                    activeLifecycles.push(lc);
+                }
+                catch (err) {
+                    console.error('[heal-playwright-tracer] lifecycle setup failed:', err);
+                }
+            }
+            try {
+                await use();
+            }
+            finally {
+                // Run any teardown hooks registered during the test. Runs
+                // BEFORE lifecycle teardowns so hooks that log via an SDK
+                // still see the per-test globals a lifecycle installed, and
+                // BEFORE stopping stdout capture so SDK teardown output lands
+                // in the ndjson's `test-result.stdout/stderr`.
+                await (0, heal_config_1.drainTeardownHooks)();
+                // Teardown in reverse order (LIFO): the last lifecycle to set
+                // up is the first to tear down, matching the mental model of
+                // nested `using` blocks.
+                for (let i = activeLifecycles.length - 1; i >= 0; i--) {
+                    try {
+                        await activeLifecycles[i].teardown();
+                    }
+                    catch (err) {
+                        console.error('[heal-playwright-tracer] lifecycle teardown failed:', err);
+                    }
+                }
+                const capturedStdout = stdoutSession.stop();
+                stopScreenshots();
+                // Emit the final test-result record and close the output
+                // exporter chain (flushes NDJSON fd, awaits in-flight
+                // user-exporter I/O). The projector has its own `finalized`
+                // guard that silently swallows any stray events fired after
+                // this point, so we do NOT swap the recorder's exporter back
+                // to a no-op — it stays pointed at the (now-finalized)
+                // projector until the next test installs a fresh one.
+                //
+                // Playwright-native artifacts (trace.zip, videos) are NOT
+                // shipped from here — their attachments are populated by
+                // Playwright in a later phase. Users who need them can
+                // register a Playwright reporter in their `playwright.config`.
+                await projector.finalize({
+                    status: testInfo.status ?? 'passed',
+                    duration: testInfo.duration,
+                    stdout: capturedStdout.stdout.length ? capturedStdout.stdout : undefined,
+                    stderr: capturedStdout.stderr.length ? capturedStdout.stderr : undefined,
+                });
+            }
+        },
+        { auto: true },
+    ],
+});
+// Thread test.step titles onto the runtime step stack. Must run AFTER
+// base.extend because Playwright's extend creates a fresh `.step` on
+// the new test object that doesn't inherit from base — patching `base`
+// first would never reach the extended test.
+stepTrackingAdapter.patch(exports.test);

package/dist/application/trace-event-recorder-runtime/index.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 { SCHEMA_VERSION } from '../../domain/trace-event-recorder/service';
+import type { TraceEventConsumer } from '../../domain/trace-event-recorder/port/trace-event-consumer';
+export declare const reset: () => void;
+export declare const setContext: (ctx: Record<string, unknown> | null) => void;
+export declare const setPage: (page: unknown | null) => void;
+export declare const pushStep: (name: string) => void;
+export declare const popStep: () => void;
+export declare const setCurrentStatementScreenshot: (filename: string) => void;
+export declare const setExporter: (newExporter: TraceEventConsumer) => void;
+export { SCHEMA_VERSION };

package/dist/application/trace-event-recorder-runtime/index.js

@@ -0,0 +1,68 @@
+"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.SCHEMA_VERSION = exports.setExporter = exports.setCurrentStatementScreenshot = exports.popStep = exports.pushStep = exports.setPage = exports.setContext = exports.reset = void 0;
+// Composition root for the process-wide trace-event-recorder singleton.
+//
+// `domain/.../factory.ts` exports the `TraceEventRecorder` class —
+// a pure service that requires exporter + clock + staticContext. This
+// file is the thin wrapper that:
+//
+//   1. Wires the default Clock (PerfHooksClock) and the default
+//      SystemInfoProvider (SystemInfoAdapter — reads pid/os/git).
+//   2. Builds one trace-event-recorder wired to `BOOTSTRAP_EXPORTER`
+//      (a no-op that silently swallows any events fired before the
+//      fixture swaps in a real projector via `setExporter(...)` at
+//      the start of every test).
+//   3. Installs `globalThis.__heal_enter/__heal_ok/__heal_throw` so the
+//      Babel-inserted calls find them at runtime.
+//   4. Re-exports the public API (`reset`, `setContext`, `setPage`,
+//      `pushStep`, `popStep`, `setCurrentStatementScreenshot`,
+//      `setExporter`) for the fixture and infrastructure adapters to
+//      import. The singleton shape is the integration surface between
+//      the always-on domain recorder and the per-test fixture.
+//
+// Tests do NOT import this file — they import the domain factory
+// directly and inject stubs + a fake clock.
+const service_1 = require("../../domain/trace-event-recorder/service");
+Object.defineProperty(exports, "SCHEMA_VERSION", { enumerable: true, get: function () { return service_1.SCHEMA_VERSION; } });
+const perf_hooks_clock_adapter_1 = require("../../infrastructure/perf-hooks-clock-adapter");
+const system_info_adapter_1 = require("../../infrastructure/system-info-adapter");
+const global_names_1 = require("../../domain/trace-event-recorder/model/global-names");
+// See the header comment: the recorder is constructed at module load
+// and MUST have an exporter from that moment so any pre-fixture
+// `__heal_enter` call doesn't crash. The fixture replaces this with
+// the real per-test projector via `setExporter(...)`.
+const BOOTSTRAP_EXPORTER = {
+    write() { },
+    clear() { },
+};
+const systemInfo = new system_info_adapter_1.SystemInfoAdapter().getStaticContext();
+const staticContext = {
+    schemaVersion: service_1.SCHEMA_VERSION,
+    ...systemInfo,
+};
+const traceEventRecorder = new service_1.TraceEventRecorder({
+    exporter: BOOTSTRAP_EXPORTER,
+    clock: new perf_hooks_clock_adapter_1.PerfHooksClock(),
+    staticContext,
+});
+// Global-name contract lives in `domain/.../model/global-names.ts`,
+// shared with the Babel plugin that emits calls to these names. The
+// factory's internal method names (`__enter`, `__ok`, `__throw`) are
+// unchanged — they never leak into user-facing code.
+const g = globalThis;
+g[global_names_1.HEAL_ENTER] = traceEventRecorder.__enter;
+g[global_names_1.HEAL_OK] = traceEventRecorder.__ok;
+g[global_names_1.HEAL_THROW] = traceEventRecorder.__throw;
+exports.reset = traceEventRecorder.reset;
+exports.setContext = traceEventRecorder.setContext;
+exports.setPage = traceEventRecorder.setPage;
+exports.pushStep = traceEventRecorder.pushStep;
+exports.popStep = traceEventRecorder.popStep;
+exports.setCurrentStatementScreenshot = traceEventRecorder.setCurrentStatementScreenshot;
+exports.setExporter = traceEventRecorder.setExporter;

package/dist/domain/code-hook-injector/service/meta-fields/enclosing-scope-labeler.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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 * as BabelTypes from '@babel/types';
+import type { NodePath } from '@babel/traverse';
+type Types = typeof BabelTypes;
+export declare const TEST_API_NAMES: RegExp;
+export type EnclosingScopeLabeler = (nodePath: NodePath) => string;
+export declare function createEnclosingScopeLabeler(t: Types): EnclosingScopeLabeler;
+export {};

package/dist/domain/code-hook-injector/service/meta-fields/enclosing-scope-labeler.js

@@ -0,0 +1,53 @@
+"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.TEST_API_NAMES = void 0;
+exports.createEnclosingScopeLabeler = createEnclosingScopeLabeler;
+exports.TEST_API_NAMES = /^(test|it|describe|step|beforeEach|afterEach|beforeAll|afterAll)$/;
+function createEnclosingScopeLabeler(t) {
+    return function labelEnclosingScope(nodePath) {
+        let p = nodePath.parentPath;
+        while (p) {
+            if (p.isFunction()) {
+                // ObjectMethod and ClassMethod ARE function nodes (not wrapped
+                // by one), so we check them on the current path itself, not on
+                // its parent. Must come BEFORE the named-function branch since
+                // those methods can also have a `.key` we want to surface.
+                if (p.isObjectMethod() || p.isClassMethod()) {
+                    const key = p.node.key;
+                    if (key && t.isIdentifier(key))
+                        return key.name;
+                }
+                const fnNode = p.node;
+                if ('id' in fnNode && fnNode.id && fnNode.id.name)
+                    return fnNode.id.name;
+                const parent = p.parentPath;
+                if (parent && parent.isCallExpression()) {
+                    const callee = parent.node.callee;
+                    let calleeName = '';
+                    if (t.isIdentifier(callee))
+                        calleeName = callee.name;
+                    else if (t.isMemberExpression(callee) && t.isIdentifier(callee.property))
+                        calleeName = callee.property.name;
+                    if (exports.TEST_API_NAMES.test(calleeName)) {
+                        const titleNode = parent.node.arguments[0];
+                        if (titleNode && t.isStringLiteral(titleNode)) {
+                            return `${calleeName}: ${titleNode.value}`;
+                        }
+                        return `${calleeName}()`;
+                    }
+                }
+                if (parent && parent.isVariableDeclarator() && t.isIdentifier(parent.node.id)) {
+                    return parent.node.id.name;
+                }
+                return '<anonymous>';
+            }
+            p = p.parentPath;
+        }
+        return '<module>';
+    };
+}

package/dist/domain/code-hook-injector/service/meta-fields/leading-comment-extractor.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
+ */
+interface BabelComment {
+    type: 'CommentLine' | 'CommentBlock';
+    value: string;
+}
+interface NodeLike {
+    leadingComments?: BabelComment[] | null;
+}
+export declare function extractLeadingComment(node: NodeLike | null | undefined): string | null;
+export {};

package/dist/domain/code-hook-injector/service/meta-fields/leading-comment-extractor.js

@@ -0,0 +1,20 @@
+"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.extractLeadingComment = extractLeadingComment;
+function extractLeadingComment(node) {
+    const comments = node?.leadingComments;
+    if (!comments || comments.length === 0)
+        return null;
+    return comments.map((c) => stripOneSpace(c.value)).join('\n');
+}
+// Strip at most one leading and one trailing space. Not `.trim()` —
+// that would destroy intentional indentation in JSDoc-style blocks
+// where inner lines are `' * foo'`.
+function stripOneSpace(value) {
+    return value.replace(/^ /, '').replace(/ $/, '');
+}

package/dist/domain/code-hook-injector/service/meta-fields/relative-file-path.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 relFile(cwd: string, absFile: string | undefined | null): string;

package/dist/domain/code-hook-injector/service/meta-fields/relative-file-path.js

@@ -0,0 +1,57 @@
+"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.relFile = relFile;
+// Computes the `meta.file` field: a repo-relative path when the
+// absolute filename lives under the instrumenter's `rootDir` (or
+// process.cwd() by default), or the absolute path otherwise.
+//
+// Relative paths make traces portable across machines; falling back
+// to absolute when the file is outside the root avoids generating
+// broken `..`-prefixed paths that can't be resolved on the consumer
+// side. Missing filenames collapse to `<anonymous>` so downstream
+// code never has to null-check.
+const path = __importStar(require("path"));
+function relFile(cwd, absFile) {
+    if (!absFile)
+        return '<anonymous>';
+    const rel = path.relative(cwd, absFile);
+    return rel && !rel.startsWith('..') ? rel : absFile;
+}

package/dist/domain/code-hook-injector/service/meta-fields/source-snippet-extractor.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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 const DEFAULT_MAX_SOURCE_LEN = 200;
+interface NodeLike {
+    start?: number | null;
+    end?: number | null;
+}
+export declare function extractSource(code: string | undefined | null, node: NodeLike | null | undefined, maxLen?: number): string;
+export {};

package/dist/domain/code-hook-injector/service/meta-fields/source-snippet-extractor.js

@@ -0,0 +1,28 @@
+"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.DEFAULT_MAX_SOURCE_LEN = void 0;
+exports.extractSource = extractSource;
+// Extracts the raw source text for a node, collapsed and length-capped.
+//
+// Produces the `meta.source` field on every __enter event. Slicing
+// the original file between `node.start` and `node.end` is cheap and
+// avoids re-printing the AST; collapsing whitespace keeps multi-line
+// statements readable on a single trace line; the 200-char cap keeps
+// long expressions from blowing up the trace buffer.
+exports.DEFAULT_MAX_SOURCE_LEN = 200;
+function extractSource(code, node, maxLen = exports.DEFAULT_MAX_SOURCE_LEN) {
+    const src = code || '';
+    if (!node || node.start == null || node.end == null)
+        return '';
+    let snippet = src.slice(node.start, node.end);
+    snippet = snippet.replace(/\s+/g, ' ').trim();
+    if (snippet.length > maxLen) {
+        snippet = snippet.slice(0, maxLen - 1) + '…';
+    }
+    return snippet;
+}

package/dist/domain/code-hook-injector/service/playwright-import-rewriter.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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 * as BabelTypes from '@babel/types';
+type Types = typeof BabelTypes;
+export type PlaywrightImportRewriter = (program: BabelTypes.Program) => void;
+export declare function createPlaywrightImportRewriter(t: Types): PlaywrightImportRewriter;
+export {};

package/dist/domain/code-hook-injector/service/playwright-import-rewriter.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.createPlaywrightImportRewriter = createPlaywrightImportRewriter;
+const PLAYWRIGHT_IMPORT_SOURCE = '@playwright/test';
+const REPLACEMENT_SOURCE = '@heal-dev/heal-playwright-tracer';
+function createPlaywrightImportRewriter(t) {
+    return function rewritePlaywrightImports(program) {
+        for (const node of program.body) {
+            if (t.isImportDeclaration(node) &&
+                node.source &&
+                node.source.value === PLAYWRIGHT_IMPORT_SOURCE) {
+                node.source = t.stringLiteral(REPLACEMENT_SOURCE);
+            }
+        }
+    };
+}

package/dist/domain/code-hook-injector/service/statement-analysis/cjs-artifact-detector.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
+ */
+import type * as BabelTypes from '@babel/types';
+type Types = typeof BabelTypes;
+type Node = BabelTypes.Node;
+export interface CjsArtifactDetector {
+    isRequireLike: (node: Node | null | undefined) => boolean;
+    isGeneratedModuleStatement: (node: Node) => boolean;
+}
+export declare function createCjsArtifactDetector(t: Types): CjsArtifactDetector;
+export {};

package/dist/domain/code-hook-injector/service/statement-analysis/cjs-artifact-detector.js

@@ -0,0 +1,30 @@
+"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.createCjsArtifactDetector = createCjsArtifactDetector;
+function createCjsArtifactDetector(t) {
+    const isRequireLike = (node) => {
+        if (!node || !t.isCallExpression(node))
+            return false;
+        const callee = node.callee;
+        if (!t.isIdentifier(callee))
+            return false;
+        if (callee.name === 'require')
+            return true;
+        if (/^_interop/.test(callee.name) && node.arguments.length > 0) {
+            return isRequireLike(node.arguments[0]);
+        }
+        return false;
+    };
+    const isGeneratedModuleStatement = (node) => {
+        if (t.isVariableDeclaration(node)) {
+            return node.declarations.every((d) => isRequireLike(d.init));
+        }
+        return false;
+    };
+    return { isRequireLike, isGeneratedModuleStatement };
+}

package/dist/domain/code-hook-injector/service/statement-analysis/for-head-declaration-detector.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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 * as BabelTypes from '@babel/types';
+type Types = typeof BabelTypes;
+export type ForHeadDeclarationDetector = (declaration: BabelTypes.VariableDeclaration, parent: BabelTypes.Node) => boolean;
+export declare function createForHeadDeclarationDetector(t: Types): ForHeadDeclarationDetector;
+export {};

package/dist/domain/code-hook-injector/service/statement-analysis/for-head-declaration-detector.js

@@ -0,0 +1,18 @@
+"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.createForHeadDeclarationDetector = createForHeadDeclarationDetector;
+function createForHeadDeclarationDetector(t) {
+    return function isForHeadDeclaration(declaration, parent) {
+        if (t.isForStatement(parent) && parent.init === declaration)
+            return true;
+        if ((t.isForInStatement(parent) || t.isForOfStatement(parent)) && parent.left === declaration) {
+            return true;
+        }
+        return false;
+    };
+}