@heal-dev/heal-playwright-tracer 1.0.0

package/dist/domain/trace-event-recorder/service/projectors/statement-projector.js

@@ -0,0 +1,183 @@
+"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.StatementProjector = void 0;
+const statement_trace_schema_1 = require("../../model/statement-trace-schema");
+class StatementProjector {
+    constructor(output) {
+        this.output = output;
+        // Every live statement, keyed by its enter-event seq. Used for
+        // parent lookup on nested enters and for ok/throw stamping.
+        this.allBySeq = new Map();
+        // Subset: statements whose runtime parent was null. These are
+        // the only ones that become their own NDJSON record.
+        this.rootsBySeq = new Map();
+        this.headerEmitted = false;
+        this.finalized = false;
+    }
+    write(event) {
+        if (this.finalized)
+            return;
+        switch (event.type) {
+            case 'meta': {
+                if (!this.headerEmitted) {
+                    this.output.write({
+                        kind: 'test-header',
+                        schemaVersion: statement_trace_schema_1.HEAL_TRACE_SCHEMA_VERSION,
+                        test: buildTestHeader(event),
+                    });
+                    this.headerEmitted = true;
+                }
+                return;
+            }
+            case 'enter': {
+                const live = { stmt: createStatement(event), enter: event };
+                this.allBySeq.set(event.seq, live);
+                if (event.parentSeq == null) {
+                    this.rootsBySeq.set(event.seq, live);
+                }
+                else {
+                    const parent = this.allBySeq.get(event.parentSeq);
+                    if (parent)
+                        parent.stmt.children.push(live.stmt);
+                    // Orphaned (parent was never seen) — promote to root so
+                    // the statement is not lost.
+                    else
+                        this.rootsBySeq.set(event.seq, live);
+                }
+                return;
+            }
+            case 'ok': {
+                const live = this.allBySeq.get(event.enterSeq);
+                if (!live)
+                    return;
+                live.stmt.duration = event.duration;
+                if (event.vars)
+                    live.stmt.vars = event.vars;
+                // Screenshot may have been stamped onto the enter event
+                // after the enter was emitted (locator-screenshots
+                // feature); pick it up now.
+                if (live.enter.screenshot)
+                    live.stmt.screenshot = live.enter.screenshot;
+                this.maybeEmitRoot(event.enterSeq, live);
+                return;
+            }
+            case 'throw': {
+                if (event.enterSeq == null)
+                    return;
+                const live = this.allBySeq.get(event.enterSeq);
+                if (!live)
+                    return;
+                live.stmt.status = 'threw';
+                live.stmt.duration = event.duration;
+                live.stmt.error = event.error;
+                if (live.enter.screenshot)
+                    live.stmt.screenshot = live.enter.screenshot;
+                this.maybeEmitRoot(event.enterSeq, live);
+                return;
+            }
+            default:
+                return;
+        }
+    }
+    // Called by `reset()` at the start of every test. Drops all
+    // in-progress statement state so the next test begins with a
+    // blank slate. Does NOT close the inner exporter — the fixture
+    // owns that lifecycle.
+    clear() {
+        this.allBySeq.clear();
+        this.rootsBySeq.clear();
+        this.headerEmitted = false;
+    }
+    /**
+     * Emit the final `test-result` record and close the underlying
+     * exporter. Called once at test teardown; the projector is unusable
+     * afterwards.
+     */
+    async finalize(result) {
+        if (this.finalized)
+            return;
+        this.finalized = true;
+        this.output.write({ kind: 'test-result', ...result });
+        await this.output.close();
+    }
+    maybeEmitRoot(seq, live) {
+        if (!this.rootsBySeq.has(seq))
+            return;
+        sortChildrenDeep(live.stmt);
+        this.output.write({ kind: 'statement', statement: live.stmt });
+        // Drop the subtree from the working maps — memory bound is
+        // now the maximum in-flight depth rather than the whole test.
+        this.dropSubtree(live.stmt);
+        this.rootsBySeq.delete(seq);
+    }
+    dropSubtree(stmt) {
+        this.allBySeq.delete(stmt.seq);
+        for (const child of stmt.children)
+            this.dropSubtree(child);
+    }
+}
+exports.StatementProjector = StatementProjector;
+function createStatement(event) {
+    const stmt = {
+        seq: event.seq,
+        file: event.file,
+        line: event.startLine,
+        endLine: event.endLine,
+        kind: event.kind,
+        scope: event.scope,
+        source: event.source,
+        hasAwait: event.hasAwait,
+        step: event.step,
+        stepPath: event.stepPath,
+        status: 'ok',
+        duration: 0,
+        t: event.t,
+        pageUrl: event.pageUrl,
+        children: [],
+    };
+    if (event.screenshot)
+        stmt.screenshot = event.screenshot;
+    if (event.leadingComment != null)
+        stmt.leadingComment = event.leadingComment;
+    return stmt;
+}
+function sortChildrenDeep(stmt) {
+    if (stmt.children.length === 0)
+        return;
+    stmt.children.sort((a, b) => a.seq - b.seq);
+    for (const child of stmt.children)
+        sortChildrenDeep(child);
+}
+function buildTestHeader(meta) {
+    const env = {
+        nodeVersion: meta.nodeVersion,
+        platform: meta.platform,
+        arch: meta.arch,
+        hostname: meta.hostname,
+        isCI: meta.isCI,
+        cwd: meta.cwd,
+        gitSha: meta.gitSha,
+        pid: meta.pid,
+    };
+    const context = {
+        testId: meta.testId ?? '',
+        attempt: meta.attempt ?? 1,
+        ...(meta.testCaseId !== undefined ? { testCaseId: meta.testCaseId } : {}),
+    };
+    return {
+        title: meta.testTitle ?? '',
+        titlePath: meta.titlePath ?? [],
+        file: meta.testFile ?? '',
+        project: meta.projectName ?? '',
+        workerIndex: meta.workerIndex ?? 0,
+        retry: meta.retry ?? 0,
+        startedAt: meta.wallTime ?? 0,
+        env,
+        context,
+    };
+}

