@piwitests/reporter 0.12.0 → 0.13.0

package/dist/index.js

@@ -1,24 +1,4725 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extendPiwiFixtures = exports.piwiFixtures = exports.createGlobalSetup = exports.wrapConfig = exports.PiwiDashboardReporter = void 0;
-/**
- * Public API of `@piwitests/reporter`.
- *
- * This barrel is the *entire* external surface of the package — the reporter
- * class, the config helpers, the capture fixtures, and the public types.
- * Everything under `internal/` is deliberately NOT re-exported here; if it isn't
- * exported from this file, it isn't part of the supported API.
- */
-const reporter_js_1 = require("./public/reporter.js");
-Object.defineProperty(exports, "PiwiDashboardReporter", { enumerable: true, get: function () { return reporter_js_1.PiwiDashboardReporter; } });
-// ── Reporter (default + named export) ────────────────────────────────────────
-exports.default = reporter_js_1.PiwiDashboardReporter;
-// ── Config helpers ───────────────────────────────────────────────────────────
-var config_wrapper_js_1 = require("./public/config-wrapper.js");
-Object.defineProperty(exports, "wrapConfig", { enumerable: true, get: function () { return config_wrapper_js_1.wrapConfig; } });
-var global_setup_js_1 = require("./public/global-setup.js");
-Object.defineProperty(exports, "createGlobalSetup", { enumerable: true, get: function () { return global_setup_js_1.createGlobalSetup; } });
-// ── Capture fixtures ─────────────────────────────────────────────────────────
-var capture_fixtures_js_1 = require("./internal/capture/capture-fixtures.js");
-Object.defineProperty(exports, "piwiFixtures", { enumerable: true, get: function () { return capture_fixtures_js_1.piwiFixtures; } });
-Object.defineProperty(exports, "extendPiwiFixtures", { enumerable: true, get: function () { return capture_fixtures_js_1.extendPiwiFixtures; } });
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  PiwiDashboardReporter: () => PiwiDashboardReporter,
+  createGlobalSetup: () => createGlobalSetup,
+  default: () => index_default,
+  extendPiwiFixtures: () => extendPiwiFixtures,
+  piwiFixtures: () => piwiFixtures,
+  wrapConfig: () => wrapConfig
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/public/reporter.ts
+var path12 = __toESM(require("path"));
+
+// src/internal/config/env.ts
+var DEFAULTS = {
+  projectName: "default-project",
+  uploadTraces: true,
+  uploadReport: true,
+  liveFileUploads: true,
+  collectScmInfo: true,
+  collectCiInfo: true,
+  collectPerformanceMetrics: true,
+  captureLocators: true,
+  capturePageState: true,
+  streaming: true,
+  streamingBatchSize: 5,
+  streamingBatchDelay: 2e3,
+  username: null,
+  password: null,
+  apiKey: null,
+  verbose: false
+};
+var PIWI_ENV_KEYS = {
+  serverUrl: "PIWI_DASHBOARD_URL",
+  projectName: "PIWI_PROJECT_NAME",
+  verbose: "PIWI_VERBOSE",
+  apiKey: "PIWI_API_KEY",
+  username: "PIWI_USERNAME",
+  password: "PIWI_PASSWORD",
+  environment: "PIWI_ENVIRONMENT",
+  label: "PIWI_LABEL",
+  runLabel: "PIWI_RUN_LABEL",
+  streaming: "PIWI_STREAMING",
+  streamingBatchSize: "PIWI_STREAMING_BATCH_SIZE",
+  streamingBatchDelay: "PIWI_STREAMING_BATCH_DELAY",
+  liveFileUploads: "PIWI_LIVE_FILE_UPLOADS",
+  uploadTraces: "PIWI_UPLOAD_TRACES",
+  uploadReport: "PIWI_UPLOAD_REPORT",
+  captureLocators: "PIWI_CAPTURE_LOCATORS",
+  capturePageState: "PIWI_CAPTURE_PAGE_STATE",
+  inspectOnFailure: "PIWI_INSPECT_ON_FAIL",
+  pickLocatorOnFailure: "PIWI_PICK_LOCATOR_ON_FAIL"
+};
+function readBool(val) {
+  if (val === void 0) return void 0;
+  return val === "true";
+}
+var ENV_FALLBACK_SPECS = [
+  { option: "serverUrl", env: PIWI_ENV_KEYS.serverUrl, kind: "string" },
+  { option: "projectName", env: PIWI_ENV_KEYS.projectName, kind: "string" },
+  { option: "apiKey", env: PIWI_ENV_KEYS.apiKey, kind: "string" },
+  { option: "username", env: PIWI_ENV_KEYS.username, kind: "string" },
+  { option: "password", env: PIWI_ENV_KEYS.password, kind: "string" },
+  { option: "environment", env: PIWI_ENV_KEYS.environment, kind: "string" },
+  { option: "label", env: PIWI_ENV_KEYS.label, kind: "string" },
+  { option: "runLabel", env: PIWI_ENV_KEYS.runLabel, kind: "string" },
+  { option: "streaming", env: PIWI_ENV_KEYS.streaming, kind: "bool" },
+  { option: "streamingBatchSize", env: PIWI_ENV_KEYS.streamingBatchSize, kind: "number" },
+  { option: "streamingBatchDelay", env: PIWI_ENV_KEYS.streamingBatchDelay, kind: "number" },
+  { option: "liveFileUploads", env: PIWI_ENV_KEYS.liveFileUploads, kind: "bool" },
+  { option: "uploadTraces", env: PIWI_ENV_KEYS.uploadTraces, kind: "bool" },
+  { option: "uploadReport", env: PIWI_ENV_KEYS.uploadReport, kind: "bool" },
+  { option: "captureLocators", env: PIWI_ENV_KEYS.captureLocators, kind: "bool" },
+  { option: "capturePageState", env: PIWI_ENV_KEYS.capturePageState, kind: "bool" },
+  { option: "inspectOnFailure", env: PIWI_ENV_KEYS.inspectOnFailure, kind: "bool" },
+  { option: "pickLocatorOnFailure", env: PIWI_ENV_KEYS.pickLocatorOnFailure, kind: "bool" }
+];
+function resolveOptions(raw) {
+  const env = process.env;
+  const mergedRaw = { ...raw };
+  for (const spec of ENV_FALLBACK_SPECS) {
+    if (mergedRaw[spec.option] !== void 0) continue;
+    const value = env[spec.env];
+    if (spec.kind === "bool") {
+      if (value !== void 0) mergedRaw[spec.option] = readBool(value);
+    } else if (value) {
+      mergedRaw[spec.option] = spec.kind === "number" ? Number(value) : value;
+    }
+  }
+  const opts = { ...DEFAULTS, ...mergedRaw };
+  if (env[PIWI_ENV_KEYS.verbose] !== void 0) opts.verbose = env[PIWI_ENV_KEYS.verbose] === "true";
+  return opts;
+}
+function applyOptionsToEnv(options) {
+  const env = process.env;
+  if (options.serverUrl !== void 0) env[PIWI_ENV_KEYS.serverUrl] = options.serverUrl;
+  if (options.projectName !== void 0) env[PIWI_ENV_KEYS.projectName] = options.projectName;
+  if (options.verbose !== void 0) env[PIWI_ENV_KEYS.verbose] = String(options.verbose);
+  if (options.apiKey) env[PIWI_ENV_KEYS.apiKey] = options.apiKey;
+  if (options.username) env[PIWI_ENV_KEYS.username] = options.username;
+  if (options.password) env[PIWI_ENV_KEYS.password] = options.password;
+  if (options.environment) env[PIWI_ENV_KEYS.environment] = options.environment;
+  if (options.label) env[PIWI_ENV_KEYS.label] = options.label;
+  if (options.runLabel) env[PIWI_ENV_KEYS.runLabel] = options.runLabel;
+  if (options.captureLocators === false || options.collectPerformanceMetrics === false)
+    env[PIWI_ENV_KEYS.captureLocators] = "false";
+  else if (options.captureLocators === true) env[PIWI_ENV_KEYS.captureLocators] = "true";
+  if (options.capturePageState === false || options.collectPerformanceMetrics === false)
+    env[PIWI_ENV_KEYS.capturePageState] = "false";
+  else if (options.capturePageState === true) env[PIWI_ENV_KEYS.capturePageState] = "true";
+  if (options.inspectOnFailure !== void 0) env[PIWI_ENV_KEYS.inspectOnFailure] = String(options.inspectOnFailure);
+  if (options.pickLocatorOnFailure !== void 0)
+    env[PIWI_ENV_KEYS.pickLocatorOnFailure] = String(options.pickLocatorOnFailure);
+}
+
+// src/internal/transport/http-client.ts
+var https = __toESM(require("https"));
+var http = __toESM(require("http"));
+var import_node_url = require("url");
+var import_form_data = __toESM(require("form-data"));
+
+// src/internal/support/logger.ts
+var Logger = class {
+  constructor(verbose = false) {
+    this.verbose = verbose;
+    this.prefix = "[Piwi Dashboard] ";
+  }
+  info(msg) {
+    console.log(this.prefix + msg);
+  }
+  warn(msg) {
+    console.warn(this.prefix + msg);
+  }
+  error(msg) {
+    console.error(this.prefix + msg);
+  }
+  debug(msg) {
+    if (this.verbose) console.log(this.prefix + msg);
+  }
+  debugError(msg) {
+    if (this.verbose) console.error(this.prefix + msg);
+  }
+};
+
+// src/internal/transport/http-client.ts
+function parseErrorMessage(text) {
+  try {
+    const parsed = JSON.parse(text);
+    const message = parsed?.message;
+    return typeof message === "string" ? message : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var HttpError = class extends Error {
+  constructor(status, message = `Request failed with status ${status}`) {
+    super(message);
+    this.status = status;
+    this.name = "HttpError";
+  }
+};
+var HttpClient = class {
+  /**
+   * @param serverUrl Base URL of the Piwi Dashboard server (e.g. `http://localhost:3000`).
+   * @param logger    Prefixed logger for verbose diagnostics.
+   * @param timeout   Socket inactivity timeout in ms (default 30s). A hung
+   *                  server now fails fast instead of stalling the reporter.
+   */
+  constructor(serverUrl, logger = new Logger(), timeout = 3e4) {
+    this.serverUrl = serverUrl;
+    this.logger = logger;
+    this.timeout = timeout;
+  }
+  /** Base URL of the Piwi Dashboard server this client talks to (used to print run links). */
+  get baseUrl() {
+    return this.serverUrl;
+  }
+  /**
+   * Resolve an auth credential: prefer `apiKey`, fall back to `username`/`password` login,
+   * or return `null` when neither is configured.
+   */
+  async resolveAuth(options) {
+    if (options.apiKey) return options.apiKey;
+    if (options.username && options.password) {
+      this.logger.info(`Authenticating as ${options.username}...`);
+      return this.login(options.username, options.password);
+    }
+    return null;
+  }
+  /** Authenticate with username/password and return the session cookie string */
+  async login(username, password) {
+    const body = JSON.stringify({ username, password });
+    const res = await this.request("POST", "/api/auth/login", {
+      headers: {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(body)
+      },
+      body
+    });
+    if (res.status < 200 || res.status >= 300) {
+      this.logger.debugError(`Login response: ${res.text}`);
+      throw new HttpError(res.status, `Login failed with status ${res.status}`);
+    }
+    const setCookie = res.headers["set-cookie"];
+    if (!setCookie || setCookie.length === 0) {
+      throw new Error("Login succeeded but no session cookie was returned");
+    }
+    const cookie = setCookie.map((c) => c.split(";")[0]).join("; ");
+    this.logger.debug("Logged in successfully");
+    return cookie;
+  }
+  /** Send a JSON POST request. `auth` can be an API key (prefix `pd_`) or a session cookie string. */
+  async postJSON(pathname, payload, auth) {
+    const body = JSON.stringify(payload);
+    const res = await this.request("POST", pathname, {
+      headers: {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(body)
+      },
+      body,
+      auth
+    });
+    if (res.status < 200 || res.status >= 300) {
+      this.logger.debugError(`Response: ${res.text}`);
+      throw new HttpError(res.status);
+    }
+    try {
+      return JSON.parse(res.text);
+    } catch {
+      return {};
+    }
+  }
+  /** Send a multipart form-data POST request. Used for report and trace uploads. */
+  async postFormData(pathname, form, auth) {
+    const headers = form.getHeaders();
+    const res = await this.request("POST", pathname, { headers, form, auth });
+    if (res.status < 200 || res.status >= 300) {
+      this.logger.debugError(`Response: ${res.text}`);
+      const detail = parseErrorMessage(res.text);
+      throw new HttpError(
+        res.status,
+        detail ? `Request failed with status ${res.status}: ${detail}` : `Request failed with status ${res.status}`
+      );
+    }
+    try {
+      return JSON.parse(res.text);
+    } catch {
+      return {};
+    }
+  }
+  /** Unified request core: transport, headers, auth, response accumulation, timeout. */
+  request(method, pathname, opts) {
+    return new Promise((resolve5, reject) => {
+      const url = new import_node_url.URL(pathname, this.serverUrl);
+      const transport = url.protocol === "https:" ? https : http;
+      const headers = { ...opts.headers };
+      this.applyAuth(headers, opts.auth);
+      const req = transport.request(
+        {
+          hostname: url.hostname,
+          port: url.port || (url.protocol === "https:" ? 443 : 80),
+          path: url.pathname,
+          method,
+          headers
+        },
+        (res) => {
+          let data = "";
+          res.on("data", (chunk) => {
+            data += chunk;
+          });
+          res.on("end", () => {
+            resolve5({ status: res.statusCode ?? 0, text: data, headers: res.headers });
+          });
+        }
+      );
+      req.on("error", reject);
+      req.setTimeout(this.timeout, () => {
+        req.destroy(new Error(`Request to ${pathname} timed out after ${this.timeout}ms`));
+      });
+      if (opts.form) {
+        opts.form.pipe(req);
+      } else if (opts.body !== void 0) {
+        req.write(opts.body);
+        req.end();
+      } else {
+        req.end();
+      }
+    });
+  }
+  applyAuth(headers, auth) {
+    if (!auth) return;
+    if (auth.startsWith("pd_")) {
+      headers["Authorization"] = `Bearer ${auth}`;
+    } else {
+      headers["Cookie"] = auth;
+    }
+  }
+};
+
+// src/internal/submit/uploader.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var import_form_data2 = __toESM(require("form-data"));
+
+// src/internal/submit/serializer.ts
+function resolveOverallStatus(result, counters) {
+  const STATUS_MAP = {
+    passed: "passed",
+    failed: "failed",
+    timedout: "failed",
+    interrupted: "failed"
+  };
+  if (result?.status) return STATUS_MAP[result.status] ?? "failed";
+  if (counters.failedTests === 0 && counters.timedOutTests === 0 && counters.totalTests > 0) return "passed";
+  return "failed";
+}
+function toWireTestCase(tc) {
+  const { type, ...rest } = tc;
+  return {
+    type,
+    title: rest.title,
+    location: rest.location,
+    status: rest.status,
+    duration: rest.duration,
+    error: rest.error,
+    retries: rest.retries,
+    workerIndex: rest.workerIndex ?? null,
+    shardIndex: rest.shardIndex ?? null,
+    startedAt: rest.startedAt ?? null,
+    steps: rest.performanceMetrics?.steps || null,
+    stepEvents: rest.stepEvents || null,
+    slowestStep: rest.performanceMetrics?.slowestStep?.title || null,
+    slowestStepDuration: rest.performanceMetrics?.slowestStep?.duration || null,
+    wastedTimeMs: rest.performanceMetrics?.waitTotalDuration ?? null,
+    networkRequests: rest.networkRequests || null,
+    webVitals: rest.webVitals || null,
+    pageState: rest.pageState || null,
+    consoleLogs: rest.consoleLogs || null,
+    ariaSnapshot: rest.ariaSnapshot || null,
+    testSource: rest.testSource || null,
+    testSourceFrames: rest.testSourceFrames || null,
+    browser: rest.browser || null,
+    suitePath: rest.suitePath ?? null,
+    suiteConfig: rest.suiteConfig ?? null,
+    testAnnotations: rest.testAnnotations ?? null,
+    locatorSnapshots: rest.locatorSnapshots || null
+  };
+}
+function serializeRun(payload, opts) {
+  const body = {
+    projectName: payload.projectName,
+    projectDescription: payload.projectDescription,
+    status: payload.status,
+    startTime: payload.startTime,
+    duration: payload.duration,
+    totalTests: payload.totalTests,
+    passedTests: payload.passedTests,
+    failedTests: payload.failedTests,
+    timedOutTests: payload.timedOutTests ?? 0,
+    skippedTests: payload.skippedTests,
+    didNotRunTests: payload.didNotRunTests ?? 0,
+    environment: payload.environment ?? null,
+    label: payload.label ?? null,
+    metadata: payload.metadata,
+    instanceId: payload.instanceId,
+    playwrightVersion: payload.playwrightVersion,
+    reporterVersion: payload.reporterVersion,
+    shardIndex: payload.shardIndex,
+    shardTotal: payload.shardTotal,
+    isFullRun: payload.isFullRun ?? true,
+    filterDetails: payload.filterDetails ?? null
+  };
+  if (opts.includeTestCases) {
+    body.testCases = payload.testCases.map((tc) => toWireTestCase(tc));
+  }
+  return body;
+}
+
+// src/internal/support/run-url.ts
+function runUrl(serverUrl, runId) {
+  return `${serverUrl.replace(/\/+$/, "")}/test-runs/${runId}`;
+}
+
+// src/internal/submit/uploader.ts
+var Uploader = class {
+  /**
+   * @param httpClient  HTTP client for server communication.
+   * @param fileHandler File discovery and compression helper.
+   * @param logger      Prefixed logger.
+   */
+  constructor(httpClient, fileHandler, logger = new Logger()) {
+    this.httpClient = httpClient;
+    this.fileHandler = fileHandler;
+    this.logger = logger;
+  }
+  /** Submit test results as a plain JSON payload (no file attachments) */
+  async uploadJSON(payload, auth) {
+    const response = await this.httpClient.postJSON(
+      "/api/test-runs/submit",
+      serializeRun(payload, { includeTestCases: true }),
+      auth
+    );
+    this.logger.info(`Successfully uploaded test results`);
+    if (response.testRunId) {
+      this.logger.info(`Test Run ID: ${response.testRunId}, Project ID: ${response.projectId}`);
+      this.logger.info(`View run: ${runUrl(this.httpClient.baseUrl, response.testRunId)}`);
+    }
+    return response;
+  }
+  /** Submit test results as a multipart form with trace files and compressed report directories */
+  async uploadWithFiles(payload, reportOptions, auth) {
+    const form = new import_form_data2.default();
+    form.append("projectName", payload.projectName);
+    form.append("testRun", JSON.stringify(serializeRun(payload, { includeTestCases: false })));
+    form.append("testCases", JSON.stringify(payload.testCases.map((tc) => toWireTestCase(tc))));
+    await this.appendReportsToForm(form, reportOptions.reports, reportOptions.uploadReport);
+    await this.appendFilesToForm(form, payload.testCases, reportOptions.uploadTraces);
+    const response = await this.httpClient.postFormData("/api/test-runs/upload", form, auth);
+    this.logger.info(`Successfully uploaded test results with files`);
+    if (response.testRunId) {
+      this.logger.info(`Test Run ID: ${response.testRunId}, Project ID: ${response.projectId}`);
+      this.logger.info(`View run: ${runUrl(this.httpClient.baseUrl, response.testRunId)}`);
+    }
+    if (response.reports) {
+      for (const r of response.reports) this.logger.info(`${r.label}: ${r.path}`);
+    }
+    return response;
+  }
+  /** Upload report files for an already-submitted streaming run */
+  async uploadReportsForStreamingRun(projectName, runId, reportOptions, startTime, auth) {
+    const form = new import_form_data2.default();
+    form.append("testRunId", String(runId));
+    form.append("projectName", projectName);
+    form.append(
+      "testRun",
+      JSON.stringify({
+        status: "already-submitted",
+        startTime,
+        duration: 0,
+        totalTests: 0,
+        passedTests: 0,
+        failedTests: 0,
+        skippedTests: 0,
+        metadata: {}
+      })
+    );
+    form.append("testCases", JSON.stringify([]));
+    await this.appendReportsToForm(form, reportOptions.reports, reportOptions.uploadReport);
+    const response = await this.httpClient.postFormData("/api/test-runs/upload", form, auth);
+    this.logger.info(`Successfully uploaded reports for streaming run #${runId}`);
+    if (response.reports) {
+      for (const r of response.reports) this.logger.info(`${r.label}: ${r.path}`);
+    }
+  }
+  /**
+   * Upload one test case's trace and attachments for a streaming run.
+   * The matching `complete` event must have been flushed to the server first.
+   * Returns `false` when the case has no files to upload.
+   */
+  async uploadCaseFiles(projectName, runId, streamToken, testCase, uploadTraces, auth) {
+    const attachments = this.fileHandler.findAllAttachments(testCase);
+    let traceInfo = null;
+    if (uploadTraces) {
+      traceInfo = await this.fileHandler.computeSingleTraceHash(testCase);
+    }
+    if (!traceInfo && attachments.length === 0) return false;
+    let missingHashes = null;
+    if (traceInfo) {
+      missingHashes = await this.fileHandler.checkMissingTraces(
+        this.httpClient,
+        projectName,
+        /* @__PURE__ */ new Map([[0, traceInfo]]),
+        auth
+      );
+    }
+    const buildForm = (includeTraceFile2) => {
+      const form = new import_form_data2.default();
+      form.append("streamToken", streamToken);
+      form.append(
+        "testCase",
+        JSON.stringify({
+          title: testCase.title,
+          location: testCase.location,
+          retries: testCase.retries ?? 0,
+          suitePath: testCase.suitePath ?? null
+        })
+      );
+      if (traceInfo) {
+        form.append("trace_hash", traceInfo.hash);
+        if (includeTraceFile2) {
+          form.append("trace", fs.createReadStream(traceInfo.tracePath), {
+            filename: path.basename(traceInfo.tracePath)
+          });
+        }
+      }
+      if (attachments.length > 0) {
+        form.append(
+          "attach_meta",
+          JSON.stringify(
+            attachments.map((a) => ({ name: a.name, contentType: a.contentType, originalName: a.originalName }))
+          )
+        );
+        for (const a of attachments) {
+          form.append("attach_file", fs.createReadStream(a.path), { filename: a.originalName });
+        }
+      }
+      return form;
+    };
+    const includeTraceFile = !traceInfo || !missingHashes || missingHashes.has(traceInfo.hash);
+    try {
+      await this.httpClient.postFormData(`/api/test-runs/${runId}/case-files`, buildForm(includeTraceFile), auth);
+    } catch (error) {
+      if (traceInfo && !includeTraceFile && error instanceof HttpError && error.status === 422) {
+        await this.httpClient.postFormData(`/api/test-runs/${runId}/case-files`, buildForm(true), auth);
+      } else {
+        throw error;
+      }
+    }
+    this.logger.debug(
+      `Uploaded files for "${testCase.title}" (trace: ${traceInfo ? "yes" : "no"}, attachments: ${attachments.length})`
+    );
+    return true;
+  }
+  async appendReportsToForm(form, reports, uploadReport) {
+    const list = reports ? [...reports] : [];
+    if (uploadReport && !list.some((r) => r.type === "html")) list.push({ type: "html" });
+    for (const cfg of list) {
+      const defaultDir = this.fileHandler.getDefaultReportDirs()[cfg.type] || cfg.type + "-report";
+      const reportDir = cfg.dir ? this.fileHandler.findReportDirectory(cfg.dir) : cfg.type === "html" ? this.fileHandler.findHTMLReportDirectory() : this.fileHandler.findReportDirectory(defaultDir);
+      if (!reportDir) {
+        this.logger.debug(`No report directory found for type '${cfg.type}'`);
+        continue;
+      }
+      const compressed = await this.fileHandler.compressReportDirectory(reportDir);
+      if (compressed) {
+        form.append(`report_${cfg.type}`, compressed, { filename: `${cfg.type}-report.gz` });
+        if (cfg.label) form.append(`report_label_${cfg.type}`, cfg.label);
+      }
+    }
+  }
+  async appendFilesToForm(form, testCases, uploadTraces) {
+    let attachmentCount = 0;
+    for (const [i, tc] of testCases.entries()) {
+      const attachments = this.fileHandler.findAllAttachments(tc);
+      if (attachments.length === 0) continue;
+      form.append(
+        `attach_meta_${i}`,
+        JSON.stringify(
+          attachments.map((a) => ({
+            name: a.name,
+            contentType: a.contentType,
+            originalName: a.originalName
+          }))
+        )
+      );
+      for (const a of attachments) {
+        form.append(`attach_file_${i}`, fs.createReadStream(a.path), { filename: a.originalName });
+        attachmentCount++;
+      }
+    }
+    if (attachmentCount > 0) this.logger.info(`Uploading ${attachmentCount} non-trace attachments`);
+    if (!uploadTraces) return;
+    let traceCount = 0;
+    for (const [i, tc] of testCases.entries()) {
+      for (const tp of this.fileHandler.findTraceFiles(tc)) {
+        if (fs.existsSync(tp)) {
+          form.append(`trace_${i}`, fs.createReadStream(tp), { filename: path.basename(tp) });
+          traceCount++;
+        }
+      }
+    }
+    this.logger.info(`Found ${traceCount} trace files`);
+  }
+};
+
+// src/internal/streaming/stream-buffer.ts
+var path2 = __toESM(require("path"));
+var os2 = __toESM(require("os"));
+var fs2 = __toESM(require("fs"));
+
+// src/internal/support/instance-id.ts
+var crypto = __toESM(require("crypto"));
+var os = __toESM(require("os"));
+function hashForProject(projectName) {
+  return crypto.createHash("sha1").update(projectName).digest("hex").slice(0, 16);
+}
+function computeInstanceId(projectName, runLabel) {
+  const seed = runLabel ? `${projectName}|${runLabel}` : `${os.hostname()}|${projectName}`;
+  return crypto.createHash("sha256").update(seed).digest("hex").slice(0, 16);
+}
+
+// src/internal/streaming/stream-buffer.ts
+var StreamBuffer = class {
+  constructor(projectName) {
+    this.filePath = path2.join(os2.tmpdir(), `piwi-dashboard-stream-${hashForProject(projectName)}.jsonl`);
+  }
+  /** Append one or more events to the on-disk buffer */
+  append(events) {
+    if (events.length === 0) return;
+    try {
+      const lines = events.map((e) => JSON.stringify(e) + "\n").join("");
+      fs2.appendFileSync(this.filePath, lines, "utf8");
+    } catch {
+    }
+  }
+  /** Load all buffered events from disk, clearing the file */
+  load() {
+    try {
+      if (fs2.existsSync(this.filePath)) {
+        const content = fs2.readFileSync(this.filePath, "utf8");
+        return content.split("\n").filter(Boolean).map((line) => JSON.parse(line));
+      }
+    } catch {
+    }
+    return [];
+  }
+  /** Delete the buffer file from disk */
+  clear() {
+    try {
+      if (fs2.existsSync(this.filePath)) fs2.unlinkSync(this.filePath);
+    } catch {
+    }
+  }
+  /** Remove the buffer file if it is older than `maxAgeMs` (default 2 hours). Used on startup to discard orphaned data. */
+  clearStale(maxAgeMs = 72e5) {
+    try {
+      if (fs2.existsSync(this.filePath)) {
+        const stats = fs2.statSync(this.filePath);
+        if (Date.now() - stats.mtimeMs > maxAgeMs) {
+          fs2.unlinkSync(this.filePath);
+        }
+      }
+    } catch {
+    }
+  }
+};
+
+// src/internal/streaming/crash-recovery.ts
+var path3 = __toESM(require("path"));
+
+// src/internal/support/errors.ts
+function errorMessage(error) {
+  if (error instanceof Error) return error.message;
+  return String(error);
+}
+
+// src/internal/streaming/crash-recovery.ts
+var os3 = __toESM(require("os"));
+var fs3 = __toESM(require("fs"));
+var CrashRecovery = class {
+  /**
+   * @param projectName Used to derive the temp-file name so recovery data is project-scoped.
+   * @param logger      Prefixed logger.
+   */
+  constructor(projectName, logger = new Logger()) {
+    this.logger = logger;
+    this.filePath = path3.join(os3.tmpdir(), `piwi-dashboard-recovery-${hashForProject(projectName)}.json`);
+  }
+  /** Serialise the payload to a temp file for later retry */
+  save(data) {
+    try {
+      fs3.writeFileSync(this.filePath, JSON.stringify(data), "utf8");
+      this.logger.info("Saved recovery data for later upload");
+    } catch (error) {
+      this.logger.error(`Failed to save recovery data: ${errorMessage(error)}`);
+    }
+  }
+  /** Read the saved payload from disk, or return `null` if none exists */
+  load() {
+    try {
+      if (fs3.existsSync(this.filePath)) return JSON.parse(fs3.readFileSync(this.filePath, "utf8"));
+    } catch {
+    }
+    return null;
+  }
+  /** Delete the recovery file from disk */
+  clear() {
+    try {
+      if (fs3.existsSync(this.filePath)) fs3.unlinkSync(this.filePath);
+    } catch {
+    }
+  }
+  /** Attempt to submit a previously saved payload. Clears the recovery file on success. */
+  async tryUpload(httpClient, auth) {
+    const data = this.load();
+    if (!data) return;
+    this.logger.info("Found saved test data from a previous run, uploading...");
+    delete data.instanceId;
+    try {
+      await httpClient.postJSON("/api/test-runs/submit", data, auth);
+      this.logger.info("Successfully uploaded saved test data");
+      this.clear();
+    } catch (error) {
+      this.logger.warn(`Could not upload saved test data: ${errorMessage(error)}`);
+    }
+  }
+};
+
+// src/internal/files/file-handler.ts
+var fs5 = __toESM(require("fs"));
+var path5 = __toESM(require("path"));
+var crypto2 = __toESM(require("crypto"));
+
+// src/internal/files/compression.ts
+var fs4 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
+var zlib = __toESM(require("zlib"));
+var import_node_util = require("util");
+var gzipAsync = (0, import_node_util.promisify)(zlib.gzip);
+async function compressDirectory(sourceDir) {
+  const files = [];
+  function collect(dir, baseDir = "") {
+    for (const entry of fs4.readdirSync(dir, { withFileTypes: true })) {
+      const full = path4.join(dir, entry.name);
+      const rel = path4.join(baseDir, entry.name);
+      if (entry.isDirectory()) collect(full, rel);
+      else if (entry.isFile()) files.push({ path: rel, content: fs4.readFileSync(full) });
+    }
+  }
+  collect(sourceDir);
+  const parts = [];
+  for (const f of files) {
+    const pb = Buffer.from(f.path, "utf8");
+    const plb = Buffer.allocUnsafe(4);
+    plb.writeUInt32LE(pb.length, 0);
+    const clb = Buffer.allocUnsafe(4);
+    clb.writeUInt32LE(f.content.length, 0);
+    parts.push(plb, pb, clb, f.content);
+  }
+  return await gzipAsync(Buffer.concat(parts), { level: 5 });
+}
+
+// src/internal/capture/attachments.ts
+var ATTACHMENT_NAMES = {
+  locators: "piwi-locators",
+  ariaSnapshot: "piwi-aria-snapshot",
+  console: "piwi-console",
+  network: "piwi-network",
+  webVitals: "piwi-web-vitals",
+  locatorSuggestion: "piwi-locator-suggestion",
+  pageState: "piwi-page-state",
+  userPick: "piwi-user-pick"
+};
+var INTERNAL_ATTACHMENT_NAMES = new Set(Object.values(ATTACHMENT_NAMES));
+var LOCATOR_SUGGESTION_ANNOTATION = ATTACHMENT_NAMES.locatorSuggestion;
+var USER_PICK_ANNOTATION = ATTACHMENT_NAMES.userPick;
+
+// src/internal/files/file-handler.ts
+var FileHandler = class {
+  constructor(logger = new Logger()) {
+    this.logger = logger;
+  }
+  /** Locate a Playwright HTML report directory containing `index.html`. Optionally override the search path. */
+  findHTMLReportDirectory(customDir) {
+    const possibleDirs = customDir ? [customDir, path5.join(process.cwd(), customDir)] : ["playwright-report", "./playwright-report", path5.join(process.cwd(), "playwright-report")];
+    for (const reportDir of possibleDirs) {
+      if (fs5.existsSync(reportDir) && fs5.statSync(reportDir).isDirectory()) {
+        if (fs5.existsSync(path5.join(reportDir, "index.html"))) return reportDir;
+      }
+    }
+    return null;
+  }
+  /** Check if `dir` exists and is a directory; also checks `path.join(process.cwd(), dir)` */
+  findReportDirectory(dir) {
+    const candidates = [dir, path5.join(process.cwd(), dir)];
+    for (const candidate of candidates) {
+      if (fs5.existsSync(candidate) && fs5.statSync(candidate).isDirectory()) return candidate;
+    }
+    return null;
+  }
+  /** Gzip-compress an entire report directory into a single buffer. Returns `null` on failure. */
+  async compressReportDirectory(reportDir) {
+    try {
+      return await compressDirectory(reportDir) || null;
+    } catch (error) {
+      this.logger.warn(`Failed to compress report directory ${reportDir}: ${errorMessage(error)}`);
+      return null;
+    }
+  }
+  /** Return resolved paths for all trace attachments on a test case */
+  findTraceFiles(testCase) {
+    const set = /* @__PURE__ */ new Set();
+    if (testCase.attachments) {
+      for (const a of testCase.attachments) {
+        if (a.name === "trace" && a.path) set.add(path5.resolve(a.path));
+      }
+    }
+    return Array.from(set);
+  }
+  /** Return all non-trace, non-internal attachments from a test case. Skips `trace` and `piwi-*` attachments. */
+  findAllAttachments(testCase) {
+    const result = [];
+    if (testCase.attachments) {
+      for (const a of testCase.attachments) {
+        if (a.name === "trace") continue;
+        if (a.name && INTERNAL_ATTACHMENT_NAMES.has(a.name)) continue;
+        if (a.path && fs5.existsSync(a.path)) {
+          result.push({
+            name: a.name || "attachment",
+            path: path5.resolve(a.path),
+            contentType: a.contentType || "application/octet-stream",
+            originalName: path5.basename(a.path)
+          });
+        }
+      }
+    }
+    return result;
+  }
+  /** Mapping of well-known report type names to their default output directories */
+  getDefaultReportDirs() {
+    return {
+      html: "playwright-report",
+      monocart: "monocart-report",
+      allure: "allure-report",
+      blob: "blob-report"
+    };
+  }
+  /** Parse Piwi-internal attachment bodies (`piwi-network`, `piwi-web-vitals`, `piwi-console`, `piwi-aria-snapshot`) into structured fields on the test case */
+  parsePerformanceAttachments(testCase, attachments) {
+    const find = (name) => attachments.find((a) => a.name === name);
+    const net = find(ATTACHMENT_NAMES.network);
+    if (net?.body) {
+      try {
+        testCase.networkRequests = JSON.parse(net.body.toString());
+      } catch {
+      }
+    }
+    const vitals = find(ATTACHMENT_NAMES.webVitals);
+    if (vitals?.body) {
+      try {
+        testCase.webVitals = JSON.parse(vitals.body.toString());
+      } catch {
+      }
+    }
+    const consoleLog = find(ATTACHMENT_NAMES.console);
+    if (consoleLog?.body) {
+      try {
+        testCase.consoleLogs = JSON.parse(consoleLog.body.toString());
+      } catch {
+      }
+    }
+    const aria = find(ATTACHMENT_NAMES.ariaSnapshot);
+    if (aria?.body) testCase.ariaSnapshot = aria.body.toString();
+    const pageState = find(ATTACHMENT_NAMES.pageState);
+    if (pageState?.body) {
+      try {
+        testCase.pageState = JSON.parse(pageState.body.toString());
+      } catch {
+      }
+    }
+  }
+  /** Compute SHA-256 hash and size for a single test case's trace file. Returns `null` when the case has no trace on disk. */
+  async computeSingleTraceHash(testCase) {
+    const tracePaths = this.findTraceFiles(testCase);
+    let lastPath = null;
+    for (const tp of tracePaths) {
+      if (fs5.existsSync(tp)) lastPath = tp;
+    }
+    if (!lastPath) return null;
+    const hash = crypto2.createHash("sha256");
+    await new Promise((resolve5, reject) => {
+      fs5.createReadStream(lastPath).on("data", (chunk) => hash.update(chunk)).on("end", resolve5).on("error", reject);
+    });
+    return {
+      tracePath: lastPath,
+      hash: hash.digest("hex"),
+      size: fs5.statSync(lastPath).size
+    };
+  }
+  /** Ask the server which trace hashes it already has, returning the set of hashes that are missing */
+  async checkMissingTraces(httpClient, projectName, traceHashMap, auth) {
+    if (traceHashMap.size === 0) return /* @__PURE__ */ new Set();
+    const hashes = [...traceHashMap.values()].map((h) => h.hash);
+    try {
+      const response = await httpClient.postJSON("/api/traces/check", { projectName, hashes }, auth);
+      const missing = Array.isArray(response.missing) ? response.missing : hashes;
+      return new Set(missing);
+    } catch {
+      return new Set(hashes);
+    }
+  }
+};
+
+// src/internal/collect/metadata-collector.ts
+var import_node_child_process = require("child_process");
+var MetadataCollector = class {
+  constructor(logger = new Logger()) {
+    this.logger = logger;
+  }
+  /** Collect all available metadata from the environment, config, and suite */
+  collect(config, suite, options) {
+    const metadata = {};
+    if (options.projectDescription) metadata.projectDescription = options.projectDescription;
+    if (options.relatedIssue) metadata.relatedIssue = options.relatedIssue;
+    if (options.ciInfo) metadata.ciInfo = options.ciInfo;
+    if (options.tags && Array.isArray(options.tags)) metadata.tags = options.tags;
+    if (options.customData) metadata.customData = options.customData;
+    if (options.collectScmInfo) {
+      const scm = this.collectScmInfo(options);
+      if (scm) metadata.scm = scm;
+    }
+    if (options.collectCiInfo) {
+      const ci = this.collectCiInfo();
+      if (ci) metadata.ci = ci;
+    }
+    const htmlMeta = this.extractPlaywrightConfigMetadata(config);
+    if (htmlMeta && Object.keys(htmlMeta).length > 0) metadata.htmlReport = htmlMeta;
+    if (config.metadata) metadata.playwrightConfig = config.metadata;
+    if (suite?.allTests) {
+      const all = suite.allTests();
+      if (all.length > 0) {
+        const first = all[0];
+        if (first?.parent) {
+          const proj = first.parent.project();
+          if (proj?.metadata) metadata.playwrightProject = proj.metadata;
+        }
+      }
+    }
+    return metadata;
+  }
+  /** Walk the test's parent hierarchy to extract the resolved browser/project configuration */
+  getBrowserConfig(test) {
+    try {
+      let suite = test.parent;
+      let depth = 0;
+      while (suite && depth < 20) {
+        depth++;
+        const project = suite.project?.();
+        if (project) {
+          const use = project.use ?? {};
+          const config = { projectName: project.name };
+          if (use.browserName) config.browserName = use.browserName;
+          if (use.channel) config.channel = use.channel;
+          if (use.viewport) config.viewport = { width: use.viewport.width, height: use.viewport.height };
+          if (use.deviceScaleFactor != null) config.deviceScaleFactor = use.deviceScaleFactor;
+          if (use.isMobile != null) config.isMobile = use.isMobile;
+          if (use.hasTouch != null) config.hasTouch = use.hasTouch;
+          if (use.locale) config.locale = use.locale;
+          if (use.timezoneId) config.timezoneId = use.timezoneId;
+          if (use.geolocation) {
+            config.geolocation = {
+              longitude: use.geolocation.longitude,
+              latitude: use.geolocation.latitude,
+              ...use.geolocation.accuracy != null && { accuracy: use.geolocation.accuracy }
+            };
+          }
+          if (use.colorScheme) config.colorScheme = use.colorScheme;
+          if (use.reducedMotion) config.reducedMotion = use.reducedMotion;
+          if (use.forcedColors) config.forcedColors = use.forcedColors;
+          if (use.offline) config.offline = use.offline;
+          if (use.bypassCSP) config.bypassCSP = use.bypassCSP;
+          if (use.javaScriptEnabled === false) config.javaScriptEnabled = false;
+          if (use.serviceWorkers) config.serviceWorkers = use.serviceWorkers;
+          if (use.userAgent) config.userAgent = use.userAgent;
+          return config;
+        }
+        suite = suite.parent;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Walk the test's parent `describe` suites to extract the suite path (titles)
+   * and per-level config (parallel mode + annotations). Reaches into Playwright
+   * suite internals (`_parallelMode`, `_annotations`) — kept here next to
+   * `getBrowserConfig` so all such access is guarded behind one class.
+   */
+  getSuiteInfo(test) {
+    const suitePath = [];
+    const suiteConfig = [];
+    const suites = [];
+    let suite = test.parent;
+    while (suite && suite.type === "describe") {
+      suites.unshift(suite);
+      suite = suite.parent;
+    }
+    for (const s of suites) {
+      if (!s.title) continue;
+      suitePath.push(s.title);
+      const rawMode = s._parallelMode;
+      const mode = rawMode === "parallel" ? "parallel" : rawMode === "serial" ? "serial" : "default";
+      const annotations = s._annotations ?? [];
+      suiteConfig.push({ mode, annotations });
+    }
+    return { suitePath, suiteConfig };
+  }
+  collectScmInfo(_options) {
+    const scm = {};
+    try {
+      const execOpts = {
+        encoding: "utf8",
+        timeout: 5e3,
+        maxBuffer: 1024 * 1024,
+        stdio: ["ignore", "pipe", "ignore"]
+      };
+      scm.commit = (0, import_node_child_process.execSync)("git rev-parse HEAD", execOpts).trim();
+      scm.branch = (0, import_node_child_process.execSync)("git rev-parse --abbrev-ref HEAD", execOpts).trim();
+      scm.author = (0, import_node_child_process.execSync)('git log -1 --pretty=format:"%an"', execOpts).trim();
+      scm.commitMessage = (0, import_node_child_process.execSync)('git log -1 --pretty=format:"%s"', execOpts).trim();
+      try {
+        scm.remoteUrl = (0, import_node_child_process.execSync)("git config --get remote.origin.url", execOpts).trim();
+      } catch {
+      }
+    } catch (error) {
+      this.logger.debug(`Git info not available: ${errorMessage(error)}`);
+    }
+    return Object.keys(scm).length > 0 ? scm : void 0;
+  }
+  collectCiInfo() {
+    const ci = {};
+    const env = process.env;
+    if (env.JENKINS_URL) {
+      ci.provider = "Jenkins";
+      ci.buildNumber = env.BUILD_NUMBER;
+      ci.buildUrl = env.BUILD_URL;
+      ci.jobName = env.JOB_NAME;
+    } else if (env.GITHUB_ACTIONS) {
+      ci.provider = "GitHub Actions";
+      ci.runId = env.GITHUB_RUN_ID;
+      ci.runNumber = env.GITHUB_RUN_NUMBER;
+      ci.workflow = env.GITHUB_WORKFLOW;
+      ci.actor = env.GITHUB_ACTOR;
+      ci.repository = env.GITHUB_REPOSITORY;
+      ci.ref = env.GITHUB_REF;
+      ci.sha = env.GITHUB_SHA;
+      ci.serverUrl = env.GITHUB_SERVER_URL;
+      if (ci.serverUrl && ci.repository && ci.runId) {
+        ci.buildUrl = `${ci.serverUrl}/${ci.repository}/actions/runs/${ci.runId}`;
+      }
+    } else if (env.GITLAB_CI) {
+      ci.provider = "GitLab CI";
+      ci.pipelineId = env.CI_PIPELINE_ID;
+      ci.pipelineUrl = env.CI_PIPELINE_URL;
+      ci.jobId = env.CI_JOB_ID;
+      ci.jobUrl = env.CI_JOB_URL;
+      ci.jobName = env.CI_JOB_NAME;
+    } else if (env.CIRCLECI) {
+      ci.provider = "CircleCI";
+      ci.buildNumber = env.CIRCLE_BUILD_NUM;
+      ci.buildUrl = env.CIRCLE_BUILD_URL;
+      ci.jobName = env.CIRCLE_JOB;
+      ci.workflow = env.CIRCLE_WORKFLOW_ID;
+    } else if (env.TRAVIS) {
+      ci.provider = "Travis CI";
+      ci.buildNumber = env.TRAVIS_BUILD_NUMBER;
+      ci.buildUrl = env.TRAVIS_BUILD_WEB_URL;
+      ci.jobNumber = env.TRAVIS_JOB_NUMBER;
+    } else if (env.TF_BUILD) {
+      ci.provider = "Azure Pipelines";
+      ci.buildNumber = env.BUILD_BUILDNUMBER;
+      ci.buildId = env.BUILD_BUILDID;
+      if (env.SYSTEM_TEAMFOUNDATIONSERVERURI && env.SYSTEM_TEAMPROJECT && env.BUILD_BUILDID) {
+        ci.buildUrl = `${env.SYSTEM_TEAMFOUNDATIONSERVERURI}${env.SYSTEM_TEAMPROJECT}/_build/results?buildId=${env.BUILD_BUILDID}`;
+      }
+      ci.jobName = env.AGENT_JOBNAME;
+    } else if (env.CI) {
+      ci.provider = "Unknown CI";
+      ci.detected = true;
+    }
+    return Object.keys(ci).length > 0 ? ci : void 0;
+  }
+  extractPlaywrightConfigMetadata(config) {
+    const meta = {};
+    if (config.projects?.length > 0) {
+      meta.projects = config.projects.map((p) => ({
+        name: p.name,
+        testDir: p.testDir,
+        use: {
+          browserName: p.use?.browserName || p.name,
+          viewport: p.use?.viewport,
+          deviceScaleFactor: p.use?.deviceScaleFactor
+        }
+      }));
+    }
+    meta.workers = config.workers;
+    meta.timeout = config.globalTimeout;
+    meta.fullyParallel = config.fullyParallel;
+    return meta;
+  }
+};
+
+// src/internal/streaming/stream-manager.ts
+var fs7 = __toESM(require("fs"));
+
+// src/internal/support/limiter.ts
+function createLimiter(maxConcurrent) {
+  const limitValue = Math.max(1, Math.floor(maxConcurrent));
+  let active = 0;
+  const queue = [];
+  const next = () => {
+    active--;
+    const run = queue.shift();
+    if (run) run();
+  };
+  return function limit(fn) {
+    return new Promise((resolve5, reject) => {
+      const run = () => {
+        active++;
+        Promise.resolve().then(fn).then(resolve5, reject).finally(next);
+      };
+      if (active < limitValue) run();
+      else queue.push(run);
+    });
+  };
+}
+
+// src/internal/support/setup-file.ts
+var path6 = __toESM(require("path"));
+var os4 = __toESM(require("os"));
+var fs6 = __toESM(require("fs"));
+function getSetupFilePath(projectName) {
+  return path6.join(os4.tmpdir(), `piwi-dashboard-setup-${hashForProject(projectName)}.json`);
+}
+function readSetupInfo(projectName) {
+  const setupFile = getSetupFilePath(projectName);
+  try {
+    if (fs6.existsSync(setupFile)) {
+      const info = JSON.parse(fs6.readFileSync(setupFile, "utf8"));
+      fs6.unlinkSync(setupFile);
+      if (info.projectName === projectName) return info;
+    }
+  } catch {
+  }
+  return null;
+}
+
+// src/internal/streaming/stream-manager.ts
+var StreamManager = class {
+  /**
+   * @param httpClient  HTTP client for server communication.
+   * @param streamBuffer On-disk buffer for crash-safe event persistence.
+   * @param recovery    Crash-recovery handler for uploading stale payloads on startup.
+   * @param uploader    Uploader for per-test-case file uploads.
+   * @param fileHandler File-discovery helper for finding traces and attachments.
+   * @param options     Piwi Dashboard reporter options.
+   * @param logger      Prefixed logger.
+   */
+  constructor(httpClient, streamBuffer, recovery, uploader, fileHandler, options, logger = new Logger()) {
+    this.httpClient = httpClient;
+    this.streamBuffer = streamBuffer;
+    this.recovery = recovery;
+    this.uploader = uploader;
+    this.fileHandler = fileHandler;
+    this.options = options;
+    this.logger = logger;
+    this.pendingEvents = [];
+    this.pendingBeginEvents = [];
+    this.flushTimer = null;
+    this.flushPromises = [];
+    this.liveUploadPromises = [];
+    this.limitLiveUpload = createLimiter(2);
+    this.retryCount = 0;
+    this.retryTimer = null;
+    this.maxRetryDelay = 3e4;
+    /**
+     * Idle heartbeat: while the run is open but no events are flowing (e.g. a single
+     * long test, or `beforeAll` setup), a periodic ping keeps the server's activity
+     * timestamp fresh so the stale-run reaper can tell a live run from a crashed one.
+     * The interval must stay well below the server's stale timeout.
+     */
+    this.heartbeatTimer = null;
+    this.heartbeatStopped = false;
+    this.lastActivityAt = 0;
+    this.heartbeatInterval = 15e3;
+    /** Tracks cases whose files have already been uploaded live, so `uploadRemaining` can skip them. */
+    this.uploadedCaseFiles = /* @__PURE__ */ new WeakSet();
+    this._enabled = false;
+    this._runId = null;
+    this._token = null;
+    this._auth = null;
+    this._startPromise = null;
+  }
+  /** Whether the streaming session is active */
+  get enabled() {
+    return this._enabled;
+  }
+  /** Server-assigned run ID (`null` until the stream opens) */
+  get runId() {
+    return this._runId;
+  }
+  /** Stream authentication token (`null` until the stream opens) */
+  get token() {
+    return this._token;
+  }
+  /** Resolved auth string (API key or session cookie) used in stream requests */
+  get auth() {
+    return this._auth;
+  }
+  /** Promise that resolves when the stream has been fully initialised */
+  get startPromise() {
+    return this._startPromise;
+  }
+  /** Begin the streaming session after `onBegin` fires. Non-blocking — the actual handshake runs asynchronously. */
+  start(startTime, metadata, instanceId, playwrightVersion, reporterVersion, shardInfo, isFullRun, filterDetails) {
+    this._startPromise = this._doStart(
+      startTime,
+      metadata,
+      instanceId,
+      playwrightVersion,
+      reporterVersion,
+      shardInfo,
+      isFullRun,
+      filterDetails
+    );
+  }
+  async _doStart(startTime, metadata, instanceId, playwrightVersion, reporterVersion, shardInfo, isFullRun, filterDetails) {
+    const setupInfo = readSetupInfo(this.options.projectName);
+    try {
+      this._auth = await this.httpClient.resolveAuth(this.options);
+      await this.recovery.tryUpload(this.httpClient, this._auth);
+      let response;
+      const shardIndex = shardInfo?.current;
+      const shardTotal = shardInfo?.total;
+      if (setupInfo) {
+        try {
+          response = await this.httpClient.postJSON(
+            `/api/test-runs/${setupInfo.runId}/begin`,
+            {
+              setupToken: setupInfo.setupToken,
+              totalTests: 0,
+              metadata,
+              playwrightVersion,
+              reporterVersion,
+              shardIndex,
+              shardTotal,
+              isFullRun,
+              filterDetails
+            },
+            this._auth
+          );
+        } catch (error) {
+          if (!(error instanceof HttpError && error.status === 409)) throw error;
+          this.logger.debug(`Setup info expired, creating fresh run...`);
+          response = await this.httpClient.postJSON(
+            "/api/test-runs/start",
+            {
+              projectName: this.options.projectName,
+              projectDescription: this.options.projectDescription,
+              startTime,
+              environment: this.options.environment || null,
+              label: this.options.label || null,
+              metadata,
+              instanceId,
+              playwrightVersion,
+              reporterVersion,
+              shardIndex,
+              shardTotal,
+              isFullRun,
+              filterDetails
+            },
+            this._auth
+          );
+        }
+      } else {
+        response = await this.httpClient.postJSON(
+          "/api/test-runs/start",
+          {
+            projectName: this.options.projectName,
+            projectDescription: this.options.projectDescription,
+            startTime,
+            environment: this.options.environment || null,
+            label: this.options.label || null,
+            metadata,
+            instanceId,
+            playwrightVersion,
+            reporterVersion,
+            shardIndex,
+            shardTotal,
+            isFullRun,
+            filterDetails
+          },
+          this._auth
+        );
+      }
+      if (response?.runId && response?.streamToken) {
+        this._runId = response.runId;
+        this._token = response.streamToken;
+        this._enabled = true;
+        this.logger.info(`Streaming enabled. Run ID: ${response.runId}`);
+        if (this.options.serverUrl) {
+          this.logger.info(`Watch live: ${runUrl(this.options.serverUrl, response.runId)}`);
+        }
+        this.lastActivityAt = Date.now();
+        this.scheduleHeartbeat();
+        if (this.pendingBeginEvents.length > 0) {
+          this.pendingEvents = [...this.pendingBeginEvents, ...this.pendingEvents];
+          this.pendingBeginEvents = [];
+          this.flush();
+        }
+      }
+    } catch (error) {
+      if (error instanceof HttpError && (error.status === 401 || error.status === 403)) {
+        this.logger.warn(
+          `Live streaming could not start: the dashboard at ${this.options.serverUrl} requires authentication. Set the reporter's \`apiKey\` option (or PIWI_API_KEY) \u2014 create a key under Settings \u2192 Users on the dashboard. Falling back to batch upload at the end of the run.`
+        );
+      } else {
+        this.logger.debug(`Streaming not available: ${errorMessage(error)}. Will use batch mode.`);
+      }
+      this._enabled = false;
+    }
+  }
+  // Queues a begin event; held in a pre-start buffer until the stream is open,
+  // then prepended to the main queue so it arrives before the matching complete event.
+  /** Queue a test-case `begin` event. Held in a pre-start buffer if the stream is not yet open, then prepended so it arrives before the matching `complete` event. */
+  queueBeginEvent(event) {
+    if (this._enabled && this._runId) {
+      this.queueEvent(event);
+    } else {
+      this.pendingBeginEvents.push(event);
+    }
+  }
+  /** Queue a test-case event. Triggers an immediate flush when the batch size is reached, otherwise schedules a timer-based flush. */
+  queueEvent(event) {
+    this.pendingEvents.push(event);
+    if (this.pendingEvents.length >= this.options.streamingBatchSize) {
+      this.flush();
+    } else if (!this.flushTimer) {
+      this.flushTimer = setTimeout(() => this.flush(), this.options.streamingBatchDelay);
+    }
+  }
+  /** Flush all pending events to the server. Returns a promise that resolves to `true` on success or `false` on failure (events are re-queued for retry). */
+  flush() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    if (this.pendingEvents.length === 0 || !this._enabled || !this._runId) return null;
+    const events = this.pendingEvents.splice(0);
+    const promise = this.httpClient.postJSON(`/api/test-runs/${this._runId}/events`, { streamToken: this._token, testCases: events }, this._auth).then(
+      () => {
+        this.retryCount = 0;
+        this.lastActivityAt = Date.now();
+        return true;
+      },
+      () => {
+        this.pendingEvents = events.concat(this.pendingEvents);
+        this.scheduleRetry();
+        return false;
+      }
+    );
+    this.flushPromises.push(promise);
+    return promise;
+  }
+  scheduleRetry() {
+    if (this.retryTimer) return;
+    this.retryCount++;
+    const delay = Math.min(1e3 * Math.pow(2, this.retryCount - 1), this.maxRetryDelay);
+    this.logger.debug(`Will retry streaming flush in ${delay}ms (attempt ${this.retryCount})`);
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = null;
+      const buffered = this.streamBuffer.load();
+      if (buffered.length > 0) {
+        this.streamBuffer.clear();
+        this.pendingEvents = buffered.concat(this.pendingEvents);
+      }
+      if (this.pendingEvents.length > 0) this.flush();
+    }, delay);
+  }
+  // Schedule the next idle heartbeat. Self-rescheduling; cleared by stopHeartbeat.
+  scheduleHeartbeat() {
+    if (this.heartbeatStopped || this.heartbeatTimer) return;
+    this.heartbeatTimer = setTimeout(() => {
+      this.heartbeatTimer = null;
+      void this.sendHeartbeat();
+    }, this.heartbeatInterval);
+  }
+  // Ping the server only when the run has actually been idle. Real event traffic
+  // already bumps the server's activity timestamp, so a recent flush (or pending
+  // events about to flush) makes the ping redundant — skip it and reschedule.
+  async sendHeartbeat() {
+    if (this.heartbeatStopped || !this._enabled || !this._runId || !this._token) return;
+    const idleFor = Date.now() - this.lastActivityAt;
+    if (idleFor < this.heartbeatInterval || this.pendingEvents.length > 0) {
+      this.scheduleHeartbeat();
+      return;
+    }
+    try {
+      await this.httpClient.postJSON(
+        `/api/test-runs/${this._runId}/heartbeat`,
+        { streamToken: this._token },
+        this._auth
+      );
+      this.lastActivityAt = Date.now();
+    } catch (error) {
+      this.logger.debug(`Heartbeat failed: ${errorMessage(error)}`);
+    }
+    this.scheduleHeartbeat();
+  }
+  /** Stop the idle heartbeat permanently (called when the run is wrapping up). */
+  stopHeartbeat() {
+    this.heartbeatStopped = true;
+    if (this.heartbeatTimer) {
+      clearTimeout(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  /** Drain all pending and buffered events before the run finishes. Retries up to 10 times with exponential back-off. */
+  async drain() {
+    this.stopHeartbeat();
+    if (!this._enabled) {
+      this.pendingEvents = [];
+      this.flushPromises = [];
+      return;
+    }
+    const MAX_ATTEMPTS = 10;
+    for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+      if (this._enabled && this.pendingEvents.length > 0) this.flush();
+      if (this.flushPromises.length > 0) {
+        await Promise.allSettled(this.flushPromises);
+        this.flushPromises = [];
+      }
+      if (this.pendingEvents.length === 0) {
+        const buffered = this.streamBuffer.load();
+        if (buffered.length > 0) {
+          this.pendingEvents = buffered;
+          this.streamBuffer.clear();
+          continue;
+        }
+        return;
+      }
+      this.logger.debugError(
+        `${this.pendingEvents.length} events pending, retrying (attempt ${attempt + 1}/${MAX_ATTEMPTS})...`
+      );
+      await new Promise((resolve5) => setTimeout(resolve5, Math.min(1e3 * Math.pow(2, attempt), 1e4)));
+    }
+    if (this.pendingEvents.length > 0) {
+      this.streamBuffer.append(this.pendingEvents);
+      this.pendingEvents = [];
+    }
+  }
+  /** Schedule a live upload of trace and attachment files for a test case. Skips cases with no files. Concurrency is limited to 2 simultaneous uploads. */
+  scheduleLiveUpload(tc) {
+    const hasTrace = !!this.options.uploadTraces && this.fileHandler.findTraceFiles(tc).some((p) => fs7.existsSync(p));
+    const hasAttachments = this.fileHandler.findAllAttachments(tc).length > 0;
+    if (!hasTrace && !hasAttachments) return;
+    const promise = (async () => {
+      if (this._startPromise) await this._startPromise;
+      if (!this._enabled || !this._runId || !this._token) return;
+      if (this.flushPromises.length > 0) {
+        await Promise.allSettled(this.flushPromises);
+      }
+      const flush = this.flush();
+      if (flush) await flush;
+      const delays = [0, 1e3, 3e3];
+      for (let attempt = 0; attempt < delays.length; attempt++) {
+        if (delays[attempt]) await new Promise((resolve5) => setTimeout(resolve5, delays[attempt]));
+        try {
+          await this.limitLiveUpload(
+            () => this.uploader.uploadCaseFiles(
+              this.options.projectName,
+              this._runId,
+              this._token,
+              tc,
+              this.options.uploadTraces,
+              this._auth
+            )
+          );
+          this.uploadedCaseFiles.add(tc);
+          return;
+        } catch (error) {
+          const retryable = error instanceof HttpError && error.status === 404;
+          if (!retryable || attempt === delays.length - 1) {
+            this.logger.debug(`Live file upload failed for "${tc.title}": ${errorMessage(error)}`);
+            return;
+          }
+        }
+      }
+    })();
+    this.liveUploadPromises.push(promise);
+  }
+  /** Wait for all live uploads to settle, then upload files for any test cases that weren't uploaded live */
+  async uploadRemaining(testCases) {
+    if (this.liveUploadPromises.length > 0) {
+      await Promise.allSettled(this.liveUploadPromises);
+      this.liveUploadPromises = [];
+    }
+    if (!this._enabled || !this._runId || !this._token) return;
+    for (const tc of testCases) {
+      if (this.uploadedCaseFiles.has(tc)) continue;
+      try {
+        const uploaded = await this.uploader.uploadCaseFiles(
+          this.options.projectName,
+          this._runId,
+          this._token,
+          tc,
+          this.options.uploadTraces,
+          this._auth
+        );
+        if (uploaded) this.uploadedCaseFiles.add(tc);
+      } catch (error) {
+        this.logger.warn(`Failed to upload files for "${tc.title}": ${errorMessage(error)}`);
+      }
+    }
+  }
+};
+
+// src/internal/collect/step-analyzer.ts
+function categorizeStep(title, pwCategory) {
+  if (!title) return "other";
+  if (pwCategory === "hook" || pwCategory === "fixture") return pwCategory;
+  if (pwCategory === "expect") return "assertion";
+  const lower = title.toLowerCase();
+  if (lower.startsWith("wait for") || lower.startsWith("locator.waitfor") || lower.startsWith("page.waitfor") || lower.startsWith("frame.waitfor"))
+    return "wait";
+  if (lower.startsWith("navigate to") || lower.startsWith("go back") || lower.startsWith("go forward") || lower.startsWith("reload") || lower.startsWith("page.goto") || lower.startsWith("page.reload") || lower.startsWith("page.goback") || lower.startsWith("page.goforward"))
+    return "navigation";
+  if (lower.startsWith("click") || lower.startsWith("double click") || lower.startsWith("check") || lower.startsWith("uncheck") || lower.startsWith("tap") || lower.startsWith("hover") || lower.startsWith("select option") || lower.startsWith("drag") || lower.startsWith("locator.click") || lower.startsWith("locator.dblclick") || lower.startsWith("locator.check") || lower.startsWith("locator.uncheck") || lower.startsWith("locator.selectoption") || lower.startsWith("locator.tap"))
+    return "action";
+  if (lower.startsWith("fill ") || lower === "fill" || lower.startsWith("type") || lower.startsWith("press") || lower.startsWith("insert ") || lower.startsWith("set input files") || lower.startsWith("locator.fill") || lower.startsWith("locator.type") || lower.startsWith("locator.press") || lower.startsWith("locator.clear") || lower.startsWith("locator.setinputfiles"))
+    return "input";
+  if (lower.startsWith("expect") || lower.startsWith("locator.expect") || lower.startsWith("page.expect"))
+    return "assertion";
+  if (lower.startsWith("apirequestcontext") || lower.startsWith("apiresponse")) return "api";
+  if (lower === "before hooks" || lower === "after hooks" || lower.startsWith("fixture:")) return "hook";
+  return "other";
+}
+function flattenSteps(steps) {
+  const result = [];
+  for (const step of steps) {
+    const flat = {
+      title: step.title,
+      duration: step.duration,
+      category: categorizeStep(step.title, step.category)
+    };
+    if (step.error?.message) {
+      flat.error = { message: step.error.message };
+      flat.failed = true;
+    }
+    if (step.location) flat.location = `${step.location.file}:${step.location.line}:${step.location.column}`;
+    if (step.startTime) flat.startTime = step.startTime instanceof Date ? step.startTime.getTime() : step.startTime;
+    result.push(flat);
+    if (step.steps?.length > 0) result.push(...flattenSteps(step.steps));
+  }
+  return result;
+}
+function collectStepMetrics(steps) {
+  const flatSteps = flattenSteps(steps);
+  const totalStepDuration = steps.reduce((sum, s) => sum + (s.duration || 0), 0);
+  let slowestStep = null;
+  for (const s of flatSteps) {
+    if (!slowestStep || s.duration > slowestStep.duration) slowestStep = { title: s.title, duration: s.duration };
+  }
+  const navSteps = flatSteps.filter((s) => s.category === "navigation");
+  const waitSteps = flatSteps.filter((s) => s.category === "wait");
+  const waitTotalDuration = waitSteps.reduce((sum, s) => sum + (s.duration || 0), 0);
+  return {
+    steps: flatSteps,
+    totalStepDuration,
+    slowestStep,
+    navigationCount: navSteps.length,
+    navigationTotalDuration: navSteps.reduce((sum, s) => sum + (s.duration || 0), 0),
+    waitTotalDuration,
+    waitCount: waitSteps.length
+  };
+}
+function percentile(sortedArr, p) {
+  if (sortedArr.length === 0) return 0;
+  const index = Math.ceil(p / 100 * sortedArr.length) - 1;
+  return sortedArr[Math.max(0, index)];
+}
+function computePerformanceSummary(testCases) {
+  const durations = testCases.filter((tc) => tc.duration != null).map((tc) => tc.duration);
+  if (durations.length === 0) return {};
+  const sorted = [...durations].sort((a, b) => a - b);
+  const sum = durations.reduce((a, b) => a + b, 0);
+  const result = {
+    avgTestDuration: Math.round(sum / durations.length),
+    p50TestDuration: percentile(sorted, 50),
+    p90TestDuration: percentile(sorted, 90),
+    p95TestDuration: percentile(sorted, 95),
+    slowestTests: [...testCases].filter((tc) => tc.duration != null).sort((a, b) => b.duration - a.duration).slice(0, 5).map((tc) => ({ title: tc.title, duration: tc.duration }))
+  };
+  let totalNavDur = 0;
+  let totalNavCount = 0;
+  for (const tc of testCases) {
+    if (tc.performanceMetrics) {
+      totalNavDur += tc.performanceMetrics.navigationTotalDuration || 0;
+      totalNavCount += tc.performanceMetrics.navigationCount || 0;
+    }
+  }
+  result.totalNavigationDuration = totalNavDur;
+  result.avgNavigationDuration = totalNavCount > 0 ? Math.round(totalNavDur / totalNavCount) : 0;
+  let totalWasted = 0;
+  for (const tc of testCases) {
+    if (tc.performanceMetrics) {
+      totalWasted += tc.performanceMetrics.waitTotalDuration || 0;
+    }
+  }
+  result.totalWastedTimeMs = totalWasted;
+  return result;
+}
+function extractTestStepEvents(steps, _testStartTime) {
+  const events = [];
+  for (const step of steps) {
+    const cat = categorizeStep(step.title, step.category);
+    if (cat !== "hook" && cat !== "fixture") continue;
+    if (!step.startTime) continue;
+    const startedAt = step.startTime instanceof Date ? step.startTime.getTime() : step.startTime;
+    events.push({
+      title: step.title,
+      category: cat,
+      startedAt,
+      duration: step.duration || 0,
+      status: step.error ? "failed" : "passed",
+      location: step.location ? `${step.location.file}:${step.location.line}:${step.location.column}` : null
+    });
+  }
+  return events;
+}
+function extractWaitEvents(steps, insideWait = false) {
+  const events = [];
+  for (const step of steps) {
+    const cat = categorizeStep(step.title, step.category);
+    const isWait = cat === "wait";
+    if (isWait && !insideWait && step.startTime) {
+      const startedAt = step.startTime instanceof Date ? step.startTime.getTime() : step.startTime;
+      events.push({
+        title: step.title,
+        category: "wait",
+        startedAt,
+        duration: step.duration || 0,
+        status: "wasted",
+        location: step.location ? `${step.location.file}:${step.location.line}:${step.location.column}` : null
+      });
+    }
+    if (step.steps?.length > 0) {
+      events.push(...extractWaitEvents(step.steps, insideWait || isWait));
+    }
+  }
+  return events;
+}
+
+// src/internal/support/reporter-version.ts
+var fs8 = __toESM(require("fs"));
+var path7 = __toESM(require("path"));
+var cachedVersion = null;
+var CANDIDATE_OFFSETS = ["..", "../../.."];
+function findOwnPackageJson(fromDir) {
+  for (const offset of CANDIDATE_OFFSETS) {
+    try {
+      const pkgPath = path7.resolve(fromDir, offset, "package.json");
+      const pkg = JSON.parse(fs8.readFileSync(pkgPath, "utf-8"));
+      const { name, version } = pkg;
+      if (name === "@piwitests/reporter" && typeof version === "string") return { version };
+    } catch {
+    }
+  }
+  return void 0;
+}
+function getReporterVersion() {
+  if (cachedVersion) return cachedVersion;
+  cachedVersion = findOwnPackageJson(__dirname)?.version ?? "unknown";
+  return cachedVersion;
+}
+
+// src/internal/support/source-snippet.ts
+var fs9 = __toESM(require("fs"));
+var path8 = __toESM(require("path"));
+function readSourceSnippet(file, declLine, context, failingLine) {
+  try {
+    const content = fs9.readFileSync(file, "utf-8");
+    const lines = content.split("\n");
+    const anchor = failingLine ?? declLine;
+    const start = Math.max(0, anchor - context - 1);
+    const end = Math.min(lines.length, anchor + context);
+    return lines.slice(start, end).map((l, i) => {
+      const lineNum = start + i + 1;
+      const hasFailingLine = failingLine != null;
+      const isFailing = hasFailingLine && lineNum === failingLine;
+      const isDecl = lineNum === declLine && !isFailing;
+      let marker = "  ";
+      if (isFailing) marker = "> ";
+      else if (isDecl) marker = hasFailingLine ? "* " : "> ";
+      return `${marker}${String(lineNum).padStart(4)} | ${l}`;
+    }).join("\n");
+  } catch {
+    return null;
+  }
+}
+function collectSourceFrames(errorText, testFile, declLine, opts = {}) {
+  const projectRoot = opts.projectRoot ?? process.cwd();
+  const context = opts.context ?? 8;
+  const maxFrames = opts.maxFrames ?? 4;
+  const picked = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (absFile, line) => {
+    const key = `${absFile}:${line}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    picked.push({ absFile, line });
+  };
+  if (errorText) {
+    const stackRe = /^\s+at (?:[^(]*\()?(.+?):(\d+):\d+\)?\s*$/gm;
+    let m;
+    while ((m = stackRe.exec(errorText)) !== null && picked.length < maxFrames) {
+      let abs;
+      try {
+        abs = path8.resolve(m[1]);
+      } catch {
+        continue;
+      }
+      if (abs.includes(`${path8.sep}node_modules${path8.sep}`)) continue;
+      const rel = path8.relative(projectRoot, abs);
+      if (rel.startsWith("..") || path8.isAbsolute(rel)) continue;
+      const line = parseInt(m[2], 10);
+      if (!isNaN(line)) add(abs, line);
+    }
+  }
+  const absTest = path8.resolve(testFile);
+  if (!picked.some((p) => p.absFile === absTest)) {
+    add(absTest, extractFailingLine(errorText, testFile, declLine));
+  }
+  const frames = [];
+  for (const p of picked.slice(0, maxFrames)) {
+    const snippet = readSourceSnippet(p.absFile, p.line, context, p.line);
+    if (snippet) {
+      frames.push({ file: path8.relative(projectRoot, p.absFile) || path8.basename(p.absFile), line: p.line, snippet });
+    }
+  }
+  return frames;
+}
+function extractFailingLine(errorText, testFile, declarationLine) {
+  if (!errorText) return declarationLine;
+  const expectedFile = path8.resolve(testFile);
+  const stackRe = /^\s+at (?:[^(]*\()?(.+?):(\d+):\d+\)?\s*$/gm;
+  let m;
+  while ((m = stackRe.exec(errorText)) !== null) {
+    try {
+      const frameFile = path8.resolve(m[1]);
+      if (frameFile === expectedFile) {
+        const line = parseInt(m[2], 10);
+        if (!isNaN(line)) return line;
+      }
+    } catch {
+    }
+  }
+  return declarationLine;
+}
+
+// src/internal/support/ci.ts
+function detectCiRunLabel() {
+  const env = process.env;
+  if (env.GITHUB_ACTIONS && env.GITHUB_RUN_ID) return env.GITHUB_RUN_ID;
+  if (env.GITLAB_CI && env.CI_PIPELINE_ID) return env.CI_PIPELINE_ID;
+  if (env.CIRCLECI && env.CIRCLE_WORKFLOW_ID) return env.CIRCLE_WORKFLOW_ID;
+  if (env.TRAVIS && env.TRAVIS_BUILD_ID) return env.TRAVIS_BUILD_ID;
+  if (env.TF_BUILD && env.BUILD_BUILDID) return env.BUILD_BUILDID;
+  if (env.JENKINS_URL && env.BUILD_ID) return env.BUILD_ID;
+  if (env.BUILDKITE_BUILD_ID) return env.BUILDKITE_BUILD_ID;
+  if (env.TEAMCITY_BUILD_ID) return env.TEAMCITY_BUILD_ID;
+  if (env.BITBUCKET_BUILD_NUMBER) return env.BITBUCKET_BUILD_NUMBER;
+  if (env.SEMAPHORE_WORKFLOW_ID) return env.SEMAPHORE_WORKFLOW_ID;
+  if (env.APPVEYOR_BUILD_ID) return env.APPVEYOR_BUILD_ID;
+  if (env.DRONE_BUILD_NUMBER) return env.DRONE_BUILD_NUMBER;
+  return null;
+}
+
+// src/internal/support/worker-index.ts
+function workerIndexOf(result) {
+  if (!result) return null;
+  return result.workerIndex ?? result.parallelIndex ?? null;
+}
+
+// src/internal/support/cli-filters.ts
+var PW_VALUE_FLAGS = /* @__PURE__ */ new Set([
+  "-c",
+  "--config",
+  "-j",
+  "--workers",
+  "-g",
+  "--grep",
+  "--grep-invert",
+  "--global-timeout",
+  "--max-failures",
+  "--output",
+  "-p",
+  "--project",
+  "--repeat-each",
+  "--reporter",
+  "--retries",
+  "--shard",
+  "--timeout",
+  "--trace"
+]);
+function detectCliFileFilters(argv = process.argv) {
+  const args = argv.slice(2);
+  const testIdx = args.indexOf("test");
+  const rest = testIdx >= 0 ? args.slice(testIdx + 1) : args;
+  const files = [];
+  for (let i = 0; i < rest.length; i++) {
+    const tok = rest[i];
+    if (tok.startsWith("-")) {
+      if (!tok.includes("=") && PW_VALUE_FLAGS.has(tok)) i++;
+      continue;
+    }
+    files.push(tok);
+  }
+  return files;
+}
+
+// src/public/global-setup.ts
+var path9 = __toESM(require("path"));
+var fs10 = __toESM(require("fs"));
+function createGlobalSetup(options, userSetup) {
+  return async function globalSetupFn(config) {
+    const piwiReporterPath = path9.resolve(__dirname, "./index.js");
+    let inlineReporterOptions = {};
+    if (Array.isArray(config?.reporter)) {
+      for (const r of config.reporter) {
+        if (!Array.isArray(r) || typeof r[0] !== "string") continue;
+        const isPiwi = r[0].toLowerCase().includes("piwi") || (() => {
+          try {
+            return path9.resolve(require.resolve(r[0])) === piwiReporterPath;
+          } catch {
+            return false;
+          }
+        })();
+        if (isPiwi && r[1] && typeof r[1] === "object") {
+          inlineReporterOptions = r[1];
+          break;
+        }
+      }
+    }
+    const opts = resolveOptions({ ...inlineReporterOptions, ...options });
+    const logger = new Logger(opts.verbose ?? false);
+    if (opts.enabled === false || !opts.serverUrl) {
+      logger.info("Not enabled \u2014 set PIWI_DASHBOARD_URL or serverUrl to enable.");
+      if (userSetup) return userSetup(config);
+      return;
+    }
+    const hasPiwi = Object.keys(inlineReporterOptions).length > 0 || Array.isArray(config?.reporter) && config.reporter.some((r) => {
+      if (!Array.isArray(r) || typeof r[0] !== "string") return false;
+      if (r[0].toLowerCase().includes("piwi")) return true;
+      try {
+        return path9.resolve(require.resolve(r[0])) === piwiReporterPath;
+      } catch {
+        return false;
+      }
+    });
+    if (!hasPiwi) {
+      logger.debug("Not reporting \u2014 Piwi is not in the Playwright reporters list.");
+      if (userSetup) return userSetup(config);
+      return;
+    }
+    const httpClient = new HttpClient(opts.serverUrl, logger);
+    try {
+      const auth = await httpClient.resolveAuth(opts);
+      const runLabel = opts.runLabel || detectCiRunLabel();
+      const pwShard = config.shard;
+      const shardIndex = pwShard?.current;
+      const shardTotal = pwShard?.total;
+      const response = await httpClient.postJSON(
+        "/api/test-runs/setup",
+        {
+          projectName: opts.projectName,
+          projectDescription: opts.projectDescription,
+          environment: opts.environment || null,
+          label: opts.label || null,
+          startTime: (/* @__PURE__ */ new Date()).toISOString(),
+          instanceId: computeInstanceId(opts.projectName, runLabel),
+          shardIndex,
+          shardTotal
+        },
+        auth
+      );
+      if (response?.runId && response?.setupToken) {
+        fs10.writeFileSync(
+          getSetupFilePath(opts.projectName),
+          JSON.stringify({
+            runId: response.runId,
+            setupToken: response.setupToken,
+            projectName: opts.projectName
+          })
+        );
+        logger.debug(`Global setup: initialising run #${response.runId}`);
+      }
+    } catch (error) {
+      logger.warn(`Could not register global setup: ${errorMessage(error)}`);
+    }
+    if (userSetup) return userSetup(config);
+  };
+}
+
+// src/public/config-wrapper.ts
+var path10 = __toESM(require("path"));
+var fs11 = __toESM(require("fs"));
+var PIWI_MODULE = "@piwitests/reporter";
+function isPiwiReporterEntry(entry) {
+  if (typeof entry === "string") return entry.toLowerCase().includes("piwi");
+  if (Array.isArray(entry) && typeof entry[0] === "string") return entry[0].toLowerCase().includes("piwi");
+  return false;
+}
+function injectReporter(reporter, piwiOptions) {
+  const piwiEntry = piwiOptions ? [PIWI_MODULE, piwiOptions] : [PIWI_MODULE];
+  if (!reporter) return [piwiEntry];
+  if (Array.isArray(reporter)) {
+    if (reporter.some(isPiwiReporterEntry)) return reporter;
+    return [...reporter, piwiEntry];
+  }
+  return [[reporter], piwiEntry];
+}
+function resolveSetupModule() {
+  const candidates = [
+    path10.join(__dirname, "global-setup-module.js"),
+    path10.join(__dirname, "..", "global-setup-module.js"),
+    path10.join(__dirname, "..", "global-setup-module.ts")
+  ];
+  return candidates.find((candidate) => fs11.existsSync(candidate)) ?? candidates[0];
+}
+function wrapConfig(config, piwiOptions) {
+  if (piwiOptions) applyOptionsToEnv(piwiOptions);
+  const globalSetupModules = [];
+  if (config.globalSetup) {
+    const orig = Array.isArray(config.globalSetup) ? config.globalSetup : [config.globalSetup];
+    globalSetupModules.push(...orig);
+  }
+  globalSetupModules.push(resolveSetupModule());
+  return {
+    ...config,
+    reporter: injectReporter(config.reporter, piwiOptions),
+    globalSetup: globalSetupModules.length === 1 ? globalSetupModules[0] : globalSetupModules
+  };
+}
+
+// src/internal/collect/skip-classify.ts
+function mergeAnnotations(test, result) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const list of [test.annotations, result.annotations]) {
+    for (const a of list ?? []) {
+      const key = `${a.type}\0${a.description ?? ""}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      out.push(a.description === void 0 ? { type: a.type } : { type: a.type, description: a.description });
+    }
+  }
+  return out;
+}
+function classifyStatus(rawStatus, annotations) {
+  if (rawStatus !== "skipped") return rawStatus;
+  const intentional = annotations.some((a) => a.type === "skip" || a.type === "fixme");
+  return intentional ? "skipped" : "didnotrun";
+}
+
+// src/internal/collect/error-text.ts
+var path11 = __toESM(require("path"));
+function buildErrorText(result) {
+  if (!result.errors || result.errors.length === 0) return null;
+  const seen = /* @__PURE__ */ new Set();
+  const parts = [];
+  for (const err of result.errors) {
+    const msg = err.message ?? "";
+    if (!msg) continue;
+    const dedupeKey = msg.trim().slice(0, 200);
+    if (seen.has(dedupeKey)) continue;
+    seen.add(dedupeKey);
+    parts.push(msg);
+  }
+  let text = parts.join("\n---\n");
+  if (!text) return null;
+  const primary = result.error;
+  const loc = primary?.location;
+  if (loc?.file && !/\n\s+at\s/.test(text)) {
+    const rel = path11.relative(process.cwd(), loc.file).split(path11.sep).join("/");
+    text += `
+    at ${rel}:${loc.line}:${loc.column}`;
+  }
+  return text;
+}
+
+// src/internal/submit/run-submitter.ts
+var RunSubmitter = class {
+  /**
+   * @param httpClient    HTTP client for auth resolution and the finish call.
+   * @param uploader      Upload strategies (multipart + JSON).
+   * @param recovery      Crash-recovery persistence.
+   * @param streamManager Streaming session (may be `null` when streaming is disabled).
+   * @param logger        Prefixed logger.
+   */
+  constructor(httpClient, uploader, recovery, streamManager, logger = new Logger()) {
+    this.httpClient = httpClient;
+    this.uploader = uploader;
+    this.recovery = recovery;
+    this.streamManager = streamManager;
+    this.logger = logger;
+  }
+  /** Run the fallback ladder for a completed test run. */
+  async submit(run, result) {
+    const endTime = (/* @__PURE__ */ new Date()).toISOString();
+    const duration = new Date(endTime).getTime() - new Date(run.startTime).getTime();
+    const overallStatus = resolveOverallStatus(result, {
+      failedTests: run.failedTests,
+      timedOutTests: run.timedOutTests,
+      totalTests: run.totalTests
+    });
+    this.logger.info(
+      `Test run completed. Status: ${overallStatus} (Playwright result.status: ${result?.status || "undefined"})`
+    );
+    this.logger.info(
+      `Total: ${run.totalTests}, Passed: ${run.passedTests}, Failed: ${run.failedTests}, Skipped: ${run.skippedTests}, TimedOut: ${run.timedOutTests}, DidNotRun: ${run.didNotRunTests}`
+    );
+    if (run.options.collectPerformanceMetrics) {
+      run.metadata.performance = computePerformanceSummary(run.testCases);
+    }
+    const sm = this.streamManager;
+    if (sm?.startPromise) await sm.startPromise;
+    await sm?.drain();
+    let auth;
+    try {
+      auth = sm?.auth ?? await this.httpClient.resolveAuth(run.options);
+    } catch (error) {
+      this.logger.error(`Authentication failed: ${errorMessage(error)}`);
+      throw error;
+    }
+    if (sm?.enabled && sm?.runId != null) {
+      if (await this.tryFinishStreaming(run, overallStatus, duration, auth)) return;
+    }
+    if (this.hasReports(run) || run.options.uploadTraces) {
+      if (await this.tryUploadWithFiles(run, overallStatus, duration, auth)) return;
+    }
+    await this.tryUploadJSON(run, overallStatus, duration, auth);
+  }
+  hasReports(run) {
+    return !!run.options.uploadReport || (run.options.reports?.length ?? 0) > 0;
+  }
+  reportOptions(run) {
+    return {
+      uploadTraces: run.options.uploadTraces,
+      uploadReport: run.options.uploadReport,
+      reports: run.options.reports
+    };
+  }
+  buildRunPayload(run, status, duration) {
+    return {
+      projectName: run.options.projectName,
+      projectDescription: run.options.projectDescription,
+      status,
+      startTime: run.startTime,
+      duration,
+      totalTests: run.totalTests,
+      passedTests: run.passedTests,
+      failedTests: run.failedTests,
+      timedOutTests: run.timedOutTests,
+      skippedTests: run.skippedTests,
+      didNotRunTests: run.didNotRunTests,
+      environment: run.options.environment,
+      label: run.options.label || null,
+      metadata: run.metadata,
+      instanceId: run.instanceId,
+      playwrightVersion: run.playwrightVersion ?? void 0,
+      reporterVersion: run.reporterVersion ?? void 0,
+      testCases: run.testCases,
+      shardIndex: run.shardInfo?.current,
+      shardTotal: run.shardInfo?.total,
+      isFullRun: run.isFullRun,
+      filterDetails: run.filterDetails
+    };
+  }
+  async tryFinishStreaming(run, overallStatus, duration, auth) {
+    const sm = this.streamManager;
+    try {
+      const flakyTests = run.testCases.filter((tc) => tc.status === "passed" && (tc.retries || 0) > 0).length;
+      const durations = run.testCases.filter((tc) => tc.duration != null).map((tc) => tc.duration);
+      await sm.uploadRemaining(run.testCases);
+      const finishBody = {
+        streamToken: sm.token,
+        status: overallStatus,
+        duration,
+        totalTests: run.totalTests,
+        passedTests: run.passedTests,
+        failedTests: run.failedTests,
+        timedOutTests: run.timedOutTests,
+        skippedTests: run.skippedTests,
+        didNotRunTests: run.didNotRunTests,
+        flakyTests,
+        durations,
+        label: run.options.label || null,
+        metadata: run.metadata,
+        hasPendingUploads: this.hasReports(run),
+        playwrightVersion: run.playwrightVersion ?? void 0,
+        reporterVersion: run.reporterVersion ?? void 0,
+        setupSteps: run.setupSteps.length > 0 ? run.setupSteps : void 0,
+        isFullRun: run.isFullRun,
+        filterDetails: run.filterDetails ?? null
+      };
+      if (run.shardInfo) {
+        finishBody.shardIndex = run.shardInfo.current;
+        finishBody.shardTotal = run.shardInfo.total;
+      }
+      await this.httpClient.postJSON(`/api/test-runs/${sm.runId}/finish`, finishBody, auth);
+      this.logger.info(`Successfully finalized streaming run #${sm.runId}`);
+      if (run.options.serverUrl) {
+        this.logger.info(`View run: ${runUrl(run.options.serverUrl, sm.runId)}`);
+      }
+      this.recovery.clear();
+      if (this.hasReports(run)) {
+        try {
+          await this.uploader.uploadReportsForStreamingRun(
+            run.options.projectName,
+            sm.runId,
+            this.reportOptions(run),
+            run.startTime,
+            auth
+          );
+        } catch (error) {
+          this.logger.warn(`Failed to upload reports for streaming run: ${errorMessage(error)}`);
+        }
+      }
+      return true;
+    } catch (error) {
+      this.logger.warn(`Failed to finalize streaming run: ${errorMessage(error)}`);
+      this.logger.info("Falling back to batch upload...");
+      return false;
+    }
+  }
+  async tryUploadWithFiles(run, overallStatus, duration, auth) {
+    try {
+      await this.uploader.uploadWithFiles(
+        this.buildRunPayload(run, overallStatus, duration),
+        this.reportOptions(run),
+        auth
+      );
+      this.recovery.clear();
+      return true;
+    } catch (error) {
+      if (error instanceof HttpError && error.status === 401 && !auth) {
+        this.logAuthRequired(run.options.serverUrl);
+        throw error;
+      }
+      this.logger.warn(`Failed to upload with files: ${errorMessage(error)}`);
+      this.logger.info("Falling back to JSON upload...");
+      return false;
+    }
+  }
+  async tryUploadJSON(run, overallStatus, duration, auth) {
+    const payload = this.buildRunPayload(run, overallStatus, duration);
+    try {
+      await this.uploader.uploadJSON(payload, auth);
+      this.recovery.clear();
+    } catch (error) {
+      if (error instanceof HttpError && error.status === 401 && !auth) {
+        this.logAuthRequired(run.options.serverUrl);
+        throw error;
+      }
+      this.logger.error(`All upload methods failed: ${errorMessage(error)}`);
+      this.logger.info(
+        `Saved a local recovery copy \u2014 it will be uploaded automatically on your next test run. If this keeps happening, check that serverUrl (${run.options.serverUrl ?? "not set"}) is correct and reachable.`
+      );
+      this.recovery.save(serializeRun(payload, { includeTestCases: true }));
+    }
+  }
+  /** Log one actionable line explaining how to fix a 401 caused by a missing credential. */
+  logAuthRequired(serverUrl) {
+    this.logger.error(
+      `Authentication is required by ${serverUrl ?? "the dashboard"} but no credentials were configured. Create an API key (Settings \u2192 Users on the dashboard) and set the reporter's \`apiKey\` option or the PIWI_API_KEY environment variable.`
+    );
+  }
+};
+
+// src/public/reporter.ts
+function testLocation(test) {
+  const relativeFilePath = path12.relative(process.cwd(), test.location.file).split(path12.sep).join("/");
+  return `${relativeFilePath}:${test.location.line}:${test.location.column}`;
+}
+var PiwiDashboardReporter = class {
+  constructor(rawOptions = {}) {
+    this.testCases = [];
+    this.startTime = null;
+    this.playwrightVersion = null;
+    this.reporterVersion = getReporterVersion();
+    this.totalTests = 0;
+    this.passedTests = 0;
+    this.failedTests = 0;
+    this.skippedTests = 0;
+    this.timedOutTests = 0;
+    this.didNotRunTests = 0;
+    /** Full set of tests Playwright planned to run this shard (captured in `onBegin`). */
+    this.plannedTests = [];
+    /** Ids of tests that actually reported via `onTestEnd`, to find the ones that never ran. */
+    this.reportedTestIds = /* @__PURE__ */ new Set();
+    this.runLabel = null;
+    this.shardInfo = null;
+    this.metadata = {};
+    this.isFullRun = true;
+    this.filterDetails = null;
+    this.streamManager = null;
+    /** Track suite-level setup steps (beforeAll/afterAll) not tied to any test */
+    this.setupSteps = [];
+    this.options = resolveOptions(rawOptions);
+    this.enabled = this.options.enabled !== false && !!this.options.serverUrl;
+    this.runLabel = this.options.runLabel || detectCiRunLabel();
+    this.instanceId = computeInstanceId(this.options.projectName, this.runLabel);
+    const logger = new Logger(this.options.verbose ?? false);
+    this.logger = logger;
+    this.httpClient = new HttpClient(this.options.serverUrl ?? "http://localhost:3000", logger);
+    this.fileHandler = new FileHandler(logger);
+    this.uploader = new Uploader(this.httpClient, this.fileHandler, logger);
+    this.recovery = new CrashRecovery(this.options.projectName, logger);
+    this.metadataCollector = new MetadataCollector(logger);
+    const streamBuffer = new StreamBuffer(this.options.projectName);
+    streamBuffer.clearStale();
+    if (this.options.streaming) {
+      this.streamManager = new StreamManager(
+        this.httpClient,
+        streamBuffer,
+        this.recovery,
+        this.uploader,
+        this.fileHandler,
+        this.options,
+        logger
+      );
+    }
+    this.submitter = new RunSubmitter(this.httpClient, this.uploader, this.recovery, this.streamManager, logger);
+  }
+  static {
+    this.wrapConfig = wrapConfig;
+  }
+  static {
+    this.createGlobalSetup = createGlobalSetup;
+  }
+  /** Playwright reporter hook: called once at the start of the test run */
+  onBegin(config, suite) {
+    if (!this.enabled) {
+      this.logger.info("Not enabled \u2014 set PIWI_DASHBOARD_URL or serverUrl to enable.");
+      return;
+    }
+    this.startTime = (/* @__PURE__ */ new Date()).toISOString();
+    this.playwrightVersion = config.version;
+    this.logger.info(
+      `Starting test run for project: ${this.options.projectName} (Playwright v${this.playwrightVersion})`
+    );
+    const rawConfig = config;
+    const grepRe = rawConfig.grep instanceof RegExp ? rawConfig.grep : void 0;
+    const grepInvertRe = rawConfig.grepInvert instanceof RegExp ? rawConfig.grepInvert : void 0;
+    const grep = grepRe && grepRe.source !== ".*" ? grepRe.source : void 0;
+    const grepInvert = grepInvertRe?.source;
+    const fileFilters = detectCliFileFilters();
+    if (grep || grepInvert || fileFilters.length > 0) {
+      this.isFullRun = false;
+      this.filterDetails = {
+        ...grep ? { grep } : {},
+        ...grepInvert ? { grepInvert } : {},
+        ...fileFilters.length > 0 ? { files: fileFilters } : {}
+      };
+      this.logger.info("Partial run detected (filter active)");
+    }
+    this.metadata = this.metadataCollector.collect(config, suite, this.options);
+    this.plannedTests = suite.allTests();
+    const pwShard = config.shard;
+    if (pwShard?.total && pwShard.total > 1) {
+      this.shardInfo = { current: pwShard.current, total: pwShard.total };
+      this.logger.info(`Shard ${this.shardInfo.current}/${this.shardInfo.total} detected`);
+    }
+    this.streamManager?.start(
+      this.startTime,
+      this.metadata,
+      this.instanceId,
+      this.playwrightVersion,
+      this.reporterVersion,
+      this.shardInfo,
+      this.isFullRun,
+      this.filterDetails
+    );
+  }
+  /** Playwright reporter hook: called when an individual test begins */
+  onTestBegin(test, result) {
+    const { suitePath, suiteConfig } = this.metadataCollector.getSuiteInfo(test);
+    const beginEvent = {
+      type: "begin",
+      title: test.title,
+      location: testLocation(test),
+      workerIndex: workerIndexOf(result),
+      shardIndex: this.shardInfo?.current ?? null,
+      browser: this.metadataCollector.getBrowserConfig(test) || void 0,
+      suitePath,
+      suiteConfig
+    };
+    if (this.streamManager) {
+      this.streamManager.queueBeginEvent(toWireTestCase(beginEvent));
+    }
+  }
+  /** Playwright reporter hook: called when a step (including hook/fixture) begins */
+  onStepBegin(test, _result, step) {
+    if (!this.enabled || !this.streamManager?.enabled) return;
+    const cat = step.category;
+    if (cat !== "hook" && cat !== "fixture") return;
+    const event = {
+      type: "step-begin",
+      title: step.title,
+      location: step.location ? `${step.location.file}:${step.location.line}:${step.location.column}` : "unknown",
+      stepCategory: cat,
+      parentTitle: test?.title || null,
+      workerIndex: workerIndexOf(_result),
+      startedAt: step.startTime instanceof Date ? step.startTime.getTime() : null
+    };
+    this.streamManager?.queueBeginEvent(event);
+  }
+  /** Playwright reporter hook: called when a step (including hook/fixture) ends */
+  onStepEnd(test, _result, step) {
+    const cat = step.category;
+    if (cat === "pw:api") return;
+    if (!this.enabled || !this.streamManager?.enabled) return;
+    if (cat !== "hook" && cat !== "fixture") return;
+    const workerIndex = workerIndexOf(_result);
+    const startedAt = step.startTime instanceof Date ? step.startTime.getTime() : null;
+    const event = {
+      type: "step-end",
+      title: step.title,
+      location: step.location ? `${step.location.file}:${step.location.line}:${step.location.column}` : "unknown",
+      status: step.error ? "failed" : "passed",
+      duration: step.duration || 0,
+      stepCategory: cat,
+      parentTitle: test?.title || null,
+      workerIndex,
+      startedAt
+    };
+    this.streamManager?.queueEvent(event);
+    if (!test && startedAt) {
+      this.setupSteps.push({
+        title: step.title,
+        category: cat,
+        startedAt,
+        duration: step.duration || 0,
+        status: step.error ? "failed" : "passed",
+        location: step.location ? `${step.location.file}:${step.location.line}:${step.location.column}` : null,
+        workerIndex
+      });
+    }
+  }
+  /** Playwright reporter hook: called when an individual test finishes */
+  onTestEnd(test, result) {
+    this.totalTests++;
+    this.reportedTestIds.add(test.id);
+    const { suitePath, suiteConfig } = this.metadataCollector.getSuiteInfo(test);
+    const annotations = mergeAnnotations(test, result);
+    const status = classifyStatus(result.status, annotations);
+    const testCase = {
+      type: "complete",
+      title: test.title,
+      location: testLocation(test),
+      status,
+      duration: result.duration,
+      error: buildErrorText(result),
+      retries: result.retry,
+      workerIndex: workerIndexOf(result),
+      shardIndex: this.shardInfo?.current ?? null,
+      startedAt: result.startTime ? result.startTime.getTime() : null,
+      attachments: result.attachments || [],
+      browser: this.metadataCollector.getBrowserConfig(test) || void 0,
+      suitePath,
+      suiteConfig,
+      testAnnotations: annotations.length ? annotations : null
+    };
+    if (result.status === "failed" || result.status === "timedOut") {
+      const failingLine = extractFailingLine(testCase.error, test.location.file, test.location.line);
+      const snippet = readSourceSnippet(test.location.file, test.location.line, 30, failingLine);
+      if (snippet) testCase.testSource = snippet;
+      const frames = collectSourceFrames(testCase.error, test.location.file, test.location.line);
+      if (frames.length) testCase.testSourceFrames = frames;
+    }
+    if (this.options.collectPerformanceMetrics && result.steps?.length > 0) {
+      testCase.performanceMetrics = collectStepMetrics(result.steps);
+      const stepEvents = extractTestStepEvents(result.steps, result.startTime);
+      const waitEvents = extractWaitEvents(result.steps);
+      const allEvents = [...stepEvents, ...waitEvents];
+      if (allEvents.length > 0) testCase.stepEvents = allEvents;
+    }
+    if (this.options.collectPerformanceMetrics && result.attachments) {
+      this.fileHandler.parsePerformanceAttachments(testCase, result.attachments);
+      const locatorAttachment = this.options.captureLocators !== false ? result.attachments.find((a) => a.name === ATTACHMENT_NAMES.locators) : void 0;
+      if (locatorAttachment?.body) {
+        try {
+          testCase.locatorSnapshots = JSON.parse(locatorAttachment.body.toString());
+        } catch {
+        }
+      }
+    }
+    switch (status) {
+      case "passed":
+        this.passedTests++;
+        break;
+      case "failed":
+        this.failedTests++;
+        break;
+      case "skipped":
+        this.skippedTests++;
+        break;
+      case "didnotrun":
+        this.didNotRunTests++;
+        break;
+      case "timedOut":
+        this.timedOutTests++;
+        break;
+    }
+    this.testCases.push(testCase);
+    if (this.streamManager) {
+      this.streamManager.queueEvent(toWireTestCase(testCase));
+      if (this.options.liveFileUploads) this.streamManager.scheduleLiveUpload(testCase);
+    }
+  }
+  /**
+   * Synthesize `didnotrun` cases for tests Playwright planned but never reported
+   * (no `onTestEnd`) — typically because `maxFailures` cut the run short. These
+   * carry no result, so they're emitted with zero duration and no error. In
+   * streaming mode they're queued as complete events so the pre-finish drain
+   * sends them alongside the rest.
+   */
+  materializeUnrunTests() {
+    for (const test of this.plannedTests) {
+      if (this.reportedTestIds.has(test.id)) continue;
+      const { suitePath, suiteConfig } = this.metadataCollector.getSuiteInfo(test);
+      const testCase = {
+        type: "complete",
+        title: test.title,
+        location: testLocation(test),
+        status: "didnotrun",
+        duration: 0,
+        error: null,
+        retries: 0,
+        workerIndex: null,
+        shardIndex: this.shardInfo?.current ?? null,
+        startedAt: null,
+        attachments: [],
+        browser: this.metadataCollector.getBrowserConfig(test) || void 0,
+        suitePath,
+        suiteConfig,
+        testAnnotations: test.annotations?.length ? test.annotations : null
+      };
+      this.testCases.push(testCase);
+      this.totalTests++;
+      this.didNotRunTests++;
+      if (this.streamManager) {
+        this.streamManager.queueEvent(toWireTestCase(testCase));
+      }
+    }
+  }
+  /** Playwright reporter hook: called when the full test run finishes */
+  async onEnd(result) {
+    if (!this.enabled) return;
+    this.materializeUnrunTests();
+    await this.submitter.submit(
+      {
+        options: this.options,
+        testCases: this.testCases,
+        startTime: this.startTime,
+        playwrightVersion: this.playwrightVersion,
+        reporterVersion: this.reporterVersion,
+        totalTests: this.totalTests,
+        passedTests: this.passedTests,
+        failedTests: this.failedTests,
+        skippedTests: this.skippedTests,
+        timedOutTests: this.timedOutTests,
+        didNotRunTests: this.didNotRunTests,
+        metadata: this.metadata,
+        instanceId: this.instanceId,
+        shardInfo: this.shardInfo,
+        setupSteps: this.setupSteps,
+        isFullRun: this.isFullRun,
+        filterDetails: this.filterDetails
+      },
+      result
+    );
+  }
+};
+
+// src/internal/capture/capture-fixtures.ts
+var import_node_zlib = require("zlib");
+
+// src/internal/capture/locator-healing.ts
+var path13 = __toESM(require("path"));
+
+// ../packages/core/src/locator-fingerprint.ts
+var PRESENT_SIMILARITY = 0.8;
+var MATCH_SIMILARITY = 0.2;
+function parseAriaCandidates(ariaSnapshot) {
+  if (!ariaSnapshot) return [];
+  const out = [];
+  for (const line of ariaSnapshot.split("\n")) {
+    const m = line.match(/^\s*-\s+([a-z]+)(?:\s+"((?:[^"\\]|\\.)*)")?/i);
+    if (!m) continue;
+    const role = m[1];
+    const name = m[2] != null ? m[2].replace(/\\(.)/g, "$1") : null;
+    if (!name && (role === "generic" || role === "group" || role === "list" || role === "paragraph")) continue;
+    const levelMatch = line.slice(m[0].length).match(/\[level=(\d+)\]/);
+    const level = levelMatch ? Number(levelMatch[1]) : null;
+    out.push({ role, name, level });
+  }
+  return out;
+}
+function textSimilarity(a, b) {
+  const tok = (s) => new Set(
+    (s ?? "").toLowerCase().split(/[^a-z0-9]+/i).filter(Boolean)
+  );
+  const sa = tok(a);
+  const sb = tok(b);
+  if (sa.size === 0 && sb.size === 0) return 1;
+  if (sa.size === 0 || sb.size === 0) return 0;
+  let common = 0;
+  for (const t of sa) if (sb.has(t)) common++;
+  return 2 * common / (sa.size + sb.size);
+}
+function fingerprintPresent(fp, candidates) {
+  if (!fp.name) return false;
+  return candidates.some(
+    (c) => (!fp.role || c.role === fp.role) && textSimilarity(c.name, fp.name) >= PRESENT_SIMILARITY
+  );
+}
+function matchRenamedElement(fp, candidates) {
+  if (candidates.length === 0) return null;
+  const sameRole = fp.role ? candidates.filter((c) => c.role === fp.role) : candidates;
+  if (sameRole.length === 0) return null;
+  let pool = sameRole;
+  if (fp.level != null) {
+    const sameLevel = sameRole.filter((c) => c.level === fp.level);
+    if (sameLevel.length > 0) pool = sameLevel;
+  }
+  if (pool.length === 1) {
+    return { candidate: pool[0], confidence: 0.7 };
+  }
+  let best = null;
+  let bestScore = -1;
+  for (const c of pool) {
+    const s = textSimilarity(c.name, fp.name);
+    if (s > bestScore) {
+      bestScore = s;
+      best = c;
+    }
+  }
+  if (best && bestScore >= MATCH_SIMILARITY) return { candidate: best, confidence: bestScore };
+  const pos = fp.rolePosition;
+  if (pos && fp.role && pos.role === fp.role && sameRole.length >= 2 && sameRole.length === pos.count) {
+    const byIndex = sameRole[pos.index];
+    if (byIndex) return { candidate: byIndex, confidence: 0.5 };
+  }
+  return null;
+}
+
+// ../packages/core/src/locator-methods.ts
+var LOCATOR_BUILDER_METHODS = [
+  "getByRole",
+  "getByTestId",
+  "getByText",
+  "getByLabel",
+  "getByPlaceholder",
+  "getByAltText",
+  "getByTitle",
+  "locator"
+];
+
+// ../packages/core/src/locator-generation.ts
+var TAG_TO_ROLE = {
+  a: "link",
+  button: "button",
+  nav: "navigation",
+  main: "main",
+  article: "article",
+  section: "region",
+  form: "form",
+  img: "img",
+  figure: "figure",
+  figcaption: "caption",
+  blockquote: "blockquote",
+  table: "table",
+  ul: "list",
+  ol: "list",
+  li: "listitem",
+  dialog: "dialog",
+  output: "status",
+  progress: "progressbar",
+  meter: "meter",
+  textarea: "textbox",
+  h1: "heading",
+  h2: "heading",
+  h3: "heading",
+  h4: "heading",
+  h5: "heading",
+  h6: "heading",
+  details: "group",
+  summary: "button",
+  search: "search"
+};
+var INPUT_TYPE_TO_ROLE = {
+  button: "button",
+  submit: "button",
+  reset: "button",
+  image: "button",
+  checkbox: "checkbox",
+  radio: "radio",
+  range: "slider",
+  search: "searchbox",
+  number: "spinbutton",
+  text: "textbox",
+  email: "textbox",
+  tel: "textbox",
+  url: "textbox",
+  password: "textbox"
+};
+var CAPTURED_ATTRIBUTES = [
+  "id",
+  "class",
+  "name",
+  "data-testid",
+  "placeholder",
+  "alt",
+  "title",
+  "aria-label",
+  "aria-level",
+  "role",
+  "type",
+  "href",
+  "multiple"
+];
+function resolveAriaRole(attrs) {
+  const explicit = attrs.attributes["role"];
+  if (explicit) return explicit;
+  const tag = attrs.tagName;
+  if (!tag) return null;
+  if (tag === "input") {
+    const type = (attrs.attributes["type"] ?? "text").toLowerCase();
+    return INPUT_TYPE_TO_ROLE[type] ?? "textbox";
+  }
+  if (tag === "select") {
+    return attrs.attributes["multiple"] != null ? "listbox" : "combobox";
+  }
+  if (tag === "a") {
+    return attrs.attributes["href"] != null ? "link" : null;
+  }
+  return TAG_TO_ROLE[tag] ?? null;
+}
+function headingLevel(attrs, role) {
+  if (role !== "heading") return null;
+  const tagMatch = attrs.tagName.match(/^h([1-6])$/);
+  if (tagMatch) return Number(tagMatch[1]);
+  const ariaLevel = attrs.attributes["aria-level"];
+  if (ariaLevel && /^\d+$/.test(ariaLevel)) return Number(ariaLevel);
+  return null;
+}
+var attr = (a, key) => a.attributes[key] || null;
+var esc = (s) => s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+var escCssAttrValue = (s) => s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+var isCssSafeId = (id) => /^[A-Za-z][A-Za-z0-9_-]*$/.test(id);
+function classifyCssStability(className) {
+  if (/[a-f0-9]{8,}/i.test(className)) return 10;
+  if (/^(?:css|sc|emotion|styled)-/i.test(className)) return 15;
+  if (/^(bg|text|border|shadow|opacity|font|w-|h-|m[tblrxy]?-|p[tblrxy]?-|flex|grid|gap|rounded|absolute|relative|fixed|sticky|block|inline|hidden|overflow|z-|top-|right-|bottom-|left-|inset-|justify-|items-|self-|content-|order-|col-|row-)/.test(
+    className
+  ))
+    return 25;
+  if (/__/.test(className) || /--/.test(className)) return 35;
+  if (/^[a-z]+(-[a-z]+)+$/.test(className)) return 40;
+  if (/^[a-z]+[A-Z][a-zA-Z]+$/.test(className)) return 40;
+  if (className.includes("_")) return 15;
+  if (/^[a-z]+-[a-z0-9]{5,}$/.test(className) && /[0-9]/.test(className)) return 15;
+  return 15;
+}
+function isAutoGenerated(value) {
+  if (/^[a-f0-9]{8}-([a-f0-9]{4}-){3}[a-f0-9]{12}$/i.test(value)) return true;
+  if (/^[a-f0-9]{8,}$/i.test(value)) return true;
+  if (/^[a-z]+-\d+$/.test(value)) return true;
+  if (/^(emotion-|styled-|css-|sc-)/.test(value)) return true;
+  if (value.startsWith("ng-")) return true;
+  if (/^(radix-|headlessui-|mui-|mantine-|chakra-)/i.test(value)) return true;
+  if (/^:r[0-9a-z]+:$/i.test(value) || /^«r[0-9a-z]+»$/i.test(value)) return true;
+  return false;
+}
+function generateAlternatives(attrs) {
+  const alts = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (loc) => {
+    if (!seen.has(loc.locator)) {
+      seen.add(loc.locator);
+      alts.push(loc);
+    }
+  };
+  const { accessibleName } = attrs;
+  const tag = attrs.tagName;
+  const role = resolveAriaRole(attrs);
+  const counts = attrs.selectorCounts;
+  const isUnique = (n) => n == null || n <= 1;
+  const text = attrs.textContent ? attrs.textContent.replace(/\s+/g, " ").trim() : null;
+  const testId = attr(attrs, "data-testid");
+  if (testId && isUnique(counts?.testId)) {
+    add({
+      locator: `getByTestId('${esc(testId)}')`,
+      method: "getByTestId",
+      args: { testId },
+      score: 100
+    });
+  }
+  const level = headingLevel(attrs, role);
+  const levelPart = level != null ? `, level: ${level}` : "";
+  const withLevel = (base) => level != null ? { ...base, level } : base;
+  if (role && accessibleName) {
+    add({
+      locator: `getByRole('${role}', { name: '${esc(accessibleName)}'${levelPart} })`,
+      method: "getByRole",
+      args: withLevel({ role, name: accessibleName }),
+      score: 90
+    });
+  }
+  const ariaLabel = attr(attrs, "aria-label");
+  if (role && ariaLabel && ariaLabel !== accessibleName) {
+    add({
+      locator: `getByRole('${role}', { name: '${esc(ariaLabel)}'${levelPart} })`,
+      method: "getByRole",
+      args: withLevel({ role, name: ariaLabel }),
+      score: 85
+    });
+  }
+  if (accessibleName && ["input", "select", "textarea"].includes(tag)) {
+    const label = attr(attrs, "aria-label");
+    const labelBacked = attrs.hasLabel === void 0 ? true : attrs.hasLabel === true || label === accessibleName;
+    if (labelBacked) {
+      add({
+        locator: `getByLabel('${esc(accessibleName)}')`,
+        method: "getByLabel",
+        args: { label: accessibleName },
+        score: 85
+      });
+    }
+  }
+  const placeholder = attr(attrs, "placeholder");
+  if (placeholder) {
+    add({
+      locator: `getByPlaceholder('${esc(placeholder)}')`,
+      method: "getByPlaceholder",
+      args: { placeholder },
+      score: 80
+    });
+  }
+  if (text && text.length < 80) {
+    add({
+      locator: `getByText('${esc(text)}')`,
+      method: "getByText",
+      args: { text },
+      score: 75
+    });
+  }
+  const id = attr(attrs, "id");
+  if (id && !isAutoGenerated(id) && isUnique(counts?.id)) {
+    const selector = isCssSafeId(id) ? `#${id}` : `[id="${escCssAttrValue(id)}"]`;
+    add({
+      locator: `locator('${esc(selector)}')`,
+      method: "locator",
+      args: { selector },
+      score: 65
+    });
+  }
+  const name = attr(attrs, "name");
+  if (name && isUnique(counts?.name)) {
+    const selector = `[name="${escCssAttrValue(name)}"]`;
+    add({
+      locator: `locator('${esc(selector)}')`,
+      method: "locator",
+      args: { selector },
+      score: 60
+    });
+  }
+  const alt = attr(attrs, "alt");
+  if (alt) {
+    add({
+      locator: `getByAltText('${esc(alt)}')`,
+      method: "getByAltText",
+      args: { text: alt },
+      score: 60
+    });
+  }
+  const title = attr(attrs, "title");
+  if (title) {
+    add({
+      locator: `getByTitle('${esc(title)}')`,
+      method: "getByTitle",
+      args: { title },
+      score: 50
+    });
+  }
+  const hasOwnTestId = !!(testId && isUnique(counts?.testId));
+  if (role && !hasOwnTestId) {
+    const rolePart = level != null ? `'${role}', { level: ${level} }` : `'${role}'`;
+    const leafArgs = withLevel({ role });
+    let testIdAnchorDone = false;
+    let idAnchorDone = false;
+    let roleAnchorDone = false;
+    for (const anc of attrs.ancestors ?? []) {
+      if (anc.scopedRoleCount !== 1) continue;
+      if (!testIdAnchorDone && anc.testId && anc.testIdCount === 1) {
+        testIdAnchorDone = true;
+        add({
+          locator: `getByTestId('${esc(anc.testId)}').getByRole(${rolePart})`,
+          method: "getByRole",
+          args: { ...leafArgs, anchorTestId: anc.testId },
+          score: 72
+        });
+      }
+      if (!idAnchorDone && anc.id && !isAutoGenerated(anc.id) && anc.idCount === 1) {
+        idAnchorDone = true;
+        const anchorSelector = isCssSafeId(anc.id) ? `#${anc.id}` : `[id="${escCssAttrValue(anc.id)}"]`;
+        add({
+          locator: `locator('${esc(anchorSelector)}').getByRole(${rolePart})`,
+          method: "getByRole",
+          args: { ...leafArgs, anchorSelector },
+          score: 64
+        });
+      }
+      const ancestorRole = anc.role || TAG_TO_ROLE[anc.tag] || null;
+      if (!roleAnchorDone && ancestorRole && ancestorRole !== role && anc.roleCount === 1) {
+        roleAnchorDone = true;
+        add({
+          locator: `getByRole('${esc(ancestorRole)}').getByRole(${rolePart})`,
+          method: "getByRole",
+          args: { ...leafArgs, anchorRole: ancestorRole },
+          score: 55
+        });
+      }
+    }
+    const pos = attrs.rolePosition;
+    if (pos && pos.role === role && (pos.count === 1 || level != null && pos.levelCount === 1)) {
+      add({
+        locator: `getByRole(${rolePart})`,
+        method: "getByRole",
+        args: leafArgs,
+        score: 58
+      });
+    }
+  }
+  const clsStr = attr(attrs, "class");
+  if (clsStr) {
+    const countsClasses = counts?.classes;
+    const classes = clsStr.split(/\s+/).filter((c) => c.length > 1 && /^[A-Za-z_-][A-Za-z0-9_-]*$/.test(c) && isUnique(countsClasses?.[c])).map((cls) => ({ cls, score: classifyCssStability(cls) })).sort((a, b) => b.score - a.score).slice(0, 3);
+    for (const { cls, score } of classes) {
+      add({
+        locator: `locator('.${esc(cls)}')`,
+        method: "locator",
+        args: { selector: `.${cls}` },
+        score
+      });
+    }
+  }
+  return alts.sort((a, b) => b.score - a.score);
+}
+function approximateAccessibleName(attrs) {
+  const a = attrs.attributes;
+  const ariaLabel = a["aria-label"];
+  if (ariaLabel) return ariaLabel;
+  if (attrs.textContent) return attrs.textContent;
+  const title = a["title"];
+  if (title) return title;
+  const placeholder = a["placeholder"];
+  if (placeholder) return placeholder;
+  return null;
+}
+
+// src/internal/capture/locator-healing.ts
+function dedupeSnapshotsByLocation(snaps) {
+  const lastWithElement = /* @__PURE__ */ new Map();
+  const lastAny = /* @__PURE__ */ new Map();
+  snaps.forEach((s, i) => {
+    if (!s.location) return;
+    lastAny.set(s.location, i);
+    if (s.element) lastWithElement.set(s.location, i);
+  });
+  return snaps.filter((s, i) => {
+    if (!s.location) return true;
+    return (lastWithElement.get(s.location) ?? lastAny.get(s.location)) === i;
+  });
+}
+var LOCATOR_METHODS = [...LOCATOR_BUILDER_METHODS];
+var CHAIN_METHODS = [
+  "first",
+  "nth",
+  "last",
+  "filter",
+  "and",
+  "or",
+  "locator",
+  "getByRole",
+  "getByTestId",
+  "getByText",
+  "getByLabel",
+  "getByPlaceholder",
+  "getByAltText",
+  "getByTitle"
+];
+var ACTION_METHODS = [
+  "click",
+  "fill",
+  "check",
+  "uncheck",
+  "selectOption",
+  "dblclick",
+  "tap",
+  "hover",
+  "press",
+  "type",
+  "pressSequentially",
+  "clear",
+  "setInputFiles",
+  "dragTo",
+  "focus",
+  "blur",
+  "scrollIntoViewIfNeeded",
+  "dispatchEvent",
+  "selectText",
+  // Not an action, but a successful waitFor proves the element resolved — the
+  // closest capture hook available for assertion-style usage of a locator.
+  "waitFor"
+];
+var LOCATOR_CREATING_CHAINS = new Set(LOCATOR_METHODS);
+function extractAccessibleName(ariaSnapshot) {
+  if (!ariaSnapshot) return null;
+  const match = ariaSnapshot.match(/- \w+ "([^"]+)"/);
+  if (match) return match[1];
+  return null;
+}
+var NAME_BASED_METHODS = /* @__PURE__ */ new Set([
+  "getByText",
+  "getByRole",
+  "getByLabel",
+  "getByPlaceholder",
+  "getByTitle",
+  "getByAltText"
+]);
+var escAttr = (s) => s.replaceAll("\\", "\\\\").replaceAll("'", "\\'");
+var SUGG_TEXT_ROLES = /* @__PURE__ */ new Set([
+  "button",
+  "link",
+  "heading",
+  "menuitem",
+  "tab",
+  "option",
+  "cell",
+  "columnheader",
+  "rowheader",
+  "gridcell",
+  "treeitem",
+  "listitem",
+  "checkbox",
+  "radio",
+  "switch"
+]);
+var SUGG_FIELD_ROLES = /* @__PURE__ */ new Set(["textbox", "combobox", "searchbox", "spinbutton", "slider"]);
+function failedNameAndRole(failed) {
+  if (failed.method === "getByRole") {
+    const role = typeof failed.args[0] === "string" ? failed.args[0] : null;
+    const opts = failed.args[1];
+    const name = opts && typeof opts.name === "string" ? opts.name : null;
+    const level = opts && typeof opts.level === "number" ? opts.level : null;
+    return { role, name, level };
+  }
+  const first = failed.args.find((a) => typeof a === "string");
+  return { role: null, name: typeof first === "string" ? first : null, level: null };
+}
+function renderFailing(failed) {
+  const { role, name } = failedNameAndRole(failed);
+  if (failed.method === "getByRole") {
+    return name ? `getByRole('${escAttr(role ?? "")}', { name: '${escAttr(name)}' })` : `getByRole('${escAttr(role ?? "")}')`;
+  }
+  return `${failed.method}('${escAttr(name ?? "")}')`;
+}
+function freshSuggestions(candidate, failedMethod) {
+  const out = [];
+  const role = candidate.role;
+  const name = candidate.name;
+  const push = (s) => {
+    if (!out.includes(s)) out.push(s);
+  };
+  const levelPart = candidate.level != null ? `, level: ${candidate.level}` : "";
+  const roleLoc = `getByRole('${escAttr(role)}', { name: '${escAttr(name)}'${levelPart} })`;
+  const textLoc = `getByText('${escAttr(name)}')`;
+  const labelLoc = `getByLabel('${escAttr(name)}')`;
+  if (failedMethod === "getByText" && SUGG_TEXT_ROLES.has(role)) push(textLoc);
+  if (failedMethod === "getByLabel" && SUGG_FIELD_ROLES.has(role)) push(labelLoc);
+  push(roleLoc);
+  if (SUGG_TEXT_ROLES.has(role)) push(textLoc);
+  else if (SUGG_FIELD_ROLES.has(role)) push(labelLoc);
+  return out;
+}
+function suggestLocatorsFromAria(failed, ariaSnapshot) {
+  if (!ariaSnapshot || !NAME_BASED_METHODS.has(failed.method)) return null;
+  const { role, name, level } = failedNameAndRole(failed);
+  if (!name) return null;
+  const candidates = parseAriaCandidates(ariaSnapshot);
+  if (candidates.length === 0) return null;
+  const fingerprint = { role, name, level };
+  if (fingerprintPresent(fingerprint, candidates)) return null;
+  const best = matchRenamedElement(fingerprint, candidates)?.candidate;
+  if (!best || !best.name) return null;
+  const suggestions = freshSuggestions({ role: best.role, name: best.name, level: best.level }, failed.method);
+  if (suggestions.length === 0) return null;
+  return { failing: renderFailing(failed), suggestions };
+}
+function captureCallerLocation(stack = new Error().stack ?? "") {
+  const lines = stack.split("\n");
+  let prevWasCaptureModule = false;
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (!line.startsWith("at")) continue;
+    const m = line.match(/^at\s+(?:(.+?)\s+\()?(.+?):(\d+):(\d+)\)?$/);
+    if (!m) {
+      prevWasCaptureModule = false;
+      continue;
+    }
+    let file = m[2];
+    if (!file || file.startsWith("node:")) {
+      prevWasCaptureModule = false;
+      continue;
+    }
+    file = file.replace(/^file:\/\/\/?/, "");
+    if (!/\.[a-z]+$/i.test(file)) {
+      prevWasCaptureModule = false;
+      continue;
+    }
+    if (/[\\/]locator-healing\.[a-z]+$/i.test(file)) {
+      prevWasCaptureModule = true;
+      continue;
+    }
+    if (prevWasCaptureModule && /[\\/](?:capture-)?fixtures\.[a-z]+$/i.test(file)) {
+      prevWasCaptureModule = false;
+      continue;
+    }
+    if (/[\\/]node_modules[\\/]/.test(file)) {
+      prevWasCaptureModule = false;
+      continue;
+    }
+    let rel = file;
+    try {
+      rel = path13.relative(process.cwd(), file);
+    } catch {
+    }
+    rel = rel.split(path13.sep).join("/");
+    if (rel.startsWith("./")) rel = rel.slice(2);
+    return `${rel}:${m[3]}:${m[4]}`;
+  }
+  return null;
+}
+
+// src/internal/capture/inspect-on-failure.ts
+function isCi(ci) {
+  return ci !== void 0 && ci !== "" && ci !== "false";
+}
+function shouldInspectOnFailure(gate) {
+  if (gate.enabled !== "true") return false;
+  if (isCi(gate.ci)) return false;
+  if (gate.headless !== false) return false;
+  if (gate.status !== "failed" && gate.status !== "timedOut") return false;
+  if (gate.status === gate.expectedStatus) return false;
+  return gate.retry >= gate.retries;
+}
+function environmentalSkipReason(gate) {
+  if (gate.enabled !== "true") return null;
+  if (gate.status !== "failed" && gate.status !== "timedOut") return null;
+  if (gate.status === gate.expectedStatus) return null;
+  if (isCi(gate.ci)) return "running under CI \u2014 this is a headed, local-only feature";
+  if (gate.headless !== false) {
+    return "the browser is headless \u2014 re-run with --headed (or set use: { headless: false })";
+  }
+  return null;
+}
+function inspectionGateFromTestInfo(testInfo, enabled = process.env.PIWI_INSPECT_ON_FAIL) {
+  const use = testInfo.project?.use ?? {};
+  return {
+    enabled,
+    ci: process.env.CI,
+    status: testInfo.status,
+    expectedStatus: testInfo.expectedStatus,
+    headless: use.headless,
+    retry: testInfo.retry,
+    retries: testInfo.project?.retries ?? 0
+  };
+}
+
+// src/internal/capture/pick-on-failure.ts
+var path14 = __toESM(require("path"));
+var ANSI_RE = /\[[0-9;]*m/g;
+function endOfString(s, start) {
+  const q = s[start];
+  for (let i = start + 1; i < s.length; i++) {
+    if (s[i] === "\\") {
+      i++;
+      continue;
+    }
+    if (s[i] === q) return i;
+  }
+  return s.length - 1;
+}
+function matchBrace(s, start) {
+  let depth = 0;
+  for (let i = start; i < s.length; i++) {
+    if (s[i] === "{") depth++;
+    else if (s[i] === "}" && --depth === 0) return i;
+  }
+  return s.length - 1;
+}
+function parseOptions(src) {
+  const obj = {};
+  const re = /(\w+)\s*:\s*('(?:\\.|[^'])*'|"(?:\\.|[^"])*"|true|false|-?\d+)/g;
+  let m;
+  while ((m = re.exec(src)) !== null) {
+    const key = m[1];
+    const raw = m[2];
+    if (raw === "true") obj[key] = true;
+    else if (raw === "false") obj[key] = false;
+    else if (/^-?\d+$/.test(raw)) obj[key] = Number(raw);
+    else obj[key] = raw.slice(1, -1).replace(/\\(.)/g, "$1");
+  }
+  return obj;
+}
+function parseArgs(inner) {
+  const args = [];
+  let i = 0;
+  while (i < inner.length) {
+    const c = inner[i];
+    if (c === " " || c === ",") {
+      i++;
+      continue;
+    }
+    if (c === "'" || c === '"') {
+      const end = endOfString(inner, i);
+      args.push(inner.slice(i + 1, end).replace(/\\(.)/g, "$1"));
+      i = end + 1;
+      continue;
+    }
+    if (c === "{") {
+      const end = matchBrace(inner, i);
+      args.push(parseOptions(inner.slice(i, end + 1)));
+      i = end + 1;
+      continue;
+    }
+    i++;
+  }
+  return args;
+}
+function leafExpression(expr) {
+  let depth = 0;
+  let leafStart = 0;
+  for (let i = 0; i < expr.length - 1; i++) {
+    const c = expr[i];
+    if (c === "'" || c === '"') {
+      i = endOfString(expr, i);
+      continue;
+    }
+    if (c === "(") depth++;
+    else if (c === ")") {
+      depth--;
+      if (depth === 0 && expr[i + 1] === ".") leafStart = i + 2;
+    }
+  }
+  return expr.slice(leafStart);
+}
+function parseLeafLocatorExpression(rawExpr) {
+  const expr = leafExpression(rawExpr.trim());
+  const m = /^([A-Za-z]+)\((.*)\)$/s.exec(expr);
+  if (!m) return null;
+  return { method: m[1], args: parseArgs(m[2].trim()) };
+}
+function deriveFailedLocator(testInfo) {
+  const info = testInfo;
+  const errors = info.errors && info.errors.length > 0 ? info.errors : info.error ? [info.error] : [];
+  for (const err of errors) {
+    const text = `${err.message ?? ""}
+${err.stack ?? ""}`.replace(ANSI_RE, "");
+    const line = /^\s*Locator:\s*(.+)$/m.exec(text);
+    if (!line) continue;
+    const parsed = parseLeafLocatorExpression(line[1].trim());
+    if (!parsed) continue;
+    const loc = err.location;
+    const location = loc ? `${path14.relative(process.cwd(), loc.file).split(path14.sep).join("/")}:${loc.line}:${loc.column}` : null;
+    return { method: parsed.method, args: parsed.args, location };
+  }
+  return null;
+}
+var escStr = (s) => s.replaceAll("\\", "\\\\").replaceAll("'", "\\'");
+var cssIdSelector = (id) => /^[A-Za-z_][A-Za-z0-9_-]*$/.test(id) ? `#${id}` : `[id="${id.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"]`;
+var ANCHOR_KIND_SCORES = { testid: 80, id: 74, labeledRole: 68, role: 62 };
+function anchorSegment(a) {
+  if (a.testId && a.testIdCount === 1) {
+    return { code: `getByTestId('${escStr(a.testId)}')`, kind: "testid", flatArgs: { anchorTestId: a.testId } };
+  }
+  if (a.id && !isAutoGenerated(a.id) && a.idCount === 1) {
+    const anchorSelector = cssIdSelector(a.id);
+    return { code: `locator('${escStr(anchorSelector)}')`, kind: "id", flatArgs: { anchorSelector } };
+  }
+  if (a.role && a.ariaLabel && a.labeledRoleCount === 1) {
+    return {
+      code: `getByRole('${escStr(a.role)}', { name: '${escStr(a.ariaLabel)}' })`,
+      kind: "labeledRole",
+      flatArgs: { anchorRole: a.role, anchorName: a.ariaLabel }
+    };
+  }
+  if (a.role && a.roleCount === 1) {
+    return { code: `getByRole('${escStr(a.role)}')`, kind: "role", flatArgs: { anchorRole: a.role } };
+  }
+  return null;
+}
+function generateAnchoredAlternatives(leaf, anchors, chainLeafCount) {
+  if (!leaf.role || anchors.length === 0) return [];
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const rolePart = leaf.level != null ? `'${leaf.role}', { level: ${leaf.level} }` : `'${leaf.role}'`;
+  const leafArgs = leaf.level != null ? { role: leaf.role, level: leaf.level } : { role: leaf.role };
+  const add = (l) => {
+    if (!seen.has(l.locator)) {
+      seen.add(l.locator);
+      out.push(l);
+    }
+  };
+  for (const anchor of anchors) {
+    if (anchor.scopedLeafCount !== 1) continue;
+    const seg = anchorSegment(anchor);
+    if (!seg) continue;
+    add({
+      locator: `${seg.code}.getByRole(${rolePart})`,
+      method: "getByRole",
+      args: { ...leafArgs, ...seg.flatArgs },
+      score: ANCHOR_KIND_SCORES[seg.kind]
+    });
+  }
+  if (anchors.length >= 2 && chainLeafCount === 1) {
+    const ordered = [...anchors].sort((a, b) => b.depth - a.depth);
+    const segments = ordered.map(anchorSegment);
+    if (segments.every((s) => s !== null)) {
+      const innermost = segments[segments.length - 1];
+      const score = Math.min(...segments.map((s) => ANCHOR_KIND_SCORES[s.kind]));
+      add({
+        locator: `${segments.map((s) => s.code).join(".")}.getByRole(${rolePart})`,
+        method: "getByRole",
+        // Flat args describe the innermost anchor (what the healing fingerprint
+        // logic understands); the full chain rides along for transparency.
+        args: { ...leafArgs, ...innermost.flatArgs, anchorChain: segments.map((s) => s.code) },
+        score
+      });
+    }
+  }
+  return out.sort((a, b) => b.score - a.score);
+}
+function mergeCandidates(base, extra) {
+  const seen = new Set(base.map((b) => b.locator));
+  const merged = [...base];
+  for (const e of extra) {
+    if (seen.has(e.locator)) continue;
+    seen.add(e.locator);
+    merged.push(e);
+  }
+  return merged.sort((a, b) => b.score - a.score);
+}
+function installPickerOverlay(arg) {
+  const g = globalThis;
+  const doc = g.document;
+  if (!doc || !doc.body) {
+    g.__piwiPickState = "skipped";
+    return;
+  }
+  const Z = 2147483600;
+  const highlight = doc.createElement("div");
+  highlight.style.cssText = `position:fixed;pointer-events:none;z-index:${Z};display:none;box-sizing:border-box;border:2px solid #7c3aed;background:rgba(124,58,237,.12);border-radius:3px;`;
+  const banner = doc.createElement("div");
+  banner.style.cssText = `position:fixed;top:12px;left:50%;transform:translateX(-50%);z-index:${Z + 2};background:#111827;color:#f9fafb;font:13px/1.5 system-ui,sans-serif;padding:10px 16px;border-radius:8px;box-shadow:0 4px 24px rgba(0,0,0,.4);max-width:80vw;`;
+  const hlLocator = (expr) => {
+    const escHtml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+    const re = /('(?:\\.|[^'])*'|"(?:\\.|[^"])*")|([A-Za-z_$][\w$]*)(?=\s*\()|([A-Za-z_$][\w$]*)(?=\s*:)|(true|false|null|\d+)|([{}(),.])/g;
+    let html = "";
+    let last = 0;
+    let m;
+    while ((m = re.exec(expr)) !== null) {
+      if (m.index > last) html += escHtml(expr.slice(last, m.index));
+      const color = m[1] ? "#4ade80" : m[2] ? "#c084fc" : m[3] ? "#93c5fd" : m[4] ? "#fbbf24" : "#9ca3af";
+      html += `<span style="color:${color}">${escHtml(m[0])}</span>`;
+      last = re.lastIndex;
+    }
+    if (last < expr.length) html += escHtml(expr.slice(last));
+    return `<code style="font-family:ui-monospace,SFMono-Regular,Menlo,monospace">${html}</code>`;
+  };
+  const head = doc.createElement("div");
+  head.innerHTML = arg.failing ? `Piwi locator picker \u2014 click the element that should replace ${hlLocator(arg.failing)}` : "Piwi inspector \u2014 click any element to generate locators for it";
+  const foot = doc.createElement("div");
+  foot.style.cssText = "color:#9ca3af;margin-top:3px;";
+  foot.textContent = "\u2191 parent \xB7 \u2193 child \xB7 Esc skip";
+  banner.appendChild(head);
+  banner.appendChild(foot);
+  doc.body.appendChild(highlight);
+  doc.body.appendChild(banner);
+  const escJs = (s) => s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+  const describe = (el) => {
+    const tag = (el.tagName || "?").toLowerCase();
+    const testId = el.getAttribute && el.getAttribute("data-testid");
+    if (testId) return `getByTestId('${escJs(testId)}')`;
+    if (el.labels && el.labels.length > 0) {
+      const labelText = (el.labels[0].textContent || "").replace(/\s+/g, " ").trim().slice(0, 80);
+      if (labelText) return `getByLabel('${escJs(labelText)}')`;
+    }
+    const ariaLabel = el.getAttribute && el.getAttribute("aria-label");
+    if (ariaLabel) return `getByLabel('${escJs(ariaLabel)}')`;
+    const placeholder = el.getAttribute && el.getAttribute("placeholder");
+    if (placeholder) return `getByPlaceholder('${escJs(placeholder)}')`;
+    const alt = el.getAttribute && el.getAttribute("alt");
+    if (alt) return `getByAltText('${escJs(alt)}')`;
+    const titleAttr = el.getAttribute && el.getAttribute("title");
+    if (titleAttr) return `getByTitle('${escJs(titleAttr)}')`;
+    if (el.id) return `locator('#${escJs(el.id)}')`;
+    const cls = (el.getAttribute && el.getAttribute("class") || "").split(/\s+/).find((c) => c.length > 1);
+    return cls ? `locator('.${escJs(cls)}')` : tag;
+  };
+  const buildChain = (raw) => {
+    const chain2 = [];
+    let node = raw;
+    while (node && chain2.length < 15) {
+      const tag = (node.tagName || "").toLowerCase();
+      if (tag === "body" || tag === "html") break;
+      chain2.push(node);
+      node = node.parentElement;
+    }
+    return chain2.length ? chain2 : [raw];
+  };
+  const ACTIONABLE_TAGS = ["button", "a", "input", "select", "textarea", "summary", "option"];
+  const snapIndex = (chain2) => {
+    for (let i = 0; i < Math.min(chain2.length, 4); i++) {
+      const el = chain2[i];
+      const tag = (el.tagName || "").toLowerCase();
+      if (ACTIONABLE_TAGS.includes(tag)) return i;
+      if (el.getAttribute && (el.getAttribute("role") || el.getAttribute("data-testid"))) return i;
+    }
+    return 0;
+  };
+  let chain = [];
+  let idx = 0;
+  let lastRaw = null;
+  const current = () => chain[idx] ?? null;
+  const refresh = () => {
+    const el = current();
+    if (!el) {
+      highlight.style.display = "none";
+      return;
+    }
+    const r = el.getBoundingClientRect();
+    highlight.style.display = "block";
+    highlight.style.left = r.left + "px";
+    highlight.style.top = r.top + "px";
+    highlight.style.width = r.width + "px";
+    highlight.style.height = r.height + "px";
+    foot.textContent = `${describe(el)} \u2014 click to pick \xB7 \u2191 parent \xB7 \u2193 child \xB7 Esc skip`;
+  };
+  const stop = (e) => {
+    e.preventDefault();
+    e.stopImmediatePropagation();
+  };
+  const isOwn = (el) => el === banner || el === highlight || banner.contains && banner.contains(el);
+  let bannerDocked = "top";
+  const dockBanner = (side) => {
+    if (bannerDocked === side) return;
+    bannerDocked = side;
+    if (side === "bottom") {
+      banner.style.top = "auto";
+      banner.style.bottom = "12px";
+    } else {
+      banner.style.top = "12px";
+      banner.style.bottom = "auto";
+    }
+  };
+  const onMove = (e) => {
+    const raw = e.target;
+    if (!raw || isOwn(raw)) {
+      highlight.style.display = "none";
+      return;
+    }
+    if (raw !== lastRaw) {
+      lastRaw = raw;
+      chain = buildChain(raw);
+      idx = snapIndex(chain);
+    }
+    refresh();
+    const el = current();
+    if (el) {
+      const r = el.getBoundingClientRect();
+      const br = banner.getBoundingClientRect();
+      const margin = 8;
+      if (r.left < br.right + margin && r.right > br.left - margin && r.top < br.bottom + margin && r.bottom > br.top - margin) {
+        dockBanner(bannerDocked === "top" ? "bottom" : "top");
+      }
+    }
+  };
+  const onClick = (e) => {
+    stop(e);
+    const el = current();
+    if (!el || isOwn(e.target)) return;
+    g.__piwiPickedElement = el;
+    g.__piwiPickState = "picked";
+    removeListeners();
+    highlight.style.display = "none";
+    foot.textContent = "Analyzing element\u2026";
+  };
+  const onKey = (e) => {
+    if (e.key === "Escape") {
+      stop(e);
+      g.__piwiPickState = "skipped";
+      cleanup();
+      return;
+    }
+    if (e.key === "ArrowUp" || e.key === "ArrowDown") {
+      stop(e);
+      if (e.key === "ArrowUp") idx = Math.min(idx + 1, chain.length - 1);
+      else idx = Math.max(idx - 1, 0);
+      refresh();
+    }
+  };
+  const suppressed = ["mousedown", "mouseup", "pointerdown", "pointerup", "auxclick", "dblclick"];
+  const removeListeners = () => {
+    doc.removeEventListener("mousemove", onMove, true);
+    doc.removeEventListener("click", onClick, true);
+    doc.removeEventListener("keydown", onKey, true);
+    for (const t of suppressed) doc.removeEventListener(t, stop, true);
+  };
+  const cleanup = () => {
+    removeListeners();
+    highlight.remove();
+    banner.remove();
+  };
+  g.__piwiPickCleanup = cleanup;
+  doc.addEventListener("mousemove", onMove, true);
+  doc.addEventListener("click", onClick, true);
+  doc.addEventListener("keydown", onKey, true);
+  for (const t of suppressed) doc.addEventListener(t, stop, true);
+}
+function showAnchorPicker(arg) {
+  const g = globalThis;
+  const doc = g.document;
+  const el = g.__piwiPickedElement;
+  if (!doc || !doc.body || !el) {
+    g.__piwiAnchorState = "skipped";
+    return;
+  }
+  const Z = 2147483600;
+  const { tagRoles, inputRoles, roleSources, leafRole, leafLevel, leafTestId } = arg;
+  const roleOf = (n) => {
+    const explicit = n.getAttribute && n.getAttribute("role");
+    if (explicit) return explicit;
+    const tag = (n.tagName || "").toLowerCase();
+    if (tag === "input") return inputRoles[(n.getAttribute("type") || "text").toLowerCase()] ?? "textbox";
+    if (tag === "select") return n.getAttribute("multiple") != null ? "listbox" : "combobox";
+    if (tag === "a") return n.getAttribute("href") != null ? "link" : null;
+    return tagRoles[tag] ?? null;
+  };
+  const levelOf = (n) => {
+    const m = /^h([1-6])$/.exec((n.tagName || "").toLowerCase());
+    if (m) return Number(m[1]);
+    const al = n.getAttribute && n.getAttribute("aria-level");
+    return al && /^\d+$/.test(al) ? Number(al) : null;
+  };
+  const leafMatches = (scope) => {
+    try {
+      if (leafTestId) return scope.querySelectorAll(`[data-testid=${JSON.stringify(leafTestId)}]`).length;
+      const nodes = scope.querySelectorAll(roleSources);
+      if (nodes.length > 2e3) return -1;
+      let matched = 0;
+      for (let i = 0; i < nodes.length; i++) {
+        const n = nodes[i];
+        if (roleOf(n) !== leafRole) continue;
+        if (leafLevel != null && levelOf(n) !== leafLevel) continue;
+        matched++;
+      }
+      return matched;
+    } catch {
+      return -1;
+    }
+  };
+  let roleNodes = [];
+  try {
+    const all = doc.querySelectorAll(roleSources);
+    if (all.length <= 4e3) roleNodes = Array.from(all);
+  } catch {
+    roleNodes = [];
+  }
+  const count = (sel) => {
+    try {
+      return doc.querySelectorAll(sel).length;
+    } catch {
+      return void 0;
+    }
+  };
+  const rows = [];
+  let node = el.parentElement;
+  let depth = 0;
+  while (node && depth < 12) {
+    depth++;
+    const tag = (node.tagName || "").toLowerCase();
+    if (tag === "body" || tag === "html") break;
+    const testId = node.getAttribute("data-testid");
+    const id = node.getAttribute("id");
+    const ariaLabel = node.getAttribute("aria-label");
+    const role = roleOf(node);
+    const info = { tag, depth, testId: testId || null, id: id || null, ariaLabel: ariaLabel || null, role };
+    if (testId) info.testIdCount = count(`[data-testid=${JSON.stringify(testId)}]`);
+    if (id) {
+      try {
+        info.idCount = count(`#${doc.defaultView.CSS.escape(id)}`);
+      } catch {
+      }
+    }
+    if (role) {
+      let roleCount = 0;
+      let labeledCount = 0;
+      for (const n of roleNodes) {
+        if (roleOf(n) !== role) continue;
+        roleCount++;
+        if (ariaLabel && n.getAttribute && n.getAttribute("aria-label") === ariaLabel) labeledCount++;
+      }
+      info.roleCount = roleCount;
+      if (ariaLabel) info.labeledRoleCount = labeledCount;
+    }
+    info.scopedLeafCount = leafMatches(node);
+    const hookLabel = testId ? `data-testid="${testId}"` : id ? `#${id}` : ariaLabel && role ? `${role} "${ariaLabel}"` : role ? `role ${role}` : "no stable hook";
+    rows.push({
+      node,
+      info,
+      hookLabel,
+      selectable: !!(testId || id || role && (ariaLabel || info.roleCount === 1))
+    });
+    node = node.parentElement;
+  }
+  if (rows.length === 0) {
+    g.__piwiAnchorState = "skipped";
+    return;
+  }
+  const outline = doc.createElement("div");
+  outline.style.cssText = `position:fixed;pointer-events:none;z-index:${Z};box-sizing:border-box;border:2px solid #22c55e;border-radius:3px;display:none;`;
+  const pickedOutline = doc.createElement("div");
+  const pr = el.getBoundingClientRect();
+  pickedOutline.style.cssText = `position:fixed;pointer-events:none;z-index:${Z};box-sizing:border-box;border:2px solid #7c3aed;background:rgba(124,58,237,.10);border-radius:3px;left:${pr.left}px;top:${pr.top}px;width:${pr.width}px;height:${pr.height}px;`;
+  const panel = doc.createElement("div");
+  panel.style.cssText = `position:fixed;top:12px;right:12px;z-index:${Z + 3};width:340px;max-height:82vh;overflow:auto;background:#111827;color:#f9fafb;border-radius:10px;padding:16px;font:12px/1.5 system-ui,sans-serif;box-shadow:0 8px 40px rgba(0,0,0,.5);`;
+  const title = doc.createElement("div");
+  title.style.cssText = "font-weight:600;font-size:13px;margin-bottom:2px;";
+  title.textContent = "Scope to stable parents (optional)";
+  const sub = doc.createElement("div");
+  sub.style.cssText = "color:#9ca3af;margin-bottom:10px;";
+  sub.textContent = "Pick one or more parents to anchor the locator to. Hover a row to see the parent.";
+  panel.appendChild(title);
+  panel.appendChild(sub);
+  const selected = /* @__PURE__ */ new Set();
+  const footer = doc.createElement("div");
+  footer.style.cssText = "margin:10px 0;font-weight:600;";
+  const segMatches = (scope, info) => {
+    try {
+      if (info.testId) return Array.from(scope.querySelectorAll(`[data-testid=${JSON.stringify(info.testId)}]`));
+      if (info.id) return Array.from(scope.querySelectorAll(`#${doc.defaultView.CSS.escape(info.id)}`));
+      const nodes = Array.from(scope.querySelectorAll(roleSources));
+      if (nodes.length > 2e3) return [];
+      return nodes.filter(
+        (n) => roleOf(n) === info.role && (!info.ariaLabel || n.getAttribute && n.getAttribute("aria-label") === info.ariaLabel)
+      );
+    } catch {
+      return [];
+    }
+  };
+  const chainCount = () => {
+    const chosen = rows.filter((_, i) => selected.has(i)).sort((a, b) => b.info.depth - a.info.depth);
+    if (chosen.length === 0) return -1;
+    let scopes = [doc];
+    for (const row of chosen) {
+      const next = [];
+      for (const s of scopes) next.push(...segMatches(s, row.info));
+      scopes = next.slice(0, 200);
+      if (scopes.length === 0) return 0;
+    }
+    let total = 0;
+    for (const s of scopes) {
+      const c = leafMatches(s);
+      if (c > 0) total += c;
+      if (total > 50) return total;
+    }
+    return total;
+  };
+  const refreshFooter = () => {
+    if (selected.size === 0) {
+      footer.textContent = "No parents selected \u2014 standard alternatives only.";
+      footer.style.color = "#9ca3af";
+      g.__piwiPickChainCount = void 0;
+      return;
+    }
+    const c = chainCount();
+    g.__piwiPickChainCount = c;
+    if (c === 1) {
+      footer.textContent = "\u2713 Selection matches exactly 1 element";
+      footer.style.color = "#4ade80";
+    } else {
+      footer.textContent = c < 0 ? "Match count unavailable" : `\u2717 Selection matches ${c} elements`;
+      footer.style.color = "#fbbf24";
+    }
+  };
+  rows.forEach((row, i) => {
+    const line = doc.createElement("label");
+    line.style.cssText = `display:flex;align-items:center;gap:8px;padding:6px 8px;border:1px solid #374151;border-radius:6px;margin-bottom:6px;cursor:${row.selectable ? "pointer" : "default"};opacity:${row.selectable ? "1" : ".45"};`;
+    const box = doc.createElement("input");
+    box.type = "checkbox";
+    box.disabled = !row.selectable;
+    const text = doc.createElement("span");
+    text.style.cssText = "flex:1;min-width:0;";
+    const code = doc.createElement("code");
+    code.style.cssText = "display:block;font:11px ui-monospace,monospace;color:#e5e7eb;word-break:break-all;";
+    code.textContent = `<${row.info.tag}> ${row.hookLabel}`;
+    const hint = doc.createElement("span");
+    hint.style.cssText = "color:#9ca3af;";
+    hint.textContent = row.selectable ? row.info.scopedLeafCount === 1 ? "contains exactly 1 matching element" : `contains ${row.info.scopedLeafCount ?? "?"} matching elements` : "add a data-testid to make this usable";
+    text.appendChild(code);
+    text.appendChild(hint);
+    line.appendChild(box);
+    line.appendChild(text);
+    line.addEventListener("mouseenter", () => {
+      const r = row.node.getBoundingClientRect();
+      outline.style.display = "block";
+      outline.style.left = r.left + "px";
+      outline.style.top = r.top + "px";
+      outline.style.width = r.width + "px";
+      outline.style.height = r.height + "px";
+    });
+    line.addEventListener("mouseleave", () => {
+      outline.style.display = "none";
+    });
+    box.addEventListener("change", () => {
+      if (box.checked) selected.add(i);
+      else selected.delete(i);
+      refreshFooter();
+    });
+    panel.appendChild(line);
+  });
+  panel.appendChild(footer);
+  const cleanup = () => {
+    doc.removeEventListener("keydown", onKey, true);
+    panel.remove();
+    outline.remove();
+    pickedOutline.remove();
+  };
+  const done = (state) => {
+    g.__piwiPickAnchors = state === "done" ? rows.filter((_, i) => selected.has(i)).map((r) => r.info) : [];
+    g.__piwiAnchorState = state;
+    cleanup();
+  };
+  const onKey = (e) => {
+    if (e.key !== "Escape") return;
+    e.preventDefault();
+    e.stopImmediatePropagation();
+    done("skipped");
+  };
+  const buttonRow = doc.createElement("div");
+  buttonRow.style.cssText = "display:flex;gap:8px;margin-top:4px;";
+  const useBtn = doc.createElement("button");
+  useBtn.style.cssText = "flex:1;background:#7c3aed;color:#fff;border:none;border-radius:6px;padding:8px;cursor:pointer;font:600 12px system-ui;";
+  useBtn.textContent = "Use selected parents";
+  useBtn.addEventListener("click", (e) => {
+    e.preventDefault();
+    e.stopImmediatePropagation();
+    done(selected.size > 0 ? "done" : "skipped");
+  });
+  const skipBtn = doc.createElement("button");
+  skipBtn.style.cssText = "background:none;border:1px solid #374151;color:#9ca3af;border-radius:6px;padding:8px 10px;cursor:pointer;font:12px system-ui;";
+  skipBtn.textContent = "Skip (Esc)";
+  skipBtn.addEventListener("click", (e) => {
+    e.preventDefault();
+    e.stopImmediatePropagation();
+    done("skipped");
+  });
+  buttonRow.appendChild(useBtn);
+  buttonRow.appendChild(skipBtn);
+  panel.appendChild(buttonRow);
+  refreshFooter();
+  g.__piwiAnchorCleanup = cleanup;
+  doc.addEventListener("keydown", onKey, true);
+  doc.body.appendChild(pickedOutline);
+  doc.body.appendChild(outline);
+  doc.body.appendChild(panel);
+}
+function showPickerChoices(arg) {
+  const g = globalThis;
+  const doc = g.document;
+  if (!doc || !doc.body) {
+    g.__piwiPickChoice = -1;
+    return;
+  }
+  const Z = 2147483600;
+  const wrap = doc.createElement("div");
+  wrap.style.cssText = `position:fixed;inset:0;z-index:${Z + 3};background:rgba(0,0,0,.45);display:flex;align-items:center;justify-content:center;font:13px/1.5 system-ui,sans-serif;`;
+  const panel = doc.createElement("div");
+  panel.style.cssText = "background:#111827;color:#f9fafb;border-radius:10px;padding:20px;max-width:640px;width:90vw;max-height:70vh;overflow:auto;box-shadow:0 8px 40px rgba(0,0,0,.5);";
+  const hlLocator = (expr) => {
+    const escHtml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+    const re = /('(?:\\.|[^'])*'|"(?:\\.|[^"])*")|([A-Za-z_$][\w$]*)(?=\s*\()|([A-Za-z_$][\w$]*)(?=\s*:)|(true|false|null|\d+)|([{}(),.])/g;
+    let html = "";
+    let last = 0;
+    let m;
+    while ((m = re.exec(expr)) !== null) {
+      if (m.index > last) html += escHtml(expr.slice(last, m.index));
+      const color = m[1] ? "#4ade80" : m[2] ? "#c084fc" : m[3] ? "#93c5fd" : m[4] ? "#fbbf24" : "#9ca3af";
+      html += `<span style="color:${color}">${escHtml(m[0])}</span>`;
+      last = re.lastIndex;
+    }
+    if (last < expr.length) html += escHtml(expr.slice(last));
+    return html;
+  };
+  const title = doc.createElement("div");
+  title.style.cssText = "font-weight:600;margin-bottom:4px;";
+  title.textContent = arg.failing ? "Pick a replacement locator" : "Pick a locator";
+  const sub = doc.createElement("div");
+  sub.style.cssText = "color:#9ca3af;margin-bottom:12px;";
+  if (arg.failing) {
+    sub.innerHTML = `Replaces <code style="font-family:ui-monospace,Menlo,monospace">${hlLocator(arg.failing)}</code> \u2014 ranked by stability score.`;
+  } else {
+    sub.textContent = "For the element you picked \u2014 ranked by stability score.";
+  }
+  panel.appendChild(title);
+  panel.appendChild(sub);
+  const done = (choice) => {
+    g.__piwiPickChoice = choice;
+    doc.removeEventListener("keydown", onKey, true);
+    wrap.remove();
+  };
+  const onKey = (e) => {
+    if (e.key !== "Escape") return;
+    e.preventDefault();
+    e.stopImmediatePropagation();
+    done(-1);
+  };
+  arg.choices.forEach((c, i) => {
+    const btn = doc.createElement("button");
+    btn.style.cssText = "display:flex;justify-content:space-between;align-items:center;gap:12px;width:100%;text-align:left;background:#1f2937;color:#e5e7eb;border:1px solid #374151;border-radius:6px;padding:8px 12px;margin:0 0 8px;cursor:pointer;font:12px/1.5 ui-monospace,SFMono-Regular,Menlo,monospace;";
+    const code = doc.createElement("span");
+    code.innerHTML = hlLocator(c.locator);
+    code.style.cssText = "word-break:break-all;";
+    const score = doc.createElement("span");
+    score.textContent = String(c.score);
+    score.style.cssText = "color:#a78bfa;flex-shrink:0;";
+    btn.appendChild(code);
+    btn.appendChild(score);
+    btn.addEventListener("click", (e) => {
+      e.preventDefault();
+      e.stopImmediatePropagation();
+      done(i);
+    });
+    panel.appendChild(btn);
+  });
+  const skip = doc.createElement("button");
+  skip.style.cssText = "background:none;border:none;color:#9ca3af;cursor:pointer;padding:6px 0 0;font:12px system-ui,sans-serif;";
+  skip.textContent = "Skip \u2014 keep the failure as-is (Esc)";
+  skip.addEventListener("click", (e) => {
+    e.preventDefault();
+    e.stopImmediatePropagation();
+    done(-1);
+  });
+  panel.appendChild(skip);
+  doc.addEventListener("keydown", onKey, true);
+  wrap.appendChild(panel);
+  doc.body.appendChild(wrap);
+}
+async function cleanupPicker(page) {
+  try {
+    await page.evaluate(() => {
+      const g = globalThis;
+      if (typeof g.__piwiPickCleanup === "function") g.__piwiPickCleanup();
+      if (typeof g.__piwiAnchorCleanup === "function") g.__piwiAnchorCleanup();
+      delete g.__piwiPickCleanup;
+      delete g.__piwiAnchorCleanup;
+      delete g.__piwiPickState;
+      delete g.__piwiPickChoice;
+      delete g.__piwiPickedElement;
+      delete g.__piwiAnchorState;
+      delete g.__piwiPickAnchors;
+      delete g.__piwiPickChainCount;
+    });
+  } catch {
+  }
+}
+async function runLocatorPicker(page, testInfo, failed, probe) {
+  try {
+    testInfo.setTimeout(0);
+    const rendered = failed ? renderFailing(failed) : null;
+    console.log(
+      `
+[piwi] "${testInfo.title}" ${testInfo.status} \u2014 ${rendered ? "locator picker" : "inspector"} open in the browser: ${rendered ? `click the element that should replace ${rendered}` : "click any element to generate locators for it"} (\u2191/\u2193 to select a parent/child, Esc to skip).`
+    );
+    await page.evaluate(installPickerOverlay, { failing: rendered });
+    await page.waitForFunction(() => globalThis.__piwiPickState !== void 0, void 0, {
+      timeout: 0,
+      polling: 250
+    });
+    const state = await page.evaluate(() => globalThis.__piwiPickState);
+    if (state !== "picked") {
+      await cleanupPicker(page);
+      return null;
+    }
+    const handle = await page.evaluateHandle(() => globalThis.__piwiPickedElement);
+    const attrs = await handle.evaluate(probe.fn, probe.arg);
+    await handle.dispose();
+    const accessibleName = approximateAccessibleName({ ...attrs, accessibleName: null });
+    const role = resolveAriaRole({ ...attrs, accessibleName });
+    const level = headingLevel({ ...attrs, accessibleName }, role);
+    let anchors = [];
+    let chainLeafCount;
+    if (role) {
+      const probeArg = probe.arg;
+      await page.evaluate(showAnchorPicker, {
+        tagRoles: probeArg.tagRoles,
+        inputRoles: probeArg.inputRoles,
+        roleSources: probeArg.roleSources,
+        leafRole: role,
+        leafLevel: level,
+        leafTestId: attrs.attributes["data-testid"] ?? null
+      });
+      await page.waitForFunction(() => globalThis.__piwiAnchorState !== void 0, void 0, {
+        timeout: 0,
+        polling: 250
+      });
+      const anchorResult = await page.evaluate(() => {
+        const g = globalThis;
+        return { state: g.__piwiAnchorState, anchors: g.__piwiPickAnchors ?? [], chainCount: g.__piwiPickChainCount };
+      });
+      if (anchorResult.state === "done" && anchorResult.anchors.length > 0) {
+        anchors = anchorResult.anchors;
+        chainLeafCount = anchorResult.chainCount;
+      }
+    }
+    const ranked = mergeCandidates(
+      generateAlternatives({ ...attrs, accessibleName }),
+      generateAnchoredAlternatives({ role, level }, anchors, chainLeafCount)
+    );
+    if (ranked.length === 0) {
+      console.log("[piwi] No stable locator could be generated for the picked element \u2014 nothing recorded.");
+      await cleanupPicker(page);
+      return null;
+    }
+    await page.evaluate(showPickerChoices, {
+      failing: rendered,
+      choices: ranked.map((r) => ({ locator: r.locator, score: r.score }))
+    });
+    await page.waitForFunction(() => globalThis.__piwiPickChoice !== void 0, void 0, {
+      timeout: 0,
+      polling: 250
+    });
+    const choice = await page.evaluate(() => globalThis.__piwiPickChoice);
+    await cleanupPicker(page);
+    if (typeof choice !== "number" || choice < 0 || choice >= ranked.length) return null;
+    const picked = { ...ranked[choice], pickedByUser: true };
+    const alternatives = [picked, ...ranked.filter((_, i) => i !== choice)];
+    const element = {
+      tagName: attrs.tagName,
+      attributes: attrs.attributes,
+      textContent: attrs.textContent,
+      accessibleName,
+      center: attrs.center,
+      ...attrs.rolePosition ? { rolePosition: attrs.rolePosition } : {},
+      ...attrs.ancestors && attrs.ancestors.length > 0 ? { ancestors: attrs.ancestors } : {}
+    };
+    const location = failed?.location ?? null;
+    console.log(
+      failed ? `[piwi] Replacement picked for ${rendered}${location ? ` at ${location}` : ""}:
+[piwi]   ${picked.locator}` : `[piwi] Locator picked while inspecting:
+[piwi]   ${picked.locator}`
+    );
+    return {
+      failing: failed ? { method: failed.method, args: failed.args, rendered, location } : null,
+      picked,
+      alternatives,
+      element,
+      ...anchors.length > 0 ? { anchors } : {}
+    };
+  } catch {
+    return null;
+  }
+}
+function applyPickToSnapshots(snapshots, pick) {
+  if (!pick.failing?.location) return false;
+  const failing = pick.failing;
+  for (let i = snapshots.length - 1; i >= 0; i--) {
+    const snap = snapshots[i];
+    if (snap.location !== failing.location || snap.element) continue;
+    snapshots[i] = {
+      location: snap.location,
+      used: snap.used,
+      element: pick.element,
+      alternatives: pick.alternatives.slice(0, 10)
+    };
+    return true;
+  }
+  snapshots.push({
+    location: failing.location,
+    used: {
+      method: failing.method,
+      args: failing.args,
+      raw: `${failing.method}(${JSON.stringify(failing.args)})`
+    },
+    element: pick.element,
+    alternatives: pick.alternatives.slice(0, 10)
+  });
+  return true;
+}
+
+// src/internal/capture/capture-fixtures.ts
+function computeCoreVitals(lcpEntries, shiftEntries, eventEntries) {
+  const lastLcp = lcpEntries && lcpEntries.length > 0 ? lcpEntries[lcpEntries.length - 1] : null;
+  const lcp = lastLcp && typeof lastLcp.startTime === "number" ? Math.round(lastLcp.startTime) : null;
+  let cls = null;
+  if (shiftEntries) {
+    const sum = shiftEntries.reduce(
+      (acc, e) => acc + (e.hadRecentInput ? 0 : typeof e.value === "number" ? e.value : 0),
+      0
+    );
+    cls = Math.round(sum * 1e4) / 1e4;
+  }
+  let inp = null;
+  if (eventEntries && eventEntries.length > 0) {
+    const byInteraction = /* @__PURE__ */ new Map();
+    for (const e of eventEntries) {
+      if (typeof e.interactionId !== "number" || e.interactionId <= 0) continue;
+      const duration = typeof e.duration === "number" ? e.duration : 0;
+      const prev = byInteraction.get(e.interactionId) ?? 0;
+      if (duration > prev) byInteraction.set(e.interactionId, duration);
+    }
+    const durations = [...byInteraction.values()].sort((a, b) => a - b);
+    if (durations.length > 0) {
+      const index = durations.length > 50 ? Math.floor(durations.length * 0.98) : durations.length - 1;
+      inp = Math.round(durations[Math.min(index, durations.length - 1)]);
+    }
+  }
+  if (lcp === null && cls === null && inp === null) return null;
+  return { lcp, cls, inp };
+}
+function createSink() {
+  return {
+    networkRequests: [],
+    consoleEntries: [],
+    pendingHandlers: [],
+    capturedLocators: [],
+    capturePromises: [],
+    failedLocators: [],
+    lastActivePage: null,
+    testInfo: null,
+    stashedWebVitals: null,
+    stashedPageState: null,
+    stashedAria: null,
+    pickOffered: false,
+    userPick: null
+  };
+}
+var currentSink = null;
+var PENDING_PROBES = /* @__PURE__ */ new Set();
+async function drainPendingProbes(capMs) {
+  if (PENDING_PROBES.size === 0) return;
+  let cap;
+  await Promise.race([
+    Promise.allSettled(PENDING_PROBES),
+    new Promise((resolve5) => {
+      cap = setTimeout(resolve5, capMs);
+    })
+  ]);
+  clearTimeout(cap);
+}
+function isPageClosed(page) {
+  try {
+    return typeof page.isClosed === "function" ? page.isClosed() : false;
+  } catch {
+    return false;
+  }
+}
+function pageContext(page) {
+  try {
+    return typeof page.context === "function" ? page.context() : null;
+  } catch {
+    return null;
+  }
+}
+async function readWebVitals(page) {
+  try {
+    const probe = await page.evaluate(async () => {
+      const navEntries = performance.getEntriesByType("navigation");
+      const paintEntries = performance.getEntriesByType("paint");
+      const nav = navEntries[0];
+      const navigation = nav ? {
+        url: nav.name,
+        ttfb: Math.round(nav.responseStart - nav.fetchStart),
+        domInteractive: Math.round(nav.domInteractive - nav.fetchStart),
+        domContentLoaded: Math.round(nav.domContentLoadedEventEnd - nav.fetchStart),
+        loadComplete: Math.round(nav.loadEventEnd - nav.fetchStart),
+        transferSize: nav.transferSize || 0,
+        encodedBodySize: nav.encodedBodySize || 0,
+        decodedBodySize: nav.decodedBodySize || 0
+      } : null;
+      const paint = {};
+      for (const entry of paintEntries) {
+        const key = entry.name.replace(/-([a-z])/g, (_, l) => l.toUpperCase());
+        paint[key] = Math.round(entry.startTime);
+      }
+      const readBuffered = (type, extra) => new Promise((resolve5) => {
+        try {
+          const PO = globalThis.PerformanceObserver;
+          if (!PO || !(PO.supportedEntryTypes || []).includes(type)) return resolve5(null);
+          const out = [];
+          const po = new PO((list) => out.push(...list.getEntries()));
+          po.observe({ type, buffered: true, ...extra });
+          setTimeout(() => {
+            try {
+              out.push(...po.takeRecords());
+              po.disconnect();
+            } catch {
+            }
+            resolve5(out);
+          }, 0);
+        } catch {
+          resolve5(null);
+        }
+      });
+      const [lcpRaw, shiftRaw, eventRaw, firstInputRaw] = await Promise.all([
+        readBuffered("largest-contentful-paint"),
+        readBuffered("layout-shift"),
+        // durationThreshold 40 mirrors the web-vitals library — captures every
+        // interaction slow enough to matter without flooding the buffer.
+        readBuffered("event", { durationThreshold: 40 }),
+        readBuffered("first-input")
+      ]);
+      const project = (entries) => entries === null ? null : entries.map((e) => ({
+        startTime: e.startTime,
+        value: e.value,
+        hadRecentInput: e.hadRecentInput,
+        interactionId: e.interactionId,
+        duration: e.duration
+      }));
+      const interactionEntries = eventRaw === null && firstInputRaw === null ? null : [...eventRaw ?? [], ...firstInputRaw ?? []];
+      return {
+        navigation,
+        paint,
+        lcpEntries: project(lcpRaw),
+        shiftEntries: project(shiftRaw),
+        eventEntries: project(interactionEntries)
+      };
+    });
+    if (!probe) return null;
+    const vitals = computeCoreVitals(probe.lcpEntries, probe.shiftEntries, probe.eventEntries);
+    if (!probe.navigation && Object.keys(probe.paint).length === 0 && !vitals) return null;
+    return { navigation: probe.navigation, paint: probe.paint, vitals };
+  } catch {
+    return null;
+  }
+}
+var PAGE_STATE_MAX_STORAGE_KEYS = 50;
+var PAGE_STATE_MAX_COOKIES = 30;
+var PAGE_STATE_HISTORY_CAP = 2048;
+var TOKEN_MASK_RES = [/\beyJ[\w-]{10,}\.[\w-]{5,}\.[\w-]{5,}\b/g, /\b[0-9a-f]{32,}\b/gi];
+function buildPageState(raw, cookies) {
+  let historyState = raw.historyState;
+  if (historyState) {
+    for (const re of TOKEN_MASK_RES) historyState = historyState.replace(re, "[masked]");
+    if (historyState.length > PAGE_STATE_HISTORY_CAP) {
+      historyState = historyState.slice(0, PAGE_STATE_HISTORY_CAP) + "\u2026";
+    }
+  }
+  const capStorage = (entries) => (Array.isArray(entries) ? entries : []).slice(0, PAGE_STATE_MAX_STORAGE_KEYS).map((e) => ({
+    key: String(e.key).slice(0, 200),
+    length: typeof e.length === "number" ? e.length : 0
+  }));
+  return {
+    url: raw.url,
+    hash: raw.hash || null,
+    historyState: historyState || null,
+    localStorage: capStorage(raw.localStorage),
+    sessionStorage: capStorage(raw.sessionStorage),
+    cookies: (cookies ?? []).slice(0, PAGE_STATE_MAX_COOKIES).map((c) => ({
+      name: String(c.name ?? ""),
+      domain: String(c.domain ?? ""),
+      path: String(c.path ?? ""),
+      httpOnly: Boolean(c.httpOnly),
+      secure: Boolean(c.secure),
+      ...c.sameSite !== void 0 ? { sameSite: String(c.sameSite) } : {},
+      ...typeof c.expires === "number" ? { expires: c.expires } : {}
+    }))
+  };
+}
+async function readPageState(page) {
+  try {
+    const raw = await page.evaluate(() => {
+      const listStorage = (s) => {
+        const out = [];
+        try {
+          for (let i = 0; i < s.length; i++) {
+            const key = s.key(i);
+            if (key != null) out.push({ key, length: (s.getItem(key) ?? "").length });
+          }
+        } catch {
+        }
+        return out;
+      };
+      const g = globalThis;
+      let historyState = null;
+      try {
+        historyState = g.history?.state == null ? null : JSON.stringify(g.history.state);
+      } catch {
+      }
+      return {
+        url: g.location.href,
+        hash: g.location.hash || null,
+        historyState,
+        localStorage: listStorage(globalThis.localStorage),
+        sessionStorage: listStorage(globalThis.sessionStorage)
+      };
+    });
+    if (!raw) return null;
+    let cookies = null;
+    try {
+      cookies = await pageContext(page)?.cookies() ?? null;
+    } catch {
+      cookies = null;
+    }
+    return buildPageState(raw, cookies);
+  } catch {
+    return null;
+  }
+}
+async function stashPageState(sink, closing) {
+  const page = sink.lastActivePage;
+  if (!page || isPageClosed(page)) return;
+  const belongsToClosing = closing.page === page || closing.context !== void 0 && pageContext(page) === closing.context;
+  if (!belongsToClosing) return;
+  const vitals = await readWebVitals(page);
+  if (vitals) sink.stashedWebVitals = vitals;
+  if (process.env.PIWI_CAPTURE_PAGE_STATE !== "false") {
+    const pageState = await readPageState(page);
+    if (pageState) sink.stashedPageState = pageState;
+  }
+  const status = sink.testInfo?.status;
+  if (status === "failed" || status === "timedOut" || status === "interrupted") {
+    const aria = await ariaSnapshotBestEffort(page.locator(":root"), 1e3);
+    if (aria) sink.stashedAria = aria;
+  }
+}
+async function maybeOpenPicker(sink, closing) {
+  if (sink.pickOffered) return;
+  const page = sink.lastActivePage;
+  const testInfo = sink.testInfo;
+  if (!page || !testInfo || isPageClosed(page)) return;
+  if (closing) {
+    const belongsToClosing = closing.page === page || closing.context !== void 0 && pageContext(page) === closing.context;
+    if (!belongsToClosing) return;
+  }
+  const pickGate = shouldInspectOnFailure(inspectionGateFromTestInfo(testInfo, process.env.PIWI_PICK_LOCATOR_ON_FAIL));
+  const inspectGate = shouldInspectOnFailure(inspectionGateFromTestInfo(testInfo, process.env.PIWI_INSPECT_ON_FAIL));
+  if (!pickGate && !inspectGate) return;
+  sink.pickOffered = true;
+  const failed = sink.failedLocators[sink.failedLocators.length - 1] ?? deriveFailedLocator(testInfo);
+  if (!failed && !inspectGate) {
+    console.log("[piwi] locator picker: no failing locator could be identified in this failure \u2014 nothing to replace.");
+    return;
+  }
+  const pick = await runLocatorPicker(page, testInfo, failed, { fn: probeElementAttrs, arg: CAPTURED_ATTRS_ARG });
+  if (!pick) return;
+  sink.userPick = pick;
+  applyPickToSnapshots(sink.capturedLocators, pick);
+}
+var INSTRUMENTED_PAGES = /* @__PURE__ */ new WeakSet();
+var INSTRUMENTED_CONTEXTS = /* @__PURE__ */ new WeakSet();
+var PATCHED_BROWSERS = /* @__PURE__ */ new WeakSet();
+var CHAIN_METHOD_SET = new Set(CHAIN_METHODS);
+var ACTION_METHOD_SET = new Set(ACTION_METHODS);
+var FORM_FIELD_TAGS = /* @__PURE__ */ new Set(["input", "select", "textarea"]);
+var CAPTURED_ATTRS_ARG = {
+  keep: [...CAPTURED_ATTRIBUTES],
+  tagRoles: TAG_TO_ROLE,
+  inputRoles: INPUT_TYPE_TO_ROLE,
+  // '[role]' plus every tag the maps can resolve (input/select are handled by
+  // special-cased logic in the probe, so add them explicitly).
+  roleSources: [.../* @__PURE__ */ new Set(["[role]", "input", "select", ...Object.keys(TAG_TO_ROLE)])].join(",")
+};
+async function ariaSnapshotBestEffort(target, timeout) {
+  if (typeof target.ariaSnapshot !== "function") return null;
+  try {
+    return await target.ariaSnapshot({
+      ...timeout != null ? { timeout } : {},
+      mode: "ai"
+    });
+  } catch {
+    try {
+      return await target.ariaSnapshot({
+        ...timeout != null ? { timeout } : {},
+        ref: true
+      });
+    } catch {
+      return null;
+    }
+  }
+}
+function probeElementAttrs(el, arg) {
+  const { keep, tagRoles, inputRoles, roleSources } = arg;
+  const attrMap = {};
+  for (const key of keep) {
+    const v = el.getAttribute(key) ?? el[key];
+    attrMap[key] = typeof v === "string" ? v.slice(0, 200) : v ? String(v).slice(0, 200) : null;
+  }
+  const r = el.getBoundingClientRect();
+  const selectorCounts = {};
+  try {
+    const doc = el.ownerDocument;
+    const cssEsc = (s) => doc.defaultView.CSS.escape(s);
+    const count = (sel) => {
+      try {
+        return doc.querySelectorAll(sel).length;
+      } catch {
+        return void 0;
+      }
+    };
+    if (attrMap["data-testid"]) {
+      selectorCounts.testId = count(`[data-testid=${JSON.stringify(attrMap["data-testid"])}]`);
+    }
+    if (attrMap["id"]) selectorCounts.id = count(`#${cssEsc(attrMap["id"])}`);
+    if (attrMap["name"]) selectorCounts.name = count(`[name=${JSON.stringify(attrMap["name"])}]`);
+    const classList = (attrMap["class"] || "").split(/\s+/).filter((c) => c.length > 1).slice(0, 10);
+    if (classList.length > 0) {
+      const classCounts = {};
+      for (const cls of classList) {
+        const n = count(`.${cssEsc(cls)}`);
+        if (n !== void 0) classCounts[cls] = n;
+      }
+      selectorCounts.classes = classCounts;
+    }
+  } catch {
+  }
+  let rolePosition = null;
+  const ancestors = [];
+  try {
+    const doc = el.ownerDocument;
+    const cssEsc = (s) => doc.defaultView.CSS.escape(s);
+    const count = (sel) => {
+      try {
+        return doc.querySelectorAll(sel).length;
+      } catch {
+        return void 0;
+      }
+    };
+    const roleOf = (n) => {
+      const explicit = n.getAttribute("role");
+      if (explicit) return explicit;
+      const tag = (n.tagName || "").toLowerCase();
+      if (tag === "input") return inputRoles[(n.getAttribute("type") || "text").toLowerCase()] ?? "textbox";
+      if (tag === "select") return n.getAttribute("multiple") != null ? "listbox" : "combobox";
+      if (tag === "a") return n.getAttribute("href") != null ? "link" : null;
+      return tagRoles[tag] ?? null;
+    };
+    const levelOf = (n) => {
+      const m = /^h([1-6])$/.exec((n.tagName || "").toLowerCase());
+      if (m) return Number(m[1]);
+      const al = n.getAttribute("aria-level");
+      return al && /^\d+$/.test(al) ? Number(al) : null;
+    };
+    const targetRole = roleOf(el);
+    const targetLevel = targetRole === "heading" ? levelOf(el) : null;
+    if (targetRole) {
+      const nodes = doc.querySelectorAll(roleSources);
+      if (nodes.length <= 4e3) {
+        let roleCountAll = 0;
+        let index = -1;
+        let levelCount = 0;
+        for (let i = 0; i < nodes.length; i++) {
+          const n = nodes[i];
+          if (roleOf(n) !== targetRole) continue;
+          if (n === el) index = roleCountAll;
+          roleCountAll++;
+          if (targetLevel != null && levelOf(n) === targetLevel) levelCount++;
+        }
+        if (index !== -1) {
+          rolePosition = {
+            role: targetRole,
+            count: roleCountAll,
+            index,
+            ...targetLevel != null ? { levelCount } : {}
+          };
+        }
+        const CONTAINER_TAGS = ["form", "nav", "main", "article", "section", "dialog", "table"];
+        const docRoleCount = (role) => {
+          let c = 0;
+          for (let i = 0; i < nodes.length; i++) if (roleOf(nodes[i]) === role) c++;
+          return c;
+        };
+        let node = el.parentElement;
+        let depth = 0;
+        while (node && depth < 12 && ancestors.length < 4) {
+          depth++;
+          const tag = (node.tagName || "").toLowerCase();
+          if (tag === "body" || tag === "html") break;
+          const testId = node.getAttribute("data-testid");
+          const id = node.getAttribute("id");
+          const explicitRole = node.getAttribute("role");
+          const ariaLabel = node.getAttribute("aria-label");
+          const anchorRole = explicitRole || (CONTAINER_TAGS.includes(tag) ? tagRoles[tag] : null) || null;
+          if (testId || id || anchorRole || ariaLabel) {
+            const scoped = node.querySelectorAll(roleSources);
+            let scopedRoleCount = 0;
+            if (scoped.length <= 2e3) {
+              for (let i = 0; i < scoped.length; i++) {
+                const n = scoped[i];
+                if (roleOf(n) !== targetRole) continue;
+                if (targetLevel != null && levelOf(n) !== targetLevel) continue;
+                scopedRoleCount++;
+              }
+            } else {
+              scopedRoleCount = -1;
+            }
+            ancestors.push({
+              tag,
+              depth,
+              testId: testId || null,
+              id: id || null,
+              role: explicitRole || null,
+              ariaLabel: ariaLabel || null,
+              ...scopedRoleCount >= 0 ? { scopedRoleCount } : {},
+              ...testId ? { testIdCount: count(`[data-testid=${JSON.stringify(testId)}]`) } : {},
+              ...id ? { idCount: count(`#${cssEsc(id)}`) } : {},
+              ...anchorRole ? { roleCount: docRoleCount(anchorRole) } : {}
+            });
+          }
+          node = node.parentElement;
+        }
+      }
+    }
+  } catch {
+  }
+  return {
+    tagName: el.tagName?.toLowerCase?.() ?? "unknown",
+    attributes: attrMap,
+    // Collapse whitespace so multi-line text can't produce a getByText
+    // suggestion with literal newlines in it.
+    textContent: (el.textContent || "").replace(/\s+/g, " ").trim().slice(0, 80),
+    center: {
+      x: Math.round(r.x + r.width / 2),
+      y: Math.round(r.y + r.height / 2)
+    },
+    hasLabel: !!(el.labels && el.labels.length > 0),
+    selectorCounts,
+    rolePosition,
+    ancestors
+  };
+}
+function wrapLocator(page, locator, originMethod, originArgs) {
+  return new Proxy(locator, {
+    get(target, prop) {
+      const original = Reflect.get(target, prop);
+      if (typeof original !== "function") return original;
+      const fn = original;
+      if (CHAIN_METHOD_SET.has(prop)) {
+        return (...args) => {
+          const next = fn.apply(target, args);
+          if (LOCATOR_CREATING_CHAINS.has(prop)) {
+            return wrapLocator(page, next, String(prop), args);
+          }
+          return wrapLocator(page, next, originMethod, originArgs);
+        };
+      }
+      if (!ACTION_METHOD_SET.has(prop)) return original;
+      return async (...callArgs) => {
+        const sink = currentSink;
+        if (!sink) return fn.apply(target, callArgs);
+        sink.lastActivePage = page;
+        const seq = sink.capturedLocators.length;
+        const callerLocation = captureCallerLocation();
+        const used = {
+          method: originMethod,
+          args: originArgs,
+          raw: `${originMethod}(${JSON.stringify(originArgs)})`
+        };
+        sink.capturedLocators.push({
+          location: callerLocation,
+          used,
+          element: null,
+          alternatives: []
+        });
+        let result;
+        try {
+          result = await fn.apply(target, callArgs);
+        } catch (error) {
+          sink.failedLocators.push({ method: originMethod, args: originArgs, location: callerLocation });
+          throw error;
+        }
+        const probe = target.evaluate(probeElementAttrs, CAPTURED_ATTRS_ARG);
+        const settledProbe = probe.then(
+          () => void 0,
+          () => void 0
+        );
+        PENDING_PROBES.add(settledProbe);
+        settledProbe.then(() => PENDING_PROBES.delete(settledProbe));
+        sink.capturePromises.push(settledProbe);
+        const resolveAttrs = (async () => {
+          let deadline;
+          try {
+            const attrs = await Promise.race([
+              probe,
+              new Promise((_, reject) => {
+                deadline = setTimeout(() => reject(new Error("locator capture timeout")), 500);
+              })
+            ]);
+            const role = resolveAriaRole({ ...attrs, accessibleName: null });
+            const isFormField = FORM_FIELD_TAGS.has(attrs.tagName);
+            const aria = role || isFormField ? await ariaSnapshotBestEffort(target, 500) : null;
+            const accessibleName = extractAccessibleName(aria) || approximateAccessibleName({ ...attrs, accessibleName: null });
+            sink.capturedLocators[seq] = {
+              location: callerLocation,
+              used,
+              // hasLabel/selectorCounts inform alternative generation only —
+              // keep the stored element to the wire shape. rolePosition and
+              // ancestors ARE wire fields: the server's renamed-element match
+              // uses them at heal time.
+              element: {
+                tagName: attrs.tagName,
+                attributes: attrs.attributes,
+                textContent: attrs.textContent,
+                accessibleName,
+                center: attrs.center,
+                ...attrs.rolePosition ? { rolePosition: attrs.rolePosition } : {},
+                ...attrs.ancestors && attrs.ancestors.length > 0 ? { ancestors: attrs.ancestors } : {}
+              },
+              alternatives: generateAlternatives({ ...attrs, accessibleName })
+            };
+          } catch {
+          } finally {
+            clearTimeout(deadline);
+          }
+        })();
+        sink.capturePromises.push(resolveAttrs);
+        return result;
+      };
+    }
+  });
+}
+function instrumentPage(page) {
+  if (!page || INSTRUMENTED_PAGES.has(page)) return;
+  INSTRUMENTED_PAGES.add(page);
+  const ctx = pageContext(page);
+  if (ctx) instrumentContext(ctx);
+  if (typeof page.close === "function") {
+    const originalClose = page.close.bind(page);
+    page.close = async (...args) => {
+      await drainPendingProbes(1e3);
+      const sink = currentSink;
+      if (sink) {
+        await stashPageState(sink, { page });
+        await maybeOpenPicker(sink, { page });
+      }
+      return originalClose(...args);
+    };
+  }
+  const captureLocators = process.env.PIWI_CAPTURE_LOCATORS !== "false";
+  if (captureLocators) {
+    const factories = page;
+    for (const method of LOCATOR_METHODS) {
+      const original = factories[method].bind(page);
+      factories[method] = (...args) => {
+        if (currentSink) currentSink.lastActivePage = page;
+        return wrapLocator(page, original(...args), method, args);
+      };
+    }
+  }
+  page.on("console", (msg) => {
+    const sink = currentSink;
+    if (!sink) return;
+    const type = msg.type();
+    if (["warning", "error", "assert"].includes(type)) {
+      const location = msg.location();
+      sink.consoleEntries.push({
+        type,
+        text: msg.text(),
+        timestamp: Date.now(),
+        location: location ? `${location.url}:${location.lineNumber}:${location.columnNumber}` : null
+      });
+    }
+  });
+  page.on("requestfinished", (request) => {
+    const sink = currentSink;
+    if (!sink) return;
+    sink.lastActivePage = page;
+    const p = (async () => {
+      try {
+        const url = request.url();
+        if (url.startsWith("data:") || url.startsWith("blob:")) return;
+        const timing = request.timing();
+        const response = await request.response();
+        const resourceType = request.resourceType();
+        if (!["fetch", "xhr", "document", "other"].includes(resourceType)) return;
+        const entry = {
+          method: request.method(),
+          url,
+          status: response ? response.status() : 0,
+          duration: timing.responseEnd > 0 ? Math.round(timing.responseEnd - timing.requestStart) : 0,
+          startTime: timing.startTime,
+          resourceType
+        };
+        if (response) {
+          const headers = response.headers();
+          const contentType = headers["content-type"];
+          if (contentType) entry.contentType = contentType.split(";")[0].trim();
+          const logHeader = headers["x-piwi-logs"];
+          if (logHeader) {
+            try {
+              entry.serverLogs = JSON.parse((0, import_node_zlib.gunzipSync)(Buffer.from(logHeader, "base64")).toString("utf-8"));
+            } catch {
+            }
+          }
+        }
+        sink.networkRequests.push(entry);
+      } catch {
+      }
+    })();
+    sink.pendingHandlers.push(p);
+  });
+}
+function instrumentContext(context) {
+  if (!context || INSTRUMENTED_CONTEXTS.has(context)) return;
+  INSTRUMENTED_CONTEXTS.add(context);
+  const originalNewPage = context.newPage.bind(context);
+  context.newPage = async (...args) => {
+    const page = await originalNewPage(...args);
+    instrumentPage(page);
+    return page;
+  };
+  if (typeof context.close === "function") {
+    const originalClose = context.close.bind(context);
+    context.close = async (...args) => {
+      await drainPendingProbes(1e3);
+      const sink = currentSink;
+      if (sink) {
+        await stashPageState(sink, { context });
+        await maybeOpenPicker(sink, { context });
+      }
+      return originalClose(...args);
+    };
+  }
+  context.on("page", (page) => instrumentPage(page));
+}
+function patchBrowser(browser) {
+  if (!browser || PATCHED_BROWSERS.has(browser)) return;
+  PATCHED_BROWSERS.add(browser);
+  const originalNewPage = browser.newPage.bind(browser);
+  browser.newPage = async (...args) => {
+    const page = await originalNewPage(...args);
+    instrumentPage(page);
+    return page;
+  };
+  const originalNewContext = browser.newContext.bind(browser);
+  browser.newContext = async (...args) => {
+    const context = await originalNewContext(...args);
+    instrumentContext(context);
+    return context;
+  };
+  if (typeof browser.close === "function") {
+    const originalClose = browser.close.bind(browser);
+    browser.close = async (...args) => {
+      await drainPendingProbes(1e3);
+      return originalClose(...args);
+    };
+  }
+}
+async function flushSink(sink, testInfo) {
+  await Promise.allSettled(sink.pendingHandlers);
+  let drainDeadline;
+  await Promise.race([
+    Promise.allSettled(sink.capturePromises),
+    new Promise((resolve5) => {
+      drainDeadline = setTimeout(resolve5, 2e3);
+    })
+  ]);
+  clearTimeout(drainDeadline);
+  const page = sink.lastActivePage;
+  const pageReadable = page !== null && !isPageClosed(page);
+  if (pageReadable) await maybeOpenPicker(sink);
+  if (sink.capturedLocators.length > 0) {
+    await testInfo.attach(ATTACHMENT_NAMES.locators, {
+      contentType: "application/json",
+      // Repeated call sites (loops) keep only their latest capture — the
+      // server stores one row per location anyway, so shipping every
+      // iteration is pure payload bloat.
+      body: Buffer.from(JSON.stringify(dedupeSnapshotsByLocation(sink.capturedLocators)))
+    });
+  }
+  if (testInfo.status !== "passed" && testInfo.status !== "skipped") {
+    try {
+      const snapshot = (pageReadable ? await ariaSnapshotBestEffort(page.locator(":root")) : null) ?? sink.stashedAria;
+      if (snapshot) {
+        await testInfo.attach(ATTACHMENT_NAMES.ariaSnapshot, {
+          contentType: "text/plain",
+          body: snapshot
+        });
+        const failed = sink.failedLocators[sink.failedLocators.length - 1];
+        const suggestion = failed ? suggestLocatorsFromAria(failed, snapshot) : null;
+        if (suggestion) {
+          testInfo.annotations.push({
+            type: LOCATOR_SUGGESTION_ANNOTATION,
+            description: `${suggestion.failing} matched nothing on the failing page \u2014 the element may have been renamed or moved. Suggested: ${suggestion.suggestions.join("  |  ")}`
+          });
+          await testInfo.attach(ATTACHMENT_NAMES.locatorSuggestion, {
+            contentType: "application/json",
+            body: Buffer.from(JSON.stringify(suggestion))
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  if (sink.userPick) {
+    const pick = sink.userPick;
+    testInfo.annotations.push({
+      type: USER_PICK_ANNOTATION,
+      description: pick.failing ? `Replacement locator picked on the failing page for ${pick.failing.rendered}${pick.failing.location ? ` at ${pick.failing.location}` : ""}: ${pick.picked.locator}` : `Locator picked while inspecting the failing page: ${pick.picked.locator}`
+    });
+    try {
+      await testInfo.attach(ATTACHMENT_NAMES.userPick, {
+        contentType: "application/json",
+        body: Buffer.from(JSON.stringify(pick))
+      });
+    } catch {
+    }
+  } else if (!sink.pickOffered) {
+    const reason = environmentalSkipReason(inspectionGateFromTestInfo(testInfo, process.env.PIWI_PICK_LOCATOR_ON_FAIL)) ?? environmentalSkipReason(inspectionGateFromTestInfo(testInfo));
+    if (reason) console.log(`[piwi] failure-time locator tools enabled but skipped: ${reason}`);
+  }
+  if (sink.consoleEntries.length > 0) {
+    await testInfo.attach(ATTACHMENT_NAMES.console, {
+      contentType: "application/json",
+      body: Buffer.from(JSON.stringify(sink.consoleEntries))
+    });
+  }
+  if (sink.networkRequests.length > 0) {
+    await testInfo.attach(ATTACHMENT_NAMES.network, {
+      contentType: "application/json",
+      body: Buffer.from(JSON.stringify(sink.networkRequests))
+    });
+  }
+  const webVitals = (pageReadable ? await readWebVitals(page) : null) ?? sink.stashedWebVitals;
+  if (webVitals) {
+    await testInfo.attach(ATTACHMENT_NAMES.webVitals, {
+      contentType: "application/json",
+      body: Buffer.from(JSON.stringify(webVitals))
+    });
+  }
+  if (process.env.PIWI_CAPTURE_PAGE_STATE !== "false") {
+    const pageState = (pageReadable ? await readPageState(page) : null) ?? sink.stashedPageState;
+    if (pageState) {
+      await testInfo.attach(ATTACHMENT_NAMES.pageState, {
+        contentType: "application/json",
+        body: Buffer.from(JSON.stringify(pageState))
+      });
+    }
+  }
+}
+var piwiFixtures = {
+  // Worker-scoped: patch the shared browser so every page/context created from
+  // it — including by user fixtures that take `browser` directly — is captured.
+  browser: [
+    async ({ browser }, use) => {
+      patchBrowser(browser);
+      await use(browser);
+    },
+    { scope: "worker" }
+  ],
+  // Safety net for the standard `page` fixture, in case its page is created
+  // through an internal path the browser patch doesn't see. Idempotent, so it
+  // never double-wraps a page the browser patch already instrumented.
+  page: async ({ page }, use) => {
+    instrumentPage(page);
+    await use(page);
+  },
+  // Auto, test-scoped: open a capture sink for the running test and flush it
+  // (attach the collected data) at teardown. Runs for every test without being
+  // requested, so suites that never destructure `page` are still captured.
+  piwiCapture: [
+    async ({}, use, testInfo) => {
+      const sink = createSink();
+      sink.testInfo = testInfo;
+      currentSink = sink;
+      try {
+        await use();
+      } finally {
+        currentSink = null;
+        await flushSink(sink, testInfo);
+      }
+    },
+    { auto: true }
+  ]
+};
+function extendPiwiFixtures(test) {
+  return test.extend(piwiFixtures);
+}
+
+// src/index.ts
+var index_default = PiwiDashboardReporter;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PiwiDashboardReporter,
+  createGlobalSetup,
+  extendPiwiFixtures,
+  piwiFixtures,
+  wrapConfig
+});