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

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

@@ -10,6 +10,7 @@ export declare class StatementProjector implements TraceEventConsumer {
     private readonly output;
     private readonly allBySeq;
     private readonly rootsBySeq;
+    private statementCount;
     private headerEmitted;
     private finalized;
     constructor(output: HealTraceExporter);
@@ -19,8 +20,16 @@ export declare class StatementProjector implements TraceEventConsumer {
      * Emit the final `test-result` record and close the underlying
      * exporter. Called once at test teardown; the projector is unusable
      * afterwards.
+     *
+     * Any root statements still live in `rootsBySeq` at this point had
+     * their `__enter` fire but never their matching `__ok`/`__throw` —
+     * typically because Playwright's test timeout short-circuited
+     * teardown before the hanging action rejected. Flushing them as
+     * `threw` with the test-level error makes the partial work visible
+     * in the trace instead of silently dropped.
      */
-    finalize(result: Omit<TestResultRecord, 'kind'>): Promise<void>;
+    finalize(result: Omit<TestResultRecord, 'kind'>, pendingError?: unknown): Promise<void>;
+    private flushPendingRoots;
     private maybeEmitRoot;
     private dropSubtree;
 }

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

@@ -7,6 +7,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StatementProjector = void 0;
 const statement_trace_schema_1 = require("../../model/statement-trace-schema");
+const error_serializer_1 = require("../serializers/error-serializer");
 class StatementProjector {
     constructor(output) {
         this.output = output;
@@ -16,6 +17,10 @@ class StatementProjector {
         // Subset: statements whose runtime parent was null. These are
         // the only ones that become their own NDJSON record.
         this.rootsBySeq = new Map();
+        // Per-test, 0-based contiguous counter stamped onto every
+        // Statement at enter-time as `index`. Reset by `clear()` so each
+        // test starts at 0.
+        this.statementCount = 0;
         this.headerEmitted = false;
         this.finalized = false;
     }
@@ -35,7 +40,10 @@ class StatementProjector {
                 return;
             }
             case 'enter': {
-                const live = { stmt: createStatement(event), enter: event };
+                const live = {
+                    stmt: createStatement(event, this.statementCount++),
+                    enter: event,
+                };
                 this.allBySeq.set(event.seq, live);
                 if (event.parentSeq == null) {
                     this.rootsBySeq.set(event.seq, live);
@@ -91,20 +99,46 @@ class StatementProjector {
     clear() {
         this.allBySeq.clear();
         this.rootsBySeq.clear();
+        this.statementCount = 0;
         this.headerEmitted = false;
     }
     /**
      * Emit the final `test-result` record and close the underlying
      * exporter. Called once at test teardown; the projector is unusable
      * afterwards.
+     *
+     * Any root statements still live in `rootsBySeq` at this point had
+     * their `__enter` fire but never their matching `__ok`/`__throw` —
+     * typically because Playwright's test timeout short-circuited
+     * teardown before the hanging action rejected. Flushing them as
+     * `threw` with the test-level error makes the partial work visible
+     * in the trace instead of silently dropped.
      */
-    async finalize(result) {
+    async finalize(result, pendingError) {
         if (this.finalized)
             return;
+        this.flushPendingRoots(result.duration, pendingError);
         this.finalized = true;
         this.output.write({ kind: 'test-result', ...result });
         await this.output.close();
     }
+    flushPendingRoots(testDuration, pendingError) {
+        if (this.rootsBySeq.size === 0)
+            return;
+        const error = (0, error_serializer_1.serializeError)(pendingError ?? new Error('Statement still pending when test ended'));
+        const pending = Array.from(this.rootsBySeq.entries()).sort(([a], [b]) => a - b);
+        for (const [seq, live] of pending) {
+            live.stmt.status = 'threw';
+            live.stmt.duration = Math.max(0, testDuration - live.stmt.t);
+            live.stmt.error = error;
+            if (live.enter.screenshot)
+                live.stmt.screenshot = live.enter.screenshot;
+            sortChildrenDeep(live.stmt);
+            this.output.write({ kind: 'statement', statement: live.stmt });
+            this.dropSubtree(live.stmt);
+            this.rootsBySeq.delete(seq);
+        }
+    }
     maybeEmitRoot(seq, live) {
         if (!this.rootsBySeq.has(seq))
             return;
@@ -122,9 +156,10 @@ class StatementProjector {
     }
 }
 exports.StatementProjector = StatementProjector;
-function createStatement(event) {
+function createStatement(event, index) {
     const stmt = {
         seq: event.seq,
+        index,
         file: event.file,
         line: event.startLine,
         endLine: event.endLine,
@@ -168,6 +203,7 @@ function buildTestHeader(meta) {
         testId: meta.testId ?? '',
         attempt: meta.attempt ?? 1,
         ...(meta.testCaseId !== undefined ? { testCaseId: meta.testCaseId } : {}),
+        ...(meta.executionId !== undefined ? { executionId: meta.executionId } : {}),
     };
     return {
         title: meta.testTitle ?? '',

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

@@ -8,6 +8,14 @@ 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)/;
+const PLAYWRIGHT_TIMEOUT_MSG = /^Test timeout of \d+ms exceeded/;
+// CSI sequence: ESC [ … letter. Covers the SGR color codes
+// Playwright uses (`\x1b[31m`, `\x1b[39m`) and any other Select
+// Graphic Rendition the runtime might emit.
+const ANSI_REGEX = /\x1b\[[0-9;]*m/g;
+function stripAnsi(s) {
+    return s.replace(ANSI_REGEX, '');
+}
 function serializeError(err) {
     if (err == null)
         return { message: String(err) };
@@ -15,15 +23,25 @@ function serializeError(err) {
         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),
-    };
+    const stackStr = e.stack
+        ? stripAnsi(String(e.stack).split('\n').slice(0, 20).join('\n'))
+        : undefined;
+    const message = stripAnsi(e.message != null ? String(e.message) : String(err));
+    let name = e.name || ctorName || 'Error';
+    const isPwStack = PLAYWRIGHT_STACK.test(stackStr || '');
+    const looksLikeTimeout = PLAYWRIGHT_TIMEOUT_MSG.test(message);
+    // Playwright's `testInfo.errors[i]` is a `TestInfoError`-shaped
+    // plain object with no `.name` and constructor `Object`. When we
+    // can prove the throw came from Playwright (stack path or
+    // timeout message), upgrade the class name so consumers get a
+    // useful discriminator instead of `Object` / `Error`.
+    if ((name === 'Object' || name === 'Error') && (isPwStack || looksLikeTimeout)) {
+        name = looksLikeTimeout ? 'TimeoutError' : 'PlaywrightError';
+    }
+    const result = { name, message };
     if (stackStr)
         result.stack = stackStr;
-    result.isPlaywrightError =
-        PLAYWRIGHT_ERROR_CTOR.test(ctorName) || PLAYWRIGHT_STACK.test(stackStr || '');
+    result.isPlaywrightError = PLAYWRIGHT_ERROR_CTOR.test(ctorName) || isPwStack || looksLikeTimeout;
     const causes = [];
     let cur = e.cause;
     let d = 0;
@@ -32,13 +50,13 @@ function serializeError(err) {
             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,
+                message: stripAnsi(c.message != null ? String(c.message) : String(cur)),
+                stack: c.stack ? stripAnsi(String(c.stack).split('\n').slice(0, 10).join('\n')) : undefined,
             });
             cur = c.cause;
         }
         else {
-            causes.push({ message: String(cur) });
+            causes.push({ message: stripAnsi(String(cur)) });
             break;
         }
         d++;

package/dist/domain/trace-event-recorder/service/serializers/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 { serializeError } from './error-serializer';
+export { safeValue, safeVars } from './variable-snapshot-serializer';

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

@@ -0,0 +1,13 @@
+"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.safeVars = exports.safeValue = exports.serializeError = void 0;
+var error_serializer_1 = require("./error-serializer");
+Object.defineProperty(exports, "serializeError", { enumerable: true, get: function () { return error_serializer_1.serializeError; } });
+var variable_snapshot_serializer_1 = require("./variable-snapshot-serializer");
+Object.defineProperty(exports, "safeValue", { enumerable: true, get: function () { return variable_snapshot_serializer_1.safeValue; } });
+Object.defineProperty(exports, "safeVars", { enumerable: true, get: function () { return variable_snapshot_serializer_1.safeVars; } });

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

@@ -50,6 +50,31 @@ export declare class TraceEventRecorder implements TraceEventRecorderState {
      * instrumented statement, e.g. before the first __enter).
      */
     setCurrentStatementScreenshot: (filename: string) => void;
+    /**
+     * Read the `seq` of the enter event currently on top of the active
+     * stack — i.e. "what statement is running right now" — for sidecar
+     * adapters (network, console) that need to attribute an out-of-band
+     * event back to a statement. Returns `undefined` when the stack is
+     * empty (event fired between statements / outside any test body).
+     *
+     * Pure read; no allocation, safe to call from a Playwright event
+     * listener on the hot path.
+     */
+    getCurrentStatementSeq: () => number | undefined;
+    /**
+     * Snapshot the currently-active step path (a copy of the step
+     * stack) for sidecar records that want to denormalize the path the
+     * way `StatementProjector` does. Returns `undefined` when no
+     * `test.step(...)` is active so callers can omit the field
+     * entirely instead of writing an empty array.
+     */
+    getCurrentStepPath: () => string[] | undefined;
+    /**
+     * The wall-clock origin used by every timestamp in the trace —
+     * sidecar adapters subtract this from `clock.now()` to produce a
+     * `t` field on the same axis as `Statement.t`.
+     */
+    getStartedAt: () => number;
     __enter: (meta: EnterMeta) => void;
     __ok: (vars?: unknown) => void;
     __throw: (err: unknown) => void;

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

@@ -62,6 +62,39 @@ class TraceEventRecorder {
             if (top)
                 top.screenshot = filename;
         };
+        /**
+         * Read the `seq` of the enter event currently on top of the active
+         * stack — i.e. "what statement is running right now" — for sidecar
+         * adapters (network, console) that need to attribute an out-of-band
+         * event back to a statement. Returns `undefined` when the stack is
+         * empty (event fired between statements / outside any test body).
+         *
+         * Pure read; no allocation, safe to call from a Playwright event
+         * listener on the hot path.
+         */
+        this.getCurrentStatementSeq = () => {
+            return this.enterStack.peek()?.seq;
+        };
+        /**
+         * Snapshot the currently-active step path (a copy of the step
+         * stack) for sidecar records that want to denormalize the path the
+         * way `StatementProjector` does. Returns `undefined` when no
+         * `test.step(...)` is active so callers can omit the field
+         * entirely instead of writing an empty array.
+         */
+        this.getCurrentStepPath = () => {
+            if (this.stepStack.length === 0)
+                return undefined;
+            return this.stepStack.slice();
+        };
+        /**
+         * The wall-clock origin used by every timestamp in the trace —
+         * sidecar adapters subtract this from `clock.now()` to produce a
+         * `t` field on the same axis as `Statement.t`.
+         */
+        this.getStartedAt = () => {
+            return this.startedAt;
+        };
         this.__enter = (meta) => {
             (0, enter_event_builder_1.buildEnterEvent)(this, meta);
         };

package/dist/index.d.ts

@@ -5,7 +5,7 @@
  */
 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 { HealTracerConfig, HealTracerTestContext, HealTraceExporterFactory, HealTestLifecycle, HealTestLifecycleFactory, StatementPreProcessor, StatementPreProcessorContext, } 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/infrastructure/artifact-summary-printer/artifact-summary-printer.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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 type ArtifactSummaryStatus = 'passed' | 'failed' | 'timedOut' | 'skipped' | 'interrupted';
+export interface ArtifactSummary {
+    title: string;
+    status: ArtifactSummaryStatus;
+}
+export interface SummaryOutputStream {
+    write(chunk: string): boolean;
+}
+export declare class ArtifactSummaryPrinter {
+    private readonly testDir;
+    private readonly stream;
+    constructor(testDir: string, stream?: SummaryOutputStream);
+    print(summary: ArtifactSummary): void;
+    formatSummary(summary: ArtifactSummary): string;
+}

package/dist/infrastructure/artifact-summary-printer/artifact-summary-printer.js

@@ -0,0 +1,24 @@
+"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.ArtifactSummaryPrinter = void 0;
+class ArtifactSummaryPrinter {
+    constructor(testDir, stream = process.stderr) {
+        this.testDir = testDir;
+        this.stream = stream;
+    }
+    print(summary) {
+        if (process.env.HEAL_PRINT_ARTIFACT_PATHS !== '1')
+            return;
+        this.stream.write(this.formatSummary(summary));
+    }
+    formatSummary(summary) {
+        return (`[heal-playwright-tracer] ${summary.title} (${summary.status})\n` +
+            `  test artifacts dir: ${this.testDir}\n`);
+    }
+}
+exports.ArtifactSummaryPrinter = ArtifactSummaryPrinter;

package/dist/infrastructure/artifact-summary-printer/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 { ArtifactSummaryPrinter } from './artifact-summary-printer';
+export type { ArtifactSummary, ArtifactSummaryStatus, SummaryOutputStream, } from './artifact-summary-printer';

package/dist/infrastructure/artifact-summary-printer/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.ArtifactSummaryPrinter = void 0;
+var artifact_summary_printer_1 = require("./artifact-summary-printer");
+Object.defineProperty(exports, "ArtifactSummaryPrinter", { enumerable: true, get: function () { return artifact_summary_printer_1.ArtifactSummaryPrinter; } });

package/dist/infrastructure/heal-reporter/crash-error-classifier.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 { StatementError } from '../../domain/trace-event-recorder/model/statement-trace-schema';
+export interface TestInfoErrorLike {
+    message?: string;
+    stack?: string;
+}
+export declare class CrashErrorClassifier {
+    classify(errors: readonly TestInfoErrorLike[], stderr: string): StatementError;
+}

package/dist/infrastructure/heal-reporter/crash-error-classifier.js

@@ -0,0 +1,65 @@
+"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.CrashErrorClassifier = void 0;
+// Classifies a Playwright worker crash into a normalized `StatementError`.
+//
+// Input signals (combined by the reporter from main-process state):
+//   - `errors`  — `TestResult.errors[]` from Playwright. On a hard
+//                  worker death Playwright typically fabricates a
+//                  single entry like "Worker process exited
+//                  unexpectedly (code=null signal=SIGKILL)".
+//   - `stderr`  — the concatenated worker stderr collected via
+//                  `Reporter.onStdErr`. Node's OOM banner
+//                  ("FATAL ERROR: … JavaScript heap out of memory")
+//                  lands here, emitted by V8 right before abort.
+//
+// Classification order matters: OOM is detected FIRST because its
+// banner often coexists with a generic "Worker process exited"
+// message in `errors` — the more specific signal wins. Segfaults
+// ride on the same SIGSEGV channel as SIGKILL so they share the
+// `WorkerCrash` name.
+//
+// Output shape matches the `SerializedError` used everywhere else in
+// the trace, so consumers can treat a reporter-synthesized crash the
+// same way they treat a regular `status: 'threw'` error.
+const serializers_1 = require("../../domain/trace-event-recorder/service/serializers");
+const OOM_BANNER = /FATAL ERROR:[^\n]*(?:Reached heap limit|heap out of memory|Allocation failed)[^\n]*/;
+const WORKER_EXIT = /Worker process exited unexpectedly/i;
+const FATAL_SIGNAL = /SIG(?:KILL|SEGV|ABRT|BUS)/;
+class CrashErrorClassifier {
+    classify(errors, stderr) {
+        const oom = OOM_BANNER.exec(stderr);
+        if (oom) {
+            return {
+                name: 'OutOfMemoryError',
+                message: oom[0],
+                stack: stderr.length > 0 ? stderr.slice(-4096) : undefined,
+                isPlaywrightError: false,
+            };
+        }
+        const first = errors[0];
+        const firstMsg = first?.message ?? '';
+        if (WORKER_EXIT.test(firstMsg) || FATAL_SIGNAL.test(firstMsg)) {
+            return {
+                name: 'WorkerCrash',
+                message: firstMsg,
+                stack: first?.stack,
+                isPlaywrightError: false,
+            };
+        }
+        if (first) {
+            return (0, serializers_1.serializeError)(first);
+        }
+        return {
+            name: 'WorkerCrash',
+            message: 'Worker terminated without diagnostic details',
+            isPlaywrightError: false,
+        };
+    }
+}
+exports.CrashErrorClassifier = CrashErrorClassifier;

package/dist/infrastructure/heal-reporter/failing-statement-finder.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 { FailingStatement } from '../../domain/persistence';
+import type { StatementError } from '../../domain/trace-event-recorder/model/statement-trace-schema';
+export interface FoundFailure {
+    statement: FailingStatement;
+    error: StatementError;
+}
+export declare class FailingStatementFinder {
+    find(ndjsonPath: string): FoundFailure | null;
+}

package/dist/infrastructure/heal-reporter/failing-statement-finder.js

@@ -0,0 +1,118 @@
+"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.FailingStatementFinder = void 0;
+// Locates the statement responsible for a test failure inside one
+// `heal-traces.ndjson`. Used by `HealTracerReporter.onTestEnd` to
+// surface a compact `FailingStatement` + `StatementError` on each
+// attempt of the `execution.json` manifest.
+//
+// "Failing statement" = the deepest node in any root `statement`
+// record's children tree whose `status === 'threw'`. Going deepest
+// rather than first-seen surfaces the actual leaf call that threw
+// (e.g. `page.locator(...).click()`) instead of the enclosing user
+// step that propagated the error up.
+//
+// Returns null when the file is missing/torn, no statement threw,
+// or the statement that threw has no error attached (defensive — the
+// schema requires `error` on `status === 'threw'` but we tolerate
+// older traces).
+const fs = __importStar(require("fs"));
+class FailingStatementFinder {
+    find(ndjsonPath) {
+        let body;
+        try {
+            body = fs.readFileSync(ndjsonPath, 'utf8');
+        }
+        catch {
+            return null;
+        }
+        let deepest = null;
+        for (const line of body.split('\n')) {
+            const trimmed = line.trim();
+            if (trimmed.length === 0)
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(trimmed);
+            }
+            catch {
+                // Torn-write tolerance: skip unparseable lines. Mirrors the
+                // discipline of `NdjsonTailInspector`.
+                continue;
+            }
+            if (parsed?.kind !== 'statement' || !parsed.statement)
+                continue;
+            const found = findDeepestThrew(parsed.statement, 0);
+            if (found && (!deepest || found.depth > deepest.depth)) {
+                deepest = found;
+            }
+        }
+        if (!deepest || !deepest.stmt.error)
+            return null;
+        return {
+            statement: project(deepest.stmt),
+            error: deepest.stmt.error,
+        };
+    }
+}
+exports.FailingStatementFinder = FailingStatementFinder;
+function findDeepestThrew(stmt, depth) {
+    let best = stmt.status === 'threw' ? { stmt, depth } : null;
+    for (const child of stmt.children) {
+        const found = findDeepestThrew(child, depth + 1);
+        if (found && (!best || found.depth > best.depth)) {
+            best = found;
+        }
+    }
+    return best;
+}
+function project(stmt) {
+    return {
+        index: stmt.index,
+        file: stmt.file,
+        line: stmt.line,
+        endLine: stmt.endLine,
+        source: stmt.source,
+        scope: stmt.scope,
+        step: stmt.step,
+        stepPath: stmt.stepPath,
+    };
+}