package/dist/domain/trace-event-recorder/service/serializers/error-serializer.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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 { SerializedError } from '../../model/serialized-error';
+export type { SerializedError };
+export declare function serializeError(err: unknown): SerializedError;

package/dist/domain/trace-event-recorder/service/serializers/error-serializer.js

@@ -0,0 +1,49 @@
+"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.serializeError = serializeError;
+const PLAYWRIGHT_ERROR_CTOR = /^(TimeoutError|PlaywrightError|LocatorError|PlaywrightTestError)$/;
+const PLAYWRIGHT_STACK = /(node_modules\/playwright|node_modules\/@playwright)/;
+function serializeError(err) {
+    if (err == null)
+        return { message: String(err) };
+    if (typeof err !== 'object')
+        return { message: String(err) };
+    const e = err;
+    const ctorName = (e.constructor && e.constructor.name) || '';
+    const stackStr = e.stack ? String(e.stack).split('\n').slice(0, 20).join('\n') : undefined;
+    const result = {
+        name: e.name || ctorName || 'Error',
+        message: e.message != null ? String(e.message) : String(err),
+    };
+    if (stackStr)
+        result.stack = stackStr;
+    result.isPlaywrightError =
+        PLAYWRIGHT_ERROR_CTOR.test(ctorName) || PLAYWRIGHT_STACK.test(stackStr || '');
+    const causes = [];
+    let cur = e.cause;
+    let d = 0;
+    while (cur != null && d < 5) {
+        if (typeof cur === 'object') {
+            const c = cur;
+            causes.push({
+                name: c.name || (c.constructor && c.constructor.name) || 'Error',
+                message: c.message != null ? String(c.message) : String(cur),
+                stack: c.stack ? String(c.stack).split('\n').slice(0, 10).join('\n') : undefined,
+            });
+            cur = c.cause;
+        }
+        else {
+            causes.push({ message: String(cur) });
+            break;
+        }
+        d++;
+    }
+    if (causes.length)
+        result.causes = causes;
+    return result;
+}

package/dist/domain/trace-event-recorder/service/serializers/variable-snapshot-serializer.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 declare function safeValue(v: unknown, depth?: number): unknown;
+export declare function safeVars(vars: unknown): Record<string, unknown> | undefined;

package/dist/domain/trace-event-recorder/service/serializers/variable-snapshot-serializer.js

