donobu 5.60.1 → 5.60.3

package/dist/reporter/reportWalk.d.ts

@@ -1,7 +1,8 @@
 /**
  * @fileoverview Shared helpers for walking a `DonobuReport` and classifying
- * the tests inside it. Used by every renderer (HTML, Markdown, Slack) so they
- * all agree on "what counts as self-healed" and how suites nest.
+ * the tests inside it. Used by every renderer (HTML, Markdown, Slack) and the
+ * merge step's stats so they all agree on "what counts as self-healed",
+ * "what counts as flaky", and how suites nest.
  */
 /**
  * Recursively collect all specs from a suite and its nested sub-suites. The
@@ -18,11 +19,20 @@ export declare function collectSpecs(suite: any): any[];
  */
 export declare function isSelfHealed(test: any): boolean;
 /** Normalized test-status the renderers use for counts and labels. */
-export type NormalizedStatus = 'passed' | 'failed' | 'healed' | 'timedOut' | 'skipped' | 'interrupted' | 'unknown';
+export type NormalizedStatus = 'passed' | 'flaky' | 'expectedFailure' | 'failed' | 'healed' | 'timedOut' | 'skipped' | 'interrupted' | 'unknown';
 /**
- * Derive the display status for a test. Prefers the final attempt's result
- * status; bumps to `'healed'` when the self-heal signal is present; falls
- * back to `'skipped'` when Playwright didn't emit a result.
+ * Derive the display status for a test from its full attempt history, not
+ * just the final attempt. The distinctions that matter:
+ *
+ * - A trailing `skipped` attempt must NOT erase an earlier real failure. An
+ *   auto-heal rerun in which the test skipped itself (e.g. a precondition
+ *   guard fired because a prerequisite test wasn't part of the rerun) appends
+ *   a skipped result after genuine failures — the failure stands.
+ * - A failed-then-passed history is `'flaky'` (Playwright's own term), not a
+ *   plain pass — unless the self-heal signal is present, which wins.
+ * - A test whose final attempt matches its `expectedStatus` (e.g.
+ *   `test.fail()` specs) is an `'expectedFailure'`: expected for stats and
+ *   exit-code purposes, but never presented as a pass.
  */
 export declare function statusOf(test: any): NormalizedStatus;
 //# sourceMappingURL=reportWalk.d.ts.map

package/dist/reporter/reportWalk.js

