donobu 5.26.0 → 5.27.0

package/dist/esm/managers/TestsManager.js

@@ -4,7 +4,7 @@ exports.TestsManager = void 0;
 const crypto_1 = require("crypto");
 const CannotDeleteRunningFlowException_1 = require("../exceptions/CannotDeleteRunningFlowException");
 const TestNotFoundException_1 = require("../exceptions/TestNotFoundException");
-const MiscUtils_1 = require("../utils/MiscUtils");
+const displayName_1 = require("../utils/displayName");
 const FederatedPagination_1 = require("./FederatedPagination");
 class TestsManager {
     constructor(testsPersistenceRegistry, flowsManager) {
@@ -22,7 +22,7 @@ class TestsManager {
         const testMetadata = {
             id: testId,
             metadataVersion: 1,
-            name: MiscUtils_1.MiscUtils.getDisplayName({ name: params.name ?? null, web }),
+            name: (0, displayName_1.getDisplayName)({ name: params.name ?? null, web }),
             suiteId: params.suiteId ?? null,
             nextRunMode: params.nextRunMode ?? 'AUTONOMOUS',
             target: params.target,

package/dist/esm/models/CreateTest.d.ts

@@ -13,7 +13,6 @@ export declare const CreateTestSchema: z.ZodObject<{
         javascript: z.ZodString;
     }, z.core.$strip>>>>;
     overallObjective: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    allowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
     resultJsonSchema: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     callbackUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     maxToolCalls: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
@@ -140,6 +139,7 @@ export declare const CreateTestSchema: z.ZodObject<{
         INSTRUCT: "INSTRUCT";
         DETERMINISTIC: "DETERMINISTIC";
     }>>>;
+    allowedTools: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
 }, z.core.$loose>;
 export type CreateTest = z.infer<typeof CreateTestSchema>;
 //# sourceMappingURL=CreateTest.d.ts.map

package/dist/esm/models/CreateTest.js

@@ -36,6 +36,12 @@ exports.CreateTestSchema = RunConfig_1.RunConfigSchema.partial()
     nextRunMode: RunMode_1.RunModeSchema.nullable()
         .optional()
         .describe('The run mode to use when creating flows from this test. Defaults to AUTONOMOUS.'),
+    // `allowedTools` is the only field in RunConfig that isn't already
+    // nullable at the base, so `.partial()` above only adds `.optional()`
+    // (accepts `undefined`, not `null`). Manual-test creation sends `null`
+    // here — mirror the nullable override that CreateDonobuFlowSchema uses
+    // so the two creation endpoints accept the same payload shape.
+    allowedTools: RunConfig_1.RunConfigSchema.shape.allowedTools.nullable().optional(),
 })
     .loose();
 //# sourceMappingURL=CreateTest.js.map

package/dist/esm/persistence/DonobuSqliteDb.js

@@ -42,8 +42,13 @@ const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
 const fs = __importStar(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
 const LockFile = __importStar(require("proper-lockfile"));
+const v4_1 = require("zod/v4");
+const FlowMetadata_1 = require("../models/FlowMetadata");
+const displayName_1 = require("../utils/displayName");
 const Logger_1 = require("../utils/Logger");
 const MiscUtils_1 = require("../utils/MiscUtils");
+const normalizeFlowMetadata_1 = require("./normalizeFlowMetadata");
+const TestConfigHash_1 = require("./TestConfigHash");
 let instance = null;
 /**
  * ##################################################################
@@ -415,6 +420,103 @@ CREATE INDEX IF NOT EXISTS idx_ai_queries_flow_id_started_at ON ai_queries(flow_
 `);
         },
     },
+    {
+        // Back-fill tests for orphan flows (test_id IS NULL). Flows with identical
+        // RunConfig-derived fields are grouped under a single new test whose id is
+        // the MD5 hash of the canonical-sorted config JSON. See TestConfigHash.ts.
+        version: 12,
+        up: (db) => {
+            // 1. Fetch all flows with null test_id, oldest first.
+            const flows = v4_1.z
+                .array(v4_1.z.object({ id: v4_1.z.string(), metadata: v4_1.z.string() }))
+                .parse(db
+                .prepare('SELECT id, metadata FROM flow_metadata WHERE test_id IS NULL ORDER BY created_at ASC')
+                .all());
+            if (flows.length === 0) {
+                return;
+            }
+            const groups = new Map();
+            for (const flow of flows) {
+                try {
+                    const metadata = FlowMetadata_1.FlowMetadataSchema.parse((0, normalizeFlowMetadata_1.normalizeFlowMetadata)(JSON.parse(flow.metadata)));
+                    const hash = (0, TestConfigHash_1.hashTestConfig)(metadata);
+                    const groupedFlow = { id: flow.id, metadata };
+                    const existing = groups.get(hash);
+                    if (existing) {
+                        existing.flows.push(groupedFlow);
+                    }
+                    else {
+                        groups.set(hash, { flows: [groupedFlow] });
+                    }
+                }
+                catch (error) {
+                    // Fail open: skip flows we can't parse/normalize so one bad row
+                    // doesn't block the rest of the migration.
+                    Logger_1.appLogger.error(`Migration 12: skipping flow ${flow.id} during grouping:`, error);
+                }
+            }
+            // 4. Create a test for each group.
+            const insertTestStmt = db.prepare(`
+        INSERT INTO test_metadata (id, name, metadata, created_at, suite_id, next_run_mode)
+        VALUES (@id, @name, @metadata, @createdAt, @suiteId, @nextRunMode)
+      `);
+            const updateFlowStmt = db.prepare('UPDATE flow_metadata SET test_id = ?, metadata = ? WHERE id = ?');
+            for (const [hash, group] of groups) {
+                try {
+                    // Flows were inserted oldest-first, so the last entry is newest.
+                    const newest = group.flows[group.flows.length - 1].metadata;
+                    // `maxToolCalls` is null on every deterministic flow, so prefer the
+                    // most recent autonomous flow's value. Fall back to the newest flow's
+                    // value (likely null) if no autonomous flow exists in the group.
+                    const newestAutonomous = [...group.flows]
+                        .reverse()
+                        .find((f) => f.metadata.runMode === 'AUTONOMOUS')?.metadata;
+                    const maxToolCalls = newestAutonomous?.maxToolCalls ?? newest.maxToolCalls;
+                    const testName = (0, displayName_1.getDisplayName)(newest, 'Untitled Test');
+                    const testMetadata = {
+                        id: hash,
+                        name: testName,
+                        target: newest.target,
+                        web: newest.web,
+                        envVars: newest.envVars,
+                        customTools: newest.customTools,
+                        overallObjective: newest.overallObjective,
+                        allowedTools: newest.allowedTools,
+                        resultJsonSchema: newest.resultJsonSchema,
+                        callbackUrl: newest.callbackUrl,
+                        videoDisabled: newest.videoDisabled,
+                        maxToolCalls,
+                        metadataVersion: newest.metadataVersion,
+                        createdWithDonobuVersion: newest.createdWithDonobuVersion,
+                        suiteId: null,
+                        nextRunMode: 'DETERMINISTIC',
+                    };
+                    insertTestStmt.run({
+                        id: hash,
+                        name: testName,
+                        metadata: JSON.stringify(testMetadata),
+                        createdAt: Date.now(),
+                        suiteId: null,
+                        nextRunMode: 'DETERMINISTIC',
+                    });
+                    // 5. Link each flow to its test (both test_id column and testId in JSON).
+                    for (const groupedFlow of group.flows) {
+                        try {
+                            groupedFlow.metadata.testId = hash;
+                            updateFlowStmt.run(hash, JSON.stringify(groupedFlow.metadata), groupedFlow.id);
+                        }
+                        catch (error) {
+                            Logger_1.appLogger.error(`Migration 12: failed to link flow ${groupedFlow.id} to test ${hash}:`, error);
+                        }
+                    }
+                }
+                catch (error) {
+                    // Fail open: skip groups we can't materialize as tests.
+                    Logger_1.appLogger.error(`Migration 12: skipping test group ${hash}:`, error);
+                }
+            }
+        },
+    },
 ];
 /**
  * Create the SQL schema migrations table that can be used to manage table

package/dist/esm/persistence/TestConfigHash.d.ts

@@ -0,0 +1,11 @@
+import type { FlowMetadata } from '../models/FlowMetadata';
+/**
+ * Deterministic MD5 of the RunConfig-derived slice of `metadata`, used to
+ * group orphan flows into a single back-filled test during migration v12 and
+ * the equivalent cloud ops script. `maxToolCalls` is excluded because it is
+ * null on deterministic flows and would otherwise split groups along run-mode
+ * boundaries. MD5 is fine here because the hash is used for grouping, not
+ * security.
+ */
+export declare function hashTestConfig(metadata: FlowMetadata): string;
+//# sourceMappingURL=TestConfigHash.d.ts.map

package/dist/esm/persistence/TestConfigHash.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashTestConfig = hashTestConfig;
+const crypto_1 = require("crypto");
+const fast_json_stable_stringify_1 = __importDefault(require("fast-json-stable-stringify"));
+/**
+ * Deterministic MD5 of the RunConfig-derived slice of `metadata`, used to
+ * group orphan flows into a single back-filled test during migration v12 and
+ * the equivalent cloud ops script. `maxToolCalls` is excluded because it is
+ * null on deterministic flows and would otherwise split groups along run-mode
+ * boundaries. MD5 is fine here because the hash is used for grouping, not
+ * security.
+ */
+function hashTestConfig(metadata) {
+    const config = {
+        name: metadata.name,
+        target: metadata.target,
+        web: metadata.web,
+        envVars: metadata.envVars,
+        customTools: metadata.customTools,
+        overallObjective: metadata.overallObjective,
+        allowedTools: metadata.allowedTools,
+        resultJsonSchema: metadata.resultJsonSchema,
+        callbackUrl: metadata.callbackUrl,
+    };
+    return (0, crypto_1.createHash)('md5').update((0, fast_json_stable_stringify_1.default)(config)).digest('hex');
+}
+//# sourceMappingURL=TestConfigHash.js.map

package/dist/esm/persistence/flows/FlowsPersistenceSqlite.d.ts

@@ -6,15 +6,6 @@ import type { PaginatedResult } from '../../models/PaginatedResult';
 import type { ToolCall } from '../../models/ToolCall';
 import type { VideoSegment } from '../../models/VideoSegment';
 import type { FlowsPersistence } from './FlowsPersistence';
-/**
- * Normalizes flow metadata written by older SDK versions to the current schema.
- *
- * Rows written by SDK v5+ carry a `metadataVersion` field. Rows without it
- * were written by an older SDK and may use a legacy format (e.g. top-level
- * `browser` / `targetWebsite` instead of the `{ target, web }` wrapper
- * introduced in migration v9).
- */
-export declare function normalizeFlowMetadata(raw: Record<string, unknown>): FlowMetadata;
 /**
  * A persistence implementation that uses SQLite for all data storage, including binary files.
  */

package/dist/esm/persistence/flows/FlowsPersistenceSqlite.js

@@ -1,40 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowsPersistenceSqlite = void 0;
-exports.normalizeFlowMetadata = normalizeFlowMetadata;
 const crypto_1 = require("crypto");
 const FlowNotFoundException_1 = require("../../exceptions/FlowNotFoundException");
 const BrowserStorageState_1 = require("../../models/BrowserStorageState");
 const MiscUtils_1 = require("../../utils/MiscUtils");
-/**
- * Current metadata schema version. Bump this when the metadata JSON structure
- * changes in a way that requires read-time normalization.
- */
-const CURRENT_METADATA_VERSION = 1;
-/**
- * Normalizes flow metadata written by older SDK versions to the current schema.
- *
- * Rows written by SDK v5+ carry a `metadataVersion` field. Rows without it
- * were written by an older SDK and may use a legacy format (e.g. top-level
- * `browser` / `targetWebsite` instead of the `{ target, web }` wrapper
- * introduced in migration v9).
- */
-function normalizeFlowMetadata(raw) {
-    if (raw.metadataVersion === CURRENT_METADATA_VERSION) {
-        return raw;
-    }
-    // Pre-v5 format: `browser` and `targetWebsite` at the top level, no `target`.
-    if (!raw.target && raw.browser) {
-        raw.target = 'web';
-        raw.web = {
-            browser: raw.browser,
-            targetWebsite: raw.targetWebsite ?? '',
-        };
-        delete raw.browser;
-        delete raw.targetWebsite;
-    }
-    return raw;
-}
+const normalizeFlowMetadata_1 = require("../normalizeFlowMetadata");
 /**
  * A persistence implementation that uses SQLite for all data storage, including binary files.
  */
@@ -111,7 +82,7 @@ class FlowsPersistenceSqlite {
         if (!row) {
             throw FlowNotFoundException_1.FlowNotFoundException.forId(flowId);
         }
-        return normalizeFlowMetadata(JSON.parse(row.metadata));
+        return (0, normalizeFlowMetadata_1.normalizeFlowMetadata)(JSON.parse(row.metadata));
     }
     async getFlowMetadataByName(flowName) {
         const stmt = this.db.prepare('SELECT metadata FROM flow_metadata WHERE name = ? ORDER BY created_at DESC LIMIT 1');
@@ -119,7 +90,7 @@ class FlowsPersistenceSqlite {
         if (!row) {
             throw FlowNotFoundException_1.FlowNotFoundException.forName(flowName);
         }
-        return normalizeFlowMetadata(JSON.parse(row.metadata));
+        return (0, normalizeFlowMetadata_1.normalizeFlowMetadata)(JSON.parse(row.metadata));
     }
     async getFlowsMetadata(query) {
         // Sanitize inputs
@@ -186,7 +157,7 @@ class FlowsPersistenceSqlite {
         // Generate next token if needed
         const nextPageToken = hasMore ? `${offset + validLimit}` : undefined;
         return {
-            items: results.map((row) => normalizeFlowMetadata(JSON.parse(row.metadata))),
+            items: results.map((row) => (0, normalizeFlowMetadata_1.normalizeFlowMetadata)(JSON.parse(row.metadata))),
             nextPageToken,
         };
     }

package/dist/esm/persistence/normalizeFlowMetadata.d.ts

@@ -0,0 +1,16 @@
+import type { FlowMetadata } from '../models/FlowMetadata';
+/**
+ * Current metadata schema version. Bump this when the metadata JSON structure
+ * changes in a way that requires read-time normalization.
+ */
+export declare const CURRENT_METADATA_VERSION = 1;
+/**
+ * Normalizes flow metadata written by older SDK versions to the current schema.
+ *
+ * Rows written by SDK v5+ carry a `metadataVersion` field. Rows without it
+ * were written by an older SDK and may use a legacy format (e.g. top-level
+ * `browser` / `targetWebsite` instead of the `{ target, web }` wrapper
+ * introduced in migration v9).
+ */
+export declare function normalizeFlowMetadata(raw: Record<string, unknown>): FlowMetadata;
+//# sourceMappingURL=normalizeFlowMetadata.d.ts.map

package/dist/esm/persistence/normalizeFlowMetadata.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CURRENT_METADATA_VERSION = void 0;
+exports.normalizeFlowMetadata = normalizeFlowMetadata;
+/**
+ * Current metadata schema version. Bump this when the metadata JSON structure
+ * changes in a way that requires read-time normalization.
+ */
+exports.CURRENT_METADATA_VERSION = 1;
+/**
+ * Normalizes flow metadata written by older SDK versions to the current schema.
+ *
+ * Rows written by SDK v5+ carry a `metadataVersion` field. Rows without it
+ * were written by an older SDK and may use a legacy format (e.g. top-level
+ * `browser` / `targetWebsite` instead of the `{ target, web }` wrapper
+ * introduced in migration v9).
+ */
+function normalizeFlowMetadata(raw) {
+    if (raw.metadataVersion === exports.CURRENT_METADATA_VERSION) {
+        return raw;
+    }
+    // Pre-v5 format: `browser` and `targetWebsite` at the top level, no `target`.
+    if (!raw.target && raw.browser) {
+        raw.target = 'web';
+        raw.web = {
+            browser: raw.browser,
+            targetWebsite: raw.targetWebsite ?? '',
+        };
+        delete raw.browser;
+        delete raw.targetWebsite;
+    }
+    return raw;
+}
+//# sourceMappingURL=normalizeFlowMetadata.js.map

package/dist/esm/reporter/buildReport.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @fileoverview Reconstructs a `DonobuReport` from live Playwright `Reporter`
+ * events. Shared across all Donobu reporter classes (HTML, Markdown, Slack)
+ * so they all agree on the canonical shape sent downstream to the renderers
+ * and the auto-heal merge step.
+ *
+ * The output structure mirrors Playwright's native JSON reporter:
+ *   suites (one per file) → specs (one per test title) → tests (one per project)
+ * plus the Donobu-specific `metadata` fields the merge + render steps rely on.
+ */
+import type { TestCase, TestResult } from '@playwright/test/reporter';
+import type { DonobuReport } from './model';
+/**
+ * Build a canonical `DonobuReport` from the per-test result accumulators that
+ * each Donobu reporter maintains during a run.
+ *
+ * Callers are expected to fill in `metadata` (specifically the `donobuOutputs`
+ * entry for their format) before persisting the result — this helper owns the
+ * structure walk, not the output-path accounting.
+ */
+export declare function buildDonobuReport(resultsByTest: Map<TestCase, TestResult[]>): DonobuReport;
+//# sourceMappingURL=buildReport.d.ts.map

package/dist/esm/reporter/buildReport.js

@@ -0,0 +1,106 @@
+"use strict";
+/**
+ * @fileoverview Reconstructs a `DonobuReport` from live Playwright `Reporter`
+ * events. Shared across all Donobu reporter classes (HTML, Markdown, Slack)
+ * so they all agree on the canonical shape sent downstream to the renderers
+ * and the auto-heal merge step.
+ *
+ * The output structure mirrors Playwright's native JSON reporter:
+ *   suites (one per file) → specs (one per test title) → tests (one per project)
+ * plus the Donobu-specific `metadata` fields the merge + render steps rely on.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildDonobuReport = buildDonobuReport;
+/**
+ * Build a canonical `DonobuReport` from the per-test result accumulators that
+ * each Donobu reporter maintains during a run.
+ *
+ * Callers are expected to fill in `metadata` (specifically the `donobuOutputs`
+ * entry for their format) before persisting the result — this helper owns the
+ * structure walk, not the output-path accounting.
+ */
+function buildDonobuReport(resultsByTest) {
+    // Group tests by file path, then by test title.
+    // Multiple TestCase objects with the same (file, title) represent the same
+    // spec running under different Playwright projects.
+    const byFile = new Map();
+    for (const test of resultsByTest.keys()) {
+        const file = test.location.file;
+        if (!byFile.has(file)) {
+            byFile.set(file, new Map());
+        }
+        const byTitle = byFile.get(file);
+        if (!byTitle.has(test.title)) {
+            byTitle.set(test.title, []);
+        }
+        byTitle.get(test.title).push(test);
+    }
+    const suites = [];
+    for (const [file, titleMap] of byFile) {
+        const specs = [];
+        for (const [title, tests] of titleMap) {
+            const testEntries = tests.map((test) => {
+                const results = resultsByTest.get(test) ?? [];
+                return {
+                    annotations: test.annotations,
+                    projectName: getProjectName(test),
+                    // Signal "skipped" tests to the renderers the same way the JSON
+                    // reporter does.
+                    status: test.expectedStatus === 'skipped' ? 'skipped' : undefined,
+                    results: results.map((r) => ({
+                        status: r.status,
+                        duration: r.duration,
+                        retry: r.retry,
+                        startTime: r.startTime?.toISOString() ?? null,
+                        // Pass errors through; cast to any to preserve runtime-only
+                        // fields (snippet, actual, expected) that Playwright adds to
+                        // assertion errors.
+                        errors: r.errors.map((e) => ({
+                            message: e.message,
+                            stack: e.stack,
+                            snippet: e.snippet,
+                            actual: e.actual,
+                            expected: e.expected,
+                            location: e.location,
+                        })),
+                        // The markdown renderer reads `result.error` (singular) in addition
+                        // to `errors[]`; surface the first error there for back-compat.
+                        error: r.errors[0]
+                            ? {
+                                message: r.errors[0].message,
+                                stack: r.errors[0].stack,
+                                snippet: r.errors[0].snippet,
+                            }
+                            : undefined,
+                        attachments: r.attachments.map((a) => ({
+                            name: a.name,
+                            contentType: a.contentType,
+                            path: a.path ?? null,
+                            // Playwright Reporter API provides body as a Buffer; the HTML
+                            // generator expects a base64-encoded string (matching JSON format).
+                            body: a.body ? a.body.toString('base64') : undefined,
+                        })),
+                        // TestResult.stderr is already Array<{text?: string; buffer?: string}>,
+                        // which is the same shape parseStderrSteps expects.
+                        stderr: r.stderr,
+                    })),
+                };
+            });
+            specs.push({ title, tests: testEntries });
+        }
+        suites.push({ file, specs });
+    }
+    return { suites, metadata: {} };
+}
+/** Walk up the suite chain to find the enclosing project suite's title. */
+function getProjectName(test) {
+    let suite = test.parent;
+    while (suite) {
+        if (suite.type === 'project') {
+            return suite.title;
+        }
+        suite = suite.parent;
+    }
+    return '';
+}
+//# sourceMappingURL=buildReport.js.map

package/dist/esm/reporter/html.d.ts

@@ -24,6 +24,11 @@
  *     }],
  *   ],
  * ```
+ *
+ * During an auto-heal rerun (`DONOBU_AUTO_HEAL_ACTIVE=1`) the reporter skips
+ * HTML generation. It always serializes its `DonobuReport` to a state file in
+ * the Playwright JSON output directory so the orchestrator can pick it up,
+ * merge it with the initial run's state, and re-render the HTML once.
  */
 import type { FullResult, Reporter, TestCase, TestResult } from '@playwright/test/reporter';
 export interface DonobuHtmlReporterOptions {
@@ -44,14 +49,5 @@ export default class DonobuHtmlReporter implements Reporter {
     onTestEnd(test: TestCase, result: TestResult): void;
     onEnd(_result: FullResult): Promise<void>;
     printsToStdio(): boolean;
-    /**
-     * Reconstruct the JSON structure that `generateHtml` / `extractTests` expects,
-     * from the TestCase + TestResult objects collected during the run.
-     *
-     * Structure: suites (one per file) → specs (one per test title) → tests (one per project).
-     */
-    private buildJsonData;
-    /** Walk up the suite chain to find the enclosing project suite's title. */
-    private getProjectName;
 }
 //# sourceMappingURL=html.d.ts.map

package/dist/esm/reporter/html.js

@@ -25,11 +25,18 @@
  *     }],
  *   ],
  * ```
+ *
+ * During an auto-heal rerun (`DONOBU_AUTO_HEAL_ACTIVE=1`) the reporter skips
+ * HTML generation. It always serializes its `DonobuReport` to a state file in
+ * the Playwright JSON output directory so the orchestrator can pick it up,
+ * merge it with the initial run's state, and re-render the HTML once.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 const fs_1 = require("fs");
 const path_1 = require("path");
-const playwright_json_to_html_1 = require("../cli/playwright-json-to-html");
+const buildReport_1 = require("./buildReport");
+const render_1 = require("./render");
+const stateFile_1 = require("./stateFile");
 class DonobuHtmlReporter {
     constructor(options = {}) {
         /** Accumulates all TestResult objects per TestCase (one per retry attempt). */
@@ -46,117 +53,34 @@ class DonobuHtmlReporter {
         }
     }
     async onEnd(_result) {
-        // During an auto-heal rerun the CLI will regenerate the HTML from the
-        // merged report (which combines both runs and includes self-heal context).
-        // Generating here would overwrite the initial run's HTML with incomplete data.
-        if (process.env.DONOBU_AUTO_HEAL_ACTIVE === '1') {
-            return;
-        }
         const outputFile = (0, path_1.resolve)(this.options.outputFile ?? 'test-results/index.html');
         const outputDir = (0, path_1.dirname)(outputFile);
+        const autoHealActive = process.env.DONOBU_AUTO_HEAL_ACTIVE === '1';
+        const report = (0, buildReport_1.buildDonobuReport)(this.resultsByTest);
+        // Persist the full report + this reporter's output entry to the shared
+        // state file so other reporters and the auto-heal orchestrator can find
+        // it. When multiple reporters run in the same process this merges each
+        // entry in without clobbering siblings.
+        (0, stateFile_1.mergeStateFileEntry)(process.env.PLAYWRIGHT_JSON_OUTPUT_DIR, report, {
+            html: { outputFile },
+        });
+        // During an auto-heal rerun the orchestrator re-renders the HTML from the
+        // merged report; writing it here would overwrite the initial HTML with
+        // incomplete data.
+        if (autoHealActive) {
+            return;
+        }
         const triage = this.options.triageDir
-            ? (0, playwright_json_to_html_1.loadTriageData)((0, path_1.resolve)(this.options.triageDir))
+            ? (0, render_1.loadTriageData)((0, path_1.resolve)(this.options.triageDir))
             : { plans: [], evidence: [] };
-        const jsonData = this.buildJsonData();
-        const html = (0, playwright_json_to_html_1.generateHtml)(jsonData, triage, outputDir);
+        const html = (0, render_1.renderHtml)(report, triage, outputDir);
         (0, fs_1.mkdirSync)(outputDir, { recursive: true });
         (0, fs_1.writeFileSync)(outputFile, html, 'utf8');
         console.error(`Donobu report written to ${outputFile}`);
-        // Write a sidecar so the CLI can find and regenerate this report from the
-        // merged JSON after an auto-heal run completes.
-        const playwrightOutputDir = process.env.PLAYWRIGHT_JSON_OUTPUT_DIR;
-        if (playwrightOutputDir) {
-            const sidecarPath = (0, path_1.join)(playwrightOutputDir, '.donobu-html-reporter.json');
-            try {
-                (0, fs_1.writeFileSync)(sidecarPath, JSON.stringify({ outputFile }), 'utf8');
-            }
-            catch {
-                // Non-fatal — worst case the CLI falls back to no HTML regeneration.
-            }
-        }
     }
     printsToStdio() {
         return false;
     }
-    /**
-     * Reconstruct the JSON structure that `generateHtml` / `extractTests` expects,
-     * from the TestCase + TestResult objects collected during the run.
-     *
-     * Structure: suites (one per file) → specs (one per test title) → tests (one per project).
-     */
-    buildJsonData() {
-        // Group tests by file path, then by test title.
-        // Multiple TestCase objects with the same (file, title) represent the same
-        // spec running under different Playwright projects.
-        const byFile = new Map();
-        for (const test of this.resultsByTest.keys()) {
-            const file = test.location.file;
-            if (!byFile.has(file)) {
-                byFile.set(file, new Map());
-            }
-            const byTitle = byFile.get(file);
-            if (!byTitle.has(test.title)) {
-                byTitle.set(test.title, []);
-            }
-            byTitle.get(test.title).push(test);
-        }
-        const suites = [];
-        for (const [file, titleMap] of byFile) {
-            const specs = [];
-            for (const [title, tests] of titleMap) {
-                const testEntries = tests.map((test) => {
-                    const results = this.resultsByTest.get(test) ?? [];
-                    return {
-                        annotations: test.annotations,
-                        projectName: this.getProjectName(test),
-                        // Signal "skipped" tests to extractTests the same way the JSON reporter does.
-                        status: test.expectedStatus === 'skipped' ? 'skipped' : undefined,
-                        results: results.map((r) => ({
-                            status: r.status,
-                            duration: r.duration,
-                            retry: r.retry,
-                            startTime: r.startTime?.toISOString() ?? null,
-                            // Pass errors through; cast to any to preserve runtime-only fields
-                            // (snippet, actual, expected) that Playwright adds to assertion errors.
-                            errors: r.errors.map((e) => ({
-                                message: e.message,
-                                stack: e.stack,
-                                snippet: e.snippet,
-                                actual: e.actual,
-                                expected: e.expected,
-                                location: e.location,
-                            })),
-                            attachments: r.attachments.map((a) => ({
-                                name: a.name,
-                                contentType: a.contentType,
-                                path: a.path ?? null,
-                                // Playwright Reporter API provides body as a Buffer; the HTML
-                                // generator expects a base64-encoded string (matching JSON format).
-                                body: a.body ? a.body.toString('base64') : undefined,
-                            })),
-                            // TestResult.stderr is already Array<{text?: string; buffer?: string}>,
-                            // which is the same shape parseStderrSteps expects.
-                            stderr: r.stderr,
-                        })),
-                    };
-                });
-                specs.push({ title, tests: testEntries });
-            }
-            suites.push({ file, specs });
-        }
-        return { suites, metadata: {} };
-    }
-    /** Walk up the suite chain to find the enclosing project suite's title. */
-    getProjectName(test) {
-        let suite = test.parent;
-        while (suite) {
-            if (suite.type === 'project') {
-                return suite.title;
-            }
-            suite = suite.parent;
-        }
-        return '';
-    }
 }
 exports.default = DonobuHtmlReporter;
 //# sourceMappingURL=html.js.map