@heal-dev/heal-playwright-tracer 1.0.0 → 1.0.8

package/README.md

@@ -4,7 +4,7 @@
   </a>
 </h1>
 <p align="center">
-  <p align="center">Statement-level execution tracing for Playwright tests, purpose-built for AI autopilots.</p>
+  <p align="center">Open-source statement-level Playwright tracer, purpose-built for AI agents.</p>
 </p>
 
 <h4 align="center">
@@ -17,20 +17,34 @@
   <a href="https://github.com/heal-dev/heal-playwright-tracer/actions/workflows/ci.yml"><img src="https://github.com/heal-dev/heal-playwright-tracer/actions/workflows/ci.yml/badge.svg?branch=main" alt="CI"></a>
   <a href="https://codecov.io/gh/heal-dev/heal-playwright-tracer"><img src="https://codecov.io/gh/heal-dev/heal-playwright-tracer/branch/main/graph/badge.svg" alt="codecov"></a>
   <a href="https://www.npmjs.com/package/@heal-dev/heal-playwright-tracer"><img src="https://img.shields.io/npm/v/@heal-dev/heal-playwright-tracer.svg" alt="npm version"></a>
-  <a href="https://www.npmjs.com/package/@heal-dev/heal-playwright-tracer"><img src="https://img.shields.io/node/v/@heal-dev/heal-playwright-tracer.svg" alt="node"></a>
-  <a href="https://www.npmjs.com/package/@playwright/test"><img src="https://img.shields.io/npm/dependency-version/@heal-dev/heal-playwright-tracer/peer/@playwright/test" alt="playwright"></a>
+  <a href="https://www.npmjs.com/package/@heal-dev/heal-playwright-tracer"><img src="https://img.shields.io/badge/node-%3E%3D18-brightgreen.svg" alt="node"></a>
+  <a href="https://www.npmjs.com/package/@playwright/test"><img src="https://img.shields.io/badge/%40playwright%2Ftest-%3E%3D1.50.0-blue.svg" alt="playwright"></a>
+  <a href="https://scorecard.dev/viewer/?uri=github.com/heal-dev/heal-playwright-tracer"><img src="https://api.scorecard.dev/projects/github.com/heal-dev/heal-playwright-tracer/badge" alt="OpenSSF Scorecard"></a>
 </h4>
 
 # @heal-dev/heal-playwright-tracer
 
-An AI-agent-first diagnostic layer for Playwright tests. Purpose-built
-to give an autopilot agent everything it needs to reason about _why_
-a test failed — statement-level execution traces with timing,
-variable values, call depth, serialized errors, highlighted locator
-screenshots, and Playwright API correlations — emitted as a
-structured NDJSON stream per test, alongside Playwright's own HTML
-report and trace viewer. Useful to humans too, but every design
-decision optimizes for what an LLM needs to see.
+heal-playwright-tracer is an agent-first diagnostic layer for your Playwright tests. It gives agents
+(and humans) everything they need to quickly analyze test results.
+
+👉 **Add this to your playwright config, run your tests, point Claude to the improved heal trace, get more accurate test diagnosis**
+
+## Why
+
+The playwright trace doesn't contain enough data for LLM-based agents such as Claude or Open Code to analyze tests results reliably.
+That's because the trace ifs focused on locator evaluation, while real-life tests also evaluate non-playwright code.
+Heal adds the missing instrumentation layer to let LLM agents work their magic.
+And it's useful for humans in complex test codebases, too!
+
+| Feature        | Playwright Trace      | Heal Tracer          | Example: What Heal Adds                                                                   |
+| -------------- | --------------------- | -------------------- | ----------------------------------------------------------------------------------------- |
+| Granularity    | Action-level          | Statement-level      | Shows `let x = calculate()` line-by-line, not just the final `page.click()`.              |
+| Data Format    | ZIP/Binary            | NDJSON Stream        | `{"type":"step","file":"auth.spec.ts","line":12,"val":{"user":"dev"}}`                    |
+| Visual Context | Standard screenshots  | Highlighted locators | An image where the target button is outlined in a neon overlay to prove hit-box accuracy. |
+| Variable State | Limited/Debugger only | Full Variable Values | Captures that `status_code` was `403` inside a hidden helper function.                    |
+| Error Detail   | Standard stack trace  | Serialized Errors    | A JSON object containing the DOM snapshot at the exact millisecond of the throw.          |
+| Timing         | Action durations      | Per-statement timing | Identifies that a specific `if` statement logic took `2.5s` to evaluate.                  |
+| Correlations   | Loose logs/network    | API Correlations     | Links `Trace_ID_99` directly to `Source_Line_45` in the NDJSON stream.                    |
 
 ## Install
 