@@ -1,8 +1,9 @@
 "use strict";
 /**
  * @fileoverview Shared helpers for walking a `DonobuReport` and classifying
- * the tests inside it. Used by every renderer (HTML, Markdown, Slack) so they
- * all agree on "what counts as self-healed" and how suites nest.
+ * the tests inside it. Used by every renderer (HTML, Markdown, Slack) and the
+ * merge step's stats so they all agree on "what counts as self-healed",
+ * "what counts as flaky", and how suites nest.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.collectSpecs = collectSpecs;
@@ -32,28 +33,77 @@ function isSelfHealed(test) {
     const hasAnnotation = annotations.some((a) => a?.type === 'self-healed');
     return hasAnnotation || test?.donobuStatus === 'healed';
 }
+const FAILURE_RESULT_STATUSES = new Set(['failed', 'timedOut', 'interrupted']);
 /**
- * Derive the display status for a test. Prefers the final attempt's result
- * status; bumps to `'healed'` when the self-heal signal is present; falls
- * back to `'skipped'` when Playwright didn't emit a result.
+ * Derive the display status for a test from its full attempt history, not
+ * just the final attempt. The distinctions that matter:
+ *
+ * - A trailing `skipped` attempt must NOT erase an earlier real failure. An
+ *   auto-heal rerun in which the test skipped itself (e.g. a precondition
+ *   guard fired because a prerequisite test wasn't part of the rerun) appends
+ *   a skipped result after genuine failures — the failure stands.
+ * - A failed-then-passed history is `'flaky'` (Playwright's own term), not a
+ *   plain pass — unless the self-heal signal is present, which wins.
+ * - A test whose final attempt matches its `expectedStatus` (e.g.
+ *   `test.fail()` specs) is an `'expectedFailure'`: expected for stats and
+ *   exit-code purposes, but never presented as a pass.
  */
 function statusOf(test) {
-    const lastResult = test?.results?.at?.(-1);
-    if (test?.status === 'skipped' ||
-        (!lastResult && test?.status === undefined)) {
+    const results = test?.results ?? [];
+    const lastResult = results.at?.(-1);
+    // No attempts recorded — Playwright reports statically-skipped tests this
+    // way (and `test.status === 'skipped'` for runtime skips with no results).
+    if (!lastResult) {
         return 'skipped';
     }
     if (isSelfHealed(test)) {
         return 'healed';
     }
-    const status = lastResult?.status ?? 'unknown';
-    switch (status) {
-        case 'passed':
+    const expectedStatus = test?.expectedStatus;
+    // An attempt "succeeded" when it passed outright, or when it landed on the
+    // declared expected outcome of a `test.fail()`-style spec. The two are kept
+    // distinct end-to-end: expected failures count as expected for stats and
+    // exit codes, but are never presented as passes.
+    const successKindOf = (result) => {
+        if (result?.status === 'passed') {
+            return 'passed';
+        }
+        if (expectedStatus !== undefined &&
+            expectedStatus !== 'passed' &&
+            expectedStatus !== 'skipped' &&
+            result?.status === expectedStatus) {
+            return 'expectedFailure';
+        }
+        return null;
+    };
+    const hadRealFailure = results.some((r) => FAILURE_RESULT_STATUSES.has(r?.status) && successKindOf(r) === null);
+    // A success anywhere in the history. Within a single run retries stop at
+    // the first success, so a success followed by a failure/skip only arises
+    // from a merged auto-heal rerun — and the rerun is advisory: it may flip a
+    // failure to healed but never an initial success to failed/skipped.
+    const priorSuccess = results.map(successKindOf).find((kind) => kind !== null) ?? null;
+    // Skips are handled first: a runtime-skipped test has
+    // `expectedStatus: 'skipped'` and must stay skipped.
+    if (lastResult.status === 'skipped') {
+        // A skip can't launder an earlier failure; surface the worst attempt.
+        if (hadRealFailure) {
+            const failure = results.find((r) => FAILURE_RESULT_STATUSES.has(r?.status) && successKindOf(r) === null);
+            return failure.status;
+        }
+        return priorSuccess ?? 'skipped';
+    }
+    const lastSuccess = successKindOf(lastResult);
+    if (lastSuccess === 'passed') {
+        return hadRealFailure ? 'flaky' : 'passed';
+    }
+    if (lastSuccess === 'expectedFailure') {
+        return 'expectedFailure';
+    }
+    switch (lastResult.status) {
         case 'failed':
         case 'timedOut':
-        case 'skipped':
         case 'interrupted':
-            return status;
+            return priorSuccess ?? lastResult.status;
         default:
             return 'unknown';
     }

package/dist/utils/BrowserUtils.d.ts

@@ -71,10 +71,10 @@ export declare class BrowserUtils {
      * @throws {InvalidParamValueException} When an invalid browser type is specified.
      */
     static create(browserConfig: BrowserConfig, videoDir?: string, storageState?: BrowserStorageState, environ?: import("env-struct").Env<{
-        BROWSERBASE_API_KEY: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-        PROXY_SERVER: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-        PROXY_USERNAME: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-        PROXY_PASSWORD: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+        BROWSERBASE_API_KEY: import("zod").ZodOptional<import("zod").ZodString>;
+        PROXY_SERVER: import("zod").ZodOptional<import("zod").ZodString>;
+        PROXY_USERNAME: import("zod").ZodOptional<import("zod").ZodString>;
+        PROXY_PASSWORD: import("zod").ZodOptional<import("zod").ZodString>;
     }, {
         BROWSERBASE_API_KEY?: string | undefined;
         PROXY_SERVER?: string | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "donobu",
-  "version": "5.60.1",
+  "version": "5.60.3",
   "description": "Create browser automations with an LLM agent and replay them as Playwright scripts.",
   "main": "dist/main.js",
   "module": "dist/esm/main.js",
@@ -46,7 +46,7 @@
   "license": "UNLICENSED",
   "devDependencies": {
     "@eslint/js": "^10.0.1",
-    "@playwright/test": "^1.57.0",
+    "@playwright/test": "^1.60.0",
     "@types/better-sqlite3": "^7.6.13",
     "@types/express": "^5.0.6",
     "@types/node": "^22.10.5",
@@ -59,8 +59,8 @@
     "eslint-plugin-perfectionist": "^5.9.0",
     "eslint-plugin-simple-import-sort": "^12.1.1",
     "globals": "^16.0.0",
-    "playwright": "^1.57.0",
-    "playwright-core": "^1.57.0",
+    "playwright": "^1.60.0",
+    "playwright-core": "^1.60.0",
     "typescript-eslint": "^8.47.0",
     "vitest": "^4.0.17",
     "winston-transport": "^4.9.0"