@@ -0,0 +1,102 @@
+"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.safeValue = safeValue;
+exports.safeVars = safeVars;
+// Turns a `{ name: value }` map of user variables into a trace-safe
+// snapshot that the ok-event-builder attaches to the `meta.vars`
+// field. Called from `__ok` with the bindings the Babel
+// instrumenter passed to it (only for `VariableDeclaration`
+// statements — `const x = compute()` sends `{ x }`).
+//
+// "Trace-safe" means:
+//
+//   - **Size-capped**. Strings are truncated at 200 chars, arrays
+//     keep the first 10 elements, objects keep the first 10 keys.
+//     The trace buffer has to serialize to JSON at teardown and get
+//     attached to a Playwright report; shipping a 50 MB mega-object
+//     would break both.
+//   - **Depth-capped**. Walks stop at depth 2 and replace deeper
+//     values with a `[Ctor]` placeholder.
+//   - **Plain-object only**. Only object literals (`{}` / `Object.create(null)`)
+//     and arrays are walked. Any class instance — Playwright's `Page`, an SDK
+//     adapter holding an API key, a `Date`, a `URL`, the user's domain
+//     types — short-circuits to a `[Ctor]` placeholder. This is the
+//     default-safe rule: walking a class instance can dump private state
+//     (e.g. `apiKey`, auth headers) into the trace, which then ships to the
+//     report. Plain JSON-shaped data — `await response.json()`, config
+//     objects, user records — is what tests actually inspect, and that path
+//     is preserved.
+//   - **Throwing-getter tolerant**. A property whose getter throws
+//     becomes the string `[getter threw]` instead of crashing the
+//     whole ok event.
+function safeValue(v, depth = 0) {
+    if (v === null || v === undefined)
+        return v;
+    const type = typeof v;
+    if (type === 'number' || type === 'boolean')
+        return v;
+    if (type === 'string') {
+        const s = v;
+        return s.length > 200 ? s.slice(0, 197) + '…' : s;
+    }
+    if (type === 'function')
+        return `[Function ${v.name || 'anonymous'}]`;
+    if (type === 'symbol' || type === 'bigint')
+        return String(v);
+    if (type !== 'object')
+        return String(v);
+    if (v instanceof Error) {
+        return { __error: true, name: v.name, message: v.message };
+    }
+    const obj = v;
+    const ctor = (obj.constructor && obj.constructor.name) || '';
+    // Anything that isn't a plain object literal or array becomes opaque.
+    // Object.create(null) instances have no constructor and are treated as plain.
+    const isPlainObject = ctor === '' || ctor === 'Object';
+    if (!isPlainObject && !Array.isArray(v)) {
+        return `[${ctor}]`;
+    }
+    if (depth >= 2)
+        return `[${ctor || 'Object'}]`;
+    if (Array.isArray(v)) {
+        const out = v.slice(0, 10).map((x) => safeValue(x, depth + 1));
+        if (v.length > 10)
+            out.push(`…${v.length - 10} more`);
+        return out;
+    }
+    const out = {};
+    let count = 0;
+    for (const k of Object.keys(obj)) {
+        if (count >= 10) {
+            out['…'] = `${Object.keys(obj).length - 10} more keys`;
+            break;
+        }
+        try {
+            out[k] = safeValue(obj[k], depth + 1);
+        }
+        catch (_) {
+            out[k] = '[getter threw]';
+        }
+        count++;
+    }
+    return out;
+}
+function safeVars(vars) {
+    if (!vars || typeof vars !== 'object')
+        return undefined;
+    const out = {};
+    for (const k of Object.keys(vars)) {
+        try {
+            out[k] = safeValue(vars[k], 0);
+        }
+        catch (_) {
+            out[k] = '[serialize threw]';
+        }
+    }
+    return out;
+}

package/dist/domain/trace-event-recorder/service/trace-event-recorder-state.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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 { TraceEventConsumer } from '../port/trace-event-consumer';
+import type { Clock } from '../port/clock';
+import type { ActiveEnterStack } from './active-enter-stack';
+export interface TraceEventRecorderState {
+    exporter: TraceEventConsumer;
+    clock: Clock;
+    staticContext: Record<string, unknown>;
+    dynamicContext: Record<string, unknown> | null;
+    currentPage: unknown;
+    enterStack: ActiveEnterStack;
+    stepStack: string[];
+    seq: number;
+    startedAt: number;
+}

package/dist/domain/trace-event-recorder/service/trace-event-recorder-state.js

@@ -0,0 +1,7 @@
+"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 });

package/dist/domain/trace-event-recorder/service/trace-event-recorder.d.ts