@@ -38,7 +52,7 @@ decision optimizes for what an LLM needs to see.
 npm install -D @heal-dev/heal-playwright-tracer
 ```
 
-Wire the Babel plugin in `playwright.config.ts`.
+Wire the Babel plugin **and** the reporter in `playwright.config.ts`:
 
 ```ts
 // playwright.config.ts
@@ -54,11 +68,19 @@ export default defineConfig({
       ],
     ],
   },
+  reporter: [['@heal-dev/heal-playwright-tracer/reporter']],
 });
 ```
 
-Or, if you prefer to keep the config fully typed, declare the
-option once at the top of the file instead of using `@ts-ignore`:
+Both are required: if you wire the Babel plugin without the
+reporter, the fixture fails fast on the first test of every worker.
+For _why_ the reporter is mandatory (crash rescue, Playwright
+attachment copy, execution-history index), see
+[`docs/configuration.md`](docs/configuration.md#reporter).
+
+If you prefer to keep the config fully typed, declare the
+`babelPlugins` option once at the top of the file instead of using
+`@ts-ignore`:
 
 ```ts
 declare module '@playwright/test' {
@@ -71,38 +93,67 @@ declare module '@playwright/test' {
 ```
 
 Per-test output lands at
-`test-results/<test>/heal-data/heal-traces.ndjson`.
+`heal-traces/<executionId>/<playwrightTestId>/<attempt>/heal-traces.ndjson`.
+See [Output layout](#output-layout) below for the full tree.
 
-### Extend: custom exporters and lifecycles
+## Output layout
 
-`configureTracer` registers extra exporters (fanned out alongside
-the default NDJSON exporter) and per-test setup/teardown pairs —
-useful for shipping traces to your own backend or installing
-per-test globals:
+Every run produces a self-contained execution dir under:
+`heal-traces/<executionId>/<playwrightTestId>/<attempt>/heal-traces.ndjson`.
 
-```ts
-// playwright.config.ts
-import { defineConfig } from '@playwright/test';
-import { configureTracer } from '@heal-dev/heal-playwright-tracer';
-
-configureTracer({
-  exporters: [(ctx) => new MyHttpExporter(ctx.transport)],
-  lifecycles: [
-    () => ({
-      setup: (ctx) => openTelemetrySession(ctx.testInfo),
-      teardown: () => closeTelemetrySession(),
-    }),
-  ],
-});
+```
+<cwd>/heal-traces/
+├── executions.ndjson                                   # append-only run index
+└── <executionId>/                                      # auto-generated uuidv4 per run
+    ├── execution.json                                  # per-run manifest
+    └── <playwrightTestId>/                             # Playwright testInfo.testId
+        └── <attempt>/                                  # 1-indexed
+            ├── heal-traces.ndjson
+            ├── trace.zip                               # if Playwright recorded one
+            ├── screenshots/
+            │   └── stmt-0001.png
+            └── videos/
+                └── video.webm
+```
 
-export default defineConfig({
-  /* ... */
-});
+Keys are shaped `{executionId}/{testId}/{attempt}/...` so the layout
+maps cleanly onto any object-store key prefix if you ship traces
+elsewhere later.
+
+History is **append-only** — runs accumulate, nothing is pruned.
+Clean up manually with `rm -rf heal-traces/<id>/` when needed.
+
+> **Note:** add `heal-traces/` to your `.gitignore` — these are local
+> build artefacts and should never be committed.
+
+`<executionId>` is a uuidv4 the reporter generates at the start of
+each run; the trace viewer uses it to scope and group artefacts per
+run.
+
+## Usage
+
+1. After installing Heal, run your tests with the usual `npx playwright test` command.
+2. You should see `heal-traces.ndjson`.
+3. You can ask Claude or another agent to use those to understand your test results.
+
+### Viewing traces
+
+A small CLI ships alongside the tracer so humans can browse the
+captured traces in a local browser without setting up a Heal account:
+
+```sh
+npx heal-tracer view
 ```
 
-Full surface: [`src/application/heal-config/types.ts`](src/application/heal-config/types.ts).
-Exporters implement [`HealTraceExporter`](src/domain/trace-event-recorder/port/heal-trace-exporter.ts)
-(`write(record)` + `close()`).
+The CLI starts a local HTTP server on a free OS-assigned port,
+reads `<cwd>/heal-traces/`, lists every recorded execution in the
+header dropdown (newest first), and opens the latest one in your
+default browser. Switch executions from the dropdown to inspect
+history. Press Ctrl+C to stop.
+
+### Claude Skill
+
+See [this Claude skill](docs/SKILL.md) for a starter.
 
 ## Sample output
 
@@ -140,82 +191,9 @@ Statements that don't touch a locator (plain JS, utility calls,
 `page.goto`) have no `screenshot` field — capture is scoped to the
 Playwright surface where it adds diagnostic signal.
 
-## How it works
-
-```
-  Build time (per worker)                        Runtime (per test)
-  ───────────────────────                        ──────────────────
-
-  test file                                      instrumented test
-      │                                                 │
-      ▼                                                 ▼
-  ┌───────────────────┐                         ┌────────────────┐
-  │  Babel plugin     │  ─── instrumented ───►  │  recorder      │
-  │  code-hook-       │      (__enter /         │  enter/ok/     │
-  │  injector         │       __ok / __throw)   │  throw stream  │
-  └───────────────────┘                         └────────┬───────┘
-                                                         │
-                                                         ▼
-                                                 ┌────────────────┐
-                                                 │  statement     │
-                                                 │  projector     │
-                                                 └────────┬───────┘
-                                                          │
-                                                          ▼
-   playwright.config.ts                           ┌──────────────────┐
-   configureTracer({      ─── extends ──────────► │    composite     │
-     exporters,                                   │     exporter     │
-     lifecycles,                                  └───┬──────────┬───┘
-   })                                                 │          │
-                                                      ▼          ▼
-                                                   NDJSON     custom
-                                                    file     exporters
-                                                           (HTTP, queue, …)
-```
-
-The Babel plugin wraps every leaf statement with a try/catch/finally
-that calls three runtime hooks. The recorder pairs those calls into an
-event stream, the projector folds them into `HealTraceRecord`s, and
-a composite exporter fans them out to the default NDJSON file and
-any exporters registered via `configureTracer`.
-
-The plugin also rewrites `from '@playwright/test'` to
-`from '@heal-dev/heal-playwright-tracer'` in every instrumented file,
-so `test` and `expect` automatically resolve to the traced variants —
-no manual import swap required.
-
-## Why CommonJS?
-
-The package ships as CommonJS (no `"type": "module"` in
-`package.json`, `tsc` emits `module: commonjs`). This is deliberate:
-Playwright's babel transform — the thing that actually loads
-`code-hook-injector` — is itself a CJS module and consumes the plugin
-via `require()`. Shipping ESM would force a dual build with no upside.
-
-ESM consumers still work — use `createRequire` in
-`playwright.config.ts` if you need to resolve the plugin path:
-
-```ts
-// playwright.config.ts  (package.json has "type": "module")
-import { defineConfig } from '@playwright/test';
-import { createRequire } from 'node:module';
-
-const require = createRequire(import.meta.url);
-
-export default defineConfig({
-  // @ts-ignore
-  '@playwright/test': {
-    babelPlugins: [[require.resolve('@heal-dev/heal-playwright-tracer/code-hook-injector')]],
-  },
-});
-```
+## Architecture, and extending the tracer
 
-> **The module format of `playwright.config.ts` must match the
-> `"type"` field of its nearest `package.json`.** A mismatch causes
-> Node to route the file through the wrong loader, typically surfacing
-> as `ReferenceError: exports is not defined in ES module scope` —
-> with a stack trace that blames this plugin even though it has never
-> run. If that happens, fix the config format first.
+See [development.md](docs/development.md)
 
 ## Caveats
 
@@ -241,5 +219,5 @@ Scope the `include` filter in `playwright.config.ts` so only your
 
 Copyright © 2026 **MYIA SAS**.
 
-This project is licensed under the **GNU Affero General Public License v3.0 (AGPL-3.0)**.
+This project is licensed under the **GNU Affero General Public License v3.0 (AGPL-3.0)**, except for the `tracer-viewer-bundle` which is a vendored, free to use version of the Heal trace viewer.
 See the [LICENSE](LICENSE) file for the full text.

package/dist/application/babel-playwright-tracer-plugin/index.js

@@ -9,6 +9,7 @@ const cjs_artifact_detector_1 = require("../../domain/code-hook-injector/service
 const leaf_statement_classifier_1 = require("../../domain/code-hook-injector/service/statement-analysis/leaf-statement-classifier");
 const non_wrappable_statement_1 = require("../../domain/code-hook-injector/service/statement-analysis/non-wrappable-statement");
 const for_head_declaration_detector_1 = require("../../domain/code-hook-injector/service/statement-analysis/for-head-declaration-detector");
+const async_enclosing_function_detector_1 = require("../../domain/code-hook-injector/service/statement-analysis/async-enclosing-function-detector");
 const enclosing_scope_labeler_1 = require("../../domain/code-hook-injector/service/meta-fields/enclosing-scope-labeler");
 const source_snippet_extractor_1 = require("../../domain/code-hook-injector/service/meta-fields/source-snippet-extractor");
 const leading_comment_extractor_1 = require("../../domain/code-hook-injector/service/meta-fields/leading-comment-extractor");
@@ -18,6 +19,7 @@ const global_trace_call_1 = require("../../domain/code-hook-injector/service/tra
 const enter_meta_literal_1 = require("../../domain/code-hook-injector/service/trace-hook/enter-meta-literal");
 const try_finally_wrapper_1 = require("../../domain/code-hook-injector/service/trace-hook/try-finally-wrapper");
 const variable_declaration_hoister_1 = require("../../domain/code-hook-injector/service/trace-hook/variable-declaration-hoister");
+const preprocess_call_1 = require("../../domain/code-hook-injector/service/trace-hook/preprocess-call");
 const global_names_1 = require("../../domain/trace-event-recorder/model/global-names");
 function codeHookInjector(api, opts = {}) {
     const t = api.types;
@@ -28,6 +30,7 @@ function codeHookInjector(api, opts = {}) {
     const findScopeName = (0, enclosing_scope_labeler_1.createEnclosingScopeLabeler)(t);
     const isNonWrappableStatement = (0, non_wrappable_statement_1.createNonWrappableStatementPredicate)(t, isGeneratedModuleStatement);
     const isForHeadDeclaration = (0, for_head_declaration_detector_1.createForHeadDeclarationDetector)(t);
+    const isAsyncEnclosing = (0, async_enclosing_function_detector_1.createAsyncEnclosingFunctionDetector)(t);
     const rewritePlaywrightImports = (0, playwright_import_rewriter_1.createPlaywrightImportRewriter)(t);
     const callStmt = (0, global_trace_call_1.createGlobalTraceCallBuilder)(t);
     const buildMeta = (0, enter_meta_literal_1.createEnterMetaLiteralBuilder)(t, {
@@ -40,6 +43,7 @@ function codeHookInjector(api, opts = {}) {
     });
     const { buildTryFinally, buildThrewDecl } = (0, try_finally_wrapper_1.createTryFinallyWrapperBuilder)(t, callStmt);
     const hoistVariableDeclaration = (0, variable_declaration_hoister_1.createVariableDeclarationHoister)(t);
+    const buildPreprocessCall = (0, preprocess_call_1.createPreprocessCallBuilder)(t);
     return {
         name: 'heal-playwright-tracer',
         visitor: {
@@ -76,6 +80,16 @@ function codeHookInjector(api, opts = {}) {
                 // `applyTraceHookIfLeaf(stmtPath, state)` function in
                 // ./trace-hook/ and call it alongside the future families.
                 const meta = buildMeta(state, stmtPath, node, CWD);
+                // Optional pre-processor call inserted at the very start of
+                // the try body. Gated on the enclosing function being async
+                // because the call itself is `await __heal_preprocess?.(meta)`
+                // — a syntax error in sync functions. Sync statements skip
+                // the preprocess phase entirely and are still traced.
+                // `cloneNode(meta)` so the same literal isn't shared between
+                // the __heal_enter call and this one.
+                const preTryStmts = isAsyncEnclosing(stmtPath)
+                    ? [buildPreprocessCall(global_names_1.HEAL_PREPROCESS, t.cloneNode(meta))]
+                    : [];
                 if (t.isVariableDeclaration(node)) {
                     // `const x = EXPR` can't be wrapped as-is — the binding
                     // would be scoped to the try block and invisible downstream.
@@ -85,7 +99,7 @@ function codeHookInjector(api, opts = {}) {
                         return;
                     const { hoistDecl, assignments, varsObject, bindingNames } = hoistVariableDeclaration(node);
                     const okArgs = bindingNames.size ? [varsObject] : [];
-                    const { threwId, tryStmt } = buildTryFinally(stmtPath.scope, assignments, okArgs);
+                    const { threwId, tryStmt } = buildTryFinally(stmtPath.scope, [...preTryStmts, ...assignments], okArgs);
                     stmtPath.replaceWithMultiple([
                         callStmt(global_names_1.HEAL_ENTER, [meta]),
                         hoistDecl,
@@ -97,7 +111,7 @@ function codeHookInjector(api, opts = {}) {
                 // Every other leaf statement: wrap in a block with the
                 // original statement inside the try body.
                 node._traced = true;
-                const { threwId, tryStmt } = buildTryFinally(stmtPath.scope, [node]);
+                const { threwId, tryStmt } = buildTryFinally(stmtPath.scope, [...preTryStmts, node]);
                 const wrapper = t.blockStatement([
                     callStmt(global_names_1.HEAL_ENTER, [meta]),
                     buildThrewDecl(threwId),

package/dist/application/commander-cli-adapter/commander-cli-adapter.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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 CommanderCliAdapterOptions {
+    /** Override default `process.argv` parser. Used by tests. */
+    argv?: string[];
+    /** Bundle dir override. Defaults to the vendored assets dir. */
+    bundleDir?: string;
+    /** Logger. Defaults to console. */
+    log?: (msg: string) => void;
+    /** Override version string. Defaults to `package.json#version`. */
+    version?: string;
+}
+export declare class CommanderCliAdapter {
+    private readonly program;
+    private readonly options;
+    constructor(options?: CommanderCliAdapterOptions);
+    private initialize;
+    private log;
+    private handleView;
+    parse(argv?: string[]): Promise<void>;
+}

package/dist/application/commander-cli-adapter/commander-cli-adapter.js

@@ -0,0 +1,133 @@
+"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.CommanderCliAdapter = void 0;
+// Tiny Commander wrapper for the trace viewer. Mirrors the shape of
+// heal-cli's CommanderCliAdapter but with a single subcommand
+// (`view`). Lives in `src/application/...` to keep room for further
+// commands later (e.g. `prune`, `export`).
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+const commander_1 = require("commander");
+const local_viewer_server_1 = require("../../infrastructure/local-viewer-adapter/local-viewer-server");
+// Bind to port 0 — the OS picks a free ephemeral port. We then read
+// the actual port back from the listening server's AddressInfo and
+// use that for the printed URL and the browser-open. Avoids "port in
+// use" failures when several copies of `heal-tracer view` overlap or
+// when port 3000 is already taken by another dev server.
+const RANDOM_PORT = 0;
+const defaultBundleDir = () => 
+// Resolves to <package-root>/tracer-viewer-bundle. At runtime,
+// __dirname is `<package-root>/dist/application/commander-cli-adapter`
+// — both during local dev and when the package is installed under
+// `node_modules/@heal-dev/heal-playwright-tracer/`. Walking three
+// levels up lands at the package root, where the committed bundle
+// lives. In tests, the caller passes `bundleDir` explicitly.
+path.resolve(__dirname, '..', '..', '..', 'tracer-viewer-bundle');
+const openInBrowser = (url) => {
+    const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start ""' : 'xdg-open';
+    (0, node_child_process_1.exec)(`${cmd} ${JSON.stringify(url)}`);
+};
+class CommanderCliAdapter {
+    constructor(options = {}) {
+        this.options = options;
+        this.program = new commander_1.Command();
+        this.initialize();
+    }
+    initialize() {
+        this.program
+            .name('heal-tracer')
+            .description('Local viewer for heal-playwright-tracer artefacts')
+            .version(this.options.version ?? '0.0.0', '-v, --version', 'Show version')
+            .helpOption('-h, --help', 'Show this help');
+        this.program
+            .command('view')
+            .description('Serve the local trace viewer over an http server')
+            .action(async () => {
+            await this.handleView();
+        });
+    }
+    log(msg) {
+        (this.options.log ?? console.log.bind(console))(msg);
+    }
+    async handleView() {
+        const rootDir = process.cwd();
+        const bundleDir = this.options.bundleDir ?? defaultBundleDir();
+        if (!(0, node_fs_1.existsSync)(path.join(bundleDir, 'index.html'))) {
+            console.error(`[heal-tracer] viewer bundle not found at ${bundleDir}.\n` +
+                `Reinstall @heal-dev/heal-playwright-tracer.`);
+            process.exit(1);
+        }
+        const server = new local_viewer_server_1.LocalViewerServer({
+            rootDir,
+            bundleDir,
+            port: RANDOM_PORT,
+            log: (m) => this.log(m),
+        });
+        await server.start();
+        const port = server.boundPort();
+        if (port === null) {
+            console.error('[heal-tracer] server failed to bind a port');
+            process.exit(1);
+        }
+        const url = `http://localhost:${String(port)}`;
+        this.log(`✓ heal-tracer viewer running at ${url}`);
+        this.log(`  scanning: ${rootDir} (recursive)`);
+        openInBrowser(url);
+        this.log('Press Ctrl+C to stop.');
+        await new Promise((resolve) => {
+            const shutdown = () => {
+                this.log('\nStopping viewer…');
+                server
+                    .stop()
+                    .catch(() => undefined)
+                    .finally(() => resolve());
+            };
+            process.once('SIGINT', shutdown);
+            process.once('SIGTERM', shutdown);
+        });
+        process.exit(0);
+    }
+    async parse(argv) {
+        await this.program.parseAsync(argv ?? this.options.argv ?? process.argv);
+    }
+}
+exports.CommanderCliAdapter = CommanderCliAdapter;

package/dist/application/heal-config/index.d.ts

@@ -5,4 +5,4 @@
  */
 export { configureTracer, getTracerConfig, onTestTeardown } from './registry';
 export { resetTeardownHooks, drainTeardownHooks } from './registry';
-export type { HealTracerConfig, HealTracerTestContext, HealTraceExporterFactory, HealTestLifecycle, HealTestLifecycleFactory, } from './types';
+export type { HealTracerConfig, HealTracerTimeouts, HealTracerTestContext, HealTraceExporterFactory, HealTestLifecycle, HealTestLifecycleFactory, StatementPreProcessor, StatementPreProcessorContext, HealTracerNetworkConfig, HealTracerNetworkBodyMode, HealTracerConsoleConfig, } from './types';

package/dist/application/heal-config/registry.js

@@ -10,6 +10,7 @@ exports.getTracerConfig = getTracerConfig;
 exports.onTestTeardown = onTestTeardown;
 exports.resetTeardownHooks = resetTeardownHooks;
 exports.drainTeardownHooks = drainTeardownHooks;
+const logger_1 = require("../../util/logger");
 let currentConfig = {};
 let teardownHooks = [];
 /**
@@ -58,7 +59,7 @@ async function drainTeardownHooks() {
             await hook();
         }
         catch (err) {
-            console.error('[heal-playwright-tracer] teardown hook failed:', err);
+            logger_1.log.error('teardown hook failed', err);
         }
     }
 }