@@ -0,0 +1,56 @@
+/**
+ * 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 { TraceEventConsumer } from '../port/trace-event-consumer';
+import type { Clock } from '../port/clock';
+import { ActiveEnterStack } from './active-enter-stack';
+import type { TraceEventRecorderState } from './trace-event-recorder-state';
+import type { EnterMeta } from '../model/enter-meta';
+import { SCHEMA_VERSION } from '../model/trace-schema';
+export { SCHEMA_VERSION };
+export type { Clock } from '../port/clock';
+export type { EnterMeta } from '../model/enter-meta';
+export interface CreateTraceEventRecorderOptions {
+    exporter: TraceEventConsumer;
+    clock: Clock;
+    staticContext?: Record<string, unknown>;
+}
+export declare class TraceEventRecorder implements TraceEventRecorderState {
+    readonly SCHEMA_VERSION = 1;
+    exporter: TraceEventConsumer;
+    readonly clock: Clock;
+    readonly staticContext: Record<string, unknown>;
+    dynamicContext: Record<string, unknown> | null;
+    currentPage: unknown;
+    readonly enterStack: ActiveEnterStack;
+    readonly stepStack: string[];
+    seq: number;
+    startedAt: number;
+    constructor(options: CreateTraceEventRecorderOptions);
+    /**
+     * Swap the active exporter for subsequent events. Used by the fixture
+     * to install a fresh projector+tee at the start of every test —
+     * that way each test has an isolated output pipeline without the
+     * recorder having to be rebuilt. The caller is responsible for
+     * flushing/closing the previous exporter if needed.
+     */
+    setExporter: (newExporter: TraceEventConsumer) => void;
+    reset: () => void;
+    setContext: (ctx: Record<string, unknown> | null) => void;
+    setPage: (page: unknown | null) => void;
+    pushStep: (name: string) => void;
+    popStep: () => void;
+    /**
+     * Stamp a highlight screenshot filename onto whatever enter event
+     * is currently on top of the active-enter stack. Called by the
+     * locator-screenshots feature right after it writes the PNG to
+     * disk. No-op if the stack is empty (screenshot fired outside any
+     * instrumented statement, e.g. before the first __enter).
+     */
+    setCurrentStatementScreenshot: (filename: string) => void;
+    __enter: (meta: EnterMeta) => void;
+    __ok: (vars?: unknown) => void;
+    __throw: (err: unknown) => void;
+}

package/dist/domain/trace-event-recorder/service/trace-event-recorder.js

@@ -0,0 +1,80 @@
+"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.TraceEventRecorder = exports.SCHEMA_VERSION = void 0;
+const active_enter_stack_1 = require("./active-enter-stack");
+const trace_schema_1 = require("../model/trace-schema");
+Object.defineProperty(exports, "SCHEMA_VERSION", { enumerable: true, get: function () { return trace_schema_1.SCHEMA_VERSION; } });
+const enter_event_builder_1 = require("./event-builders/enter-event-builder");
+const ok_event_builder_1 = require("./event-builders/ok-event-builder");
+const throw_event_builder_1 = require("./event-builders/throw-event-builder");
+const meta_event_builder_1 = require("./event-builders/meta-event-builder");
+class TraceEventRecorder {
+    constructor(options) {
+        this.SCHEMA_VERSION = trace_schema_1.SCHEMA_VERSION;
+        this.dynamicContext = null;
+        this.currentPage = null;
+        this.enterStack = new active_enter_stack_1.ActiveEnterStack();
+        this.stepStack = [];
+        this.seq = 0;
+        /**
+         * Swap the active exporter for subsequent events. Used by the fixture
+         * to install a fresh projector+tee at the start of every test —
+         * that way each test has an isolated output pipeline without the
+         * recorder having to be rebuilt. The caller is responsible for
+         * flushing/closing the previous exporter if needed.
+         */
+        this.setExporter = (newExporter) => {
+            this.exporter = newExporter;
+        };
+        this.reset = () => {
+            this.exporter.clear();
+            this.enterStack.clear();
+            this.seq = 0;
+            this.startedAt = this.clock.now();
+            (0, meta_event_builder_1.buildMetaEvent)(this);
+        };
+        this.setContext = (ctx) => {
+            this.dynamicContext = ctx ?? null;
+        };
+        this.setPage = (page) => {
+            this.currentPage = page ?? null;
+        };
+        this.pushStep = (name) => {
+            this.stepStack.push(name);
+        };
+        this.popStep = () => {
+            this.stepStack.pop();
+        };
+        /**
+         * Stamp a highlight screenshot filename onto whatever enter event
+         * is currently on top of the active-enter stack. Called by the
+         * locator-screenshots feature right after it writes the PNG to
+         * disk. No-op if the stack is empty (screenshot fired outside any
+         * instrumented statement, e.g. before the first __enter).
+         */
+        this.setCurrentStatementScreenshot = (filename) => {
+            const top = this.enterStack.peek();
+            if (top)
+                top.screenshot = filename;
+        };
+        this.__enter = (meta) => {
+            (0, enter_event_builder_1.buildEnterEvent)(this, meta);
+        };
+        this.__ok = (vars) => {
+            (0, ok_event_builder_1.buildOkEvent)(this, vars);
+        };
+        this.__throw = (err) => {
+            (0, throw_event_builder_1.buildThrowEvent)(this, err);
+        };
+        this.exporter = options.exporter;
+        this.clock = options.clock;
+        this.staticContext = options.staticContext ?? {};
+        this.startedAt = this.clock.now();
+    }
+}
+exports.TraceEventRecorder = TraceEventRecorder;

package/dist/index.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
+ */
+export { test, expect, reset } from './application/playwright-fixture';
+export { configureTracer, onTestTeardown } from './application/heal-config';
+export type { HealTracerConfig, HealTracerTestContext, HealTraceExporterFactory, HealTestLifecycle, HealTestLifecycleFactory, } from './application/heal-config';
+export type { HealTraceExporter } from './domain/trace-event-recorder/port/heal-trace-exporter';
+export type { HealTraceRecord } from './domain/trace-event-recorder/model/statement-trace-schema';
+export * from '@playwright/test';

package/dist/index.js

@@ -0,0 +1,43 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onTestTeardown = exports.configureTracer = exports.reset = exports.expect = exports.test = void 0;
+// Package entry — what `import ... from '@heal-dev/heal-playwright-tracer'` hits.
+//
+// The Playwright surface is re-exported so consumers can keep
+// `import { test, expect, devices } from '@heal-dev/heal-playwright-tracer'`
+// as a drop-in replacement for `@playwright/test`.
+var playwright_fixture_1 = require("./application/playwright-fixture");
+Object.defineProperty(exports, "test", { enumerable: true, get: function () { return playwright_fixture_1.test; } });
+Object.defineProperty(exports, "expect", { enumerable: true, get: function () { return playwright_fixture_1.expect; } });
+Object.defineProperty(exports, "reset", { enumerable: true, get: function () { return playwright_fixture_1.reset; } });
+// Extension API. Users call `configureTracer(...)` from their
+// `playwright.config.ts` to plug in exporters and bindings, and can
+// register per-test teardown callbacks at runtime via
+// `onTestTeardown(...)`.
+var heal_config_1 = require("./application/heal-config");
+Object.defineProperty(exports, "configureTracer", { enumerable: true, get: function () { return heal_config_1.configureTracer; } });
+Object.defineProperty(exports, "onTestTeardown", { enumerable: true, get: function () { return heal_config_1.onTestTeardown; } });
+// Re-export every symbol from @playwright/test so code that imports
+// e.g. `devices`, `chromium`, or the `Page`/`Locator` types from our
+// package still gets them. The named exports above take precedence
+// in module-load order.
+__exportStar(require("@playwright/test"), exports);

package/dist/infrastructure/ndjson-exporter-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 { NdjsonExporter } from './ndjson-exporter';

package/dist/infrastructure/ndjson-exporter-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.NdjsonExporter = void 0;
+var ndjson_exporter_1 = require("./ndjson-exporter");
+Object.defineProperty(exports, "NdjsonExporter", { enumerable: true, get: function () { return ndjson_exporter_1.NdjsonExporter; } });

package/dist/infrastructure/ndjson-exporter-adapter/ndjson-exporter.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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 { HealTraceExporter, HealTraceRecord } from '../../domain/trace-event-recorder/port/heal-trace-exporter';
+export declare class NdjsonExporter implements HealTraceExporter {
+    private readonly fd;
+    private closed;
+    constructor(filePath: string);
+    write(record: HealTraceRecord): void;
+    close(): Promise<void>;
+}