@piwitests/reporter 0.12.0 → 0.13.0

package/dist/global-setup-module.d.ts

@@ -1,2 +1,3 @@
 declare const _default: (config: any) => Promise<any>;
-export default _default;
+
+export { _default as default };

package/dist/global-setup-module.js

@@ -1,4 +1,433 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const global_setup_js_1 = require("./public/global-setup.js");
-exports.default = (0, global_setup_js_1.createGlobalSetup)();
+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/global-setup-module.ts
+var global_setup_module_exports = {};
+__export(global_setup_module_exports, {
+  default: () => global_setup_module_default
+});
+module.exports = __toCommonJS(global_setup_module_exports);
+
+// src/public/global-setup.ts
+var path2 = __toESM(require("path"));
+
+// src/internal/support/errors.ts
+function errorMessage(error) {
+  if (error instanceof Error) return error.message;
+  return String(error);
+}
+
+// src/public/global-setup.ts
+var fs2 = __toESM(require("fs"));
+
+// 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;
+}
+
+// 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((resolve2, 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", () => {
+            resolve2({ 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/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/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/setup-file.ts
+var path = __toESM(require("path"));
+var os2 = __toESM(require("os"));
+var fs = __toESM(require("fs"));
+function getSetupFilePath(projectName) {
+  return path.join(os2.tmpdir(), `piwi-dashboard-setup-${hashForProject(projectName)}.json`);
+}
+
+// src/public/global-setup.ts
+function createGlobalSetup(options, userSetup) {
+  return async function globalSetupFn(config) {
+    const piwiReporterPath = path2.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 path2.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 path2.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) {
+        fs2.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/global-setup-module.ts
+var global_setup_module_default = createGlobalSetup();

package/dist/index.d.ts

@@ -1,3 +1,205 @@
+import { FullConfig, Suite, TestCase, TestResult, FullResult } from '@playwright/test/reporter';
+import { PlaywrightTestConfig } from '@playwright/test';
+export { PlaywrightTestConfig } from '@playwright/test';
+export { PiwiFixtures, extendPiwiFixtures, piwiFixtures } from './internal/capture/capture-fixtures.js';
+
+/** Options for configuring the Piwi Dashboard reporter */
+interface PiwiDashboardOptions extends PlaywrightTestConfig {
+    /** Explicitly enable or disable the reporter. Defaults to `true` when `serverUrl` is set. Set to `false` to disable even if `serverUrl` is provided. */
+    enabled?: boolean;
+    /** URL of the Piwi Dashboard server */
+    serverUrl?: string;
+    /** Name of the project to report results under. Defaults to `'default-project'`. */
+    projectName?: string;
+    /** Optional description of the project */
+    projectDescription?: string;
+    /** Upload trace files to the dashboard. Defaults to `true`. */
+    uploadTraces?: boolean;
+    /** Upload the Playwright HTML report. Defaults to `true`. */
+    uploadReport?: boolean;
+    /** Upload each test's trace and attachments as soon as the test finishes (streaming mode only). Defaults to `true`. */
+    liveFileUploads?: boolean;
+    /** Auto-collect git commit, branch, author. Defaults to `true`. */
+    collectScmInfo?: boolean;
+    /** Auto-collect CI environment info. Defaults to `true`. */
+    collectCiInfo?: boolean;
+    /** Collect step timings, network requests and web vitals. Defaults to `true`. */
+    collectPerformanceMetrics?: boolean;
+    /**
+     * Capture per-action locator snapshots that power failure-time healing
+     * suggestions. Adds a small per-action cost (one DOM read, sometimes an ARIA
+     * snapshot) in the test worker. Defaults to `true`; automatically disabled
+     * when `collectPerformanceMetrics` is `false` (the reporter discards the data
+     * in that case anyway). Can also be forced off with `PIWI_CAPTURE_LOCATORS=false`.
+     */
+    captureLocators?: boolean;
+    /**
+     * Capture the page's state at test end (URL, history state, localStorage/
+     * sessionStorage key names + value lengths, cookie names + flags). Values of
+     * storage entries and cookies are never captured. Defaults to `true`;
+     * automatically disabled when `collectPerformanceMetrics` is `false`. Can
+     * also be forced off with `PIWI_CAPTURE_PAGE_STATE=false`.
+     */
+    capturePageState?: boolean;
+    /**
+     * Open Piwi's own failure-time overlay on the failing page — for inspecting
+     * the page and picking a locator for any element (click an element → confirm
+     * a ranked replacement locator). This is Piwi's own in-page overlay, not
+     * Playwright's native inspector, so a confirmed pick flows back into the
+     * dashboard. `pickLocatorOnFailure` opens the same overlay targeted at the
+     * broken locator; this opens it for the whole page. Local debugging aid: only
+     * takes effect in a headed browser (`headless: false` / `--headed`), never
+     * under CI, and only on a test's final attempt when retries are configured.
+     * The run waits until the overlay is resolved. Defaults to `false`. Can also
+     * be enabled with `PIWI_INSPECT_ON_FAIL=true`.
+     */
+    inspectOnFailure?: boolean;
+    /**
+     * Open Piwi's locator picker on the failing page when a locator action
+     * fails: click the element the locator should have matched, confirm one of
+     * the ranked replacement locators generated for it, and the choice is
+     * recorded — folded into the run's locator snapshots (so the dashboard's
+     * healing panel shows it) and attached as `piwi-user-pick` with a report
+     * annotation. Same gate as `inspectOnFailure`: headed browser only, never
+     * under CI, final attempt only. Defaults to `false`. Can also be enabled
+     * with `PIWI_PICK_LOCATOR_ON_FAIL=true`.
+     */
+    pickLocatorOnFailure?: boolean;
+    /** Enable live streaming of results (falls back to batch if unsupported). Defaults to `true`. */
+    streaming?: boolean;
+    /** Number of test results to batch before sending during streaming. Defaults to `5`. */
+    streamingBatchSize?: number;
+    /** Max delay (ms) before flushing pending events during streaming. Defaults to `2000`. */
+    streamingBatchDelay?: number;
+    /** Username for dashboard login (use `apiKey` instead when possible) */
+    username?: string | null;
+    /** Password for dashboard login (used with `username`) */
+    password?: string | null;
+    /** API key for authentication (preferred over `username`/`password` for CI) */
+    apiKey?: string | null;
+    /** Additional report types to upload. Each entry can specify `type`, optional `dir`, and optional `label`. */
+    reports?: Array<{
+        type: string;
+        dir?: string;
+        label?: string;
+    }>;
+    /** Stable label that ties shards together (e.g. CI run ID). Auto-detected from CI env; override if needed. */
+    runLabel?: string;
+    /** Deployment environment for this run, e.g. `"production"`, `"staging"`, `"integration"` */
+    environment?: string;
+    /** Optional display label for the test run (e.g. "v2.3.1 release") */
+    label?: string;
+    /** Related issue reference, e.g. `"JIRA-123"` */
+    relatedIssue?: string;
+    /** CI job information */
+    ciInfo?: string;
+    /** Tags to categorize the test run */
+    tags?: string[];
+    /** Additional custom metadata as key-value pairs */
+    customData?: Record<string, unknown>;
+    /** Enable verbose logging for debugging. Defaults to `false`. */
+    verbose?: boolean;
+}
+
+/**
+ * Create a Playwright `globalSetup` function that registers a test run on the
+ * Piwi Dashboard server at the start of the run.  An optional `userSetup` is
+ * called afterward so existing setup logic is preserved.
+ *
+ * The server-run ID and a one-time token are written to a temp file so the
+ * reporter instance can pick them up during the streaming handshake.
+ *
+ * @param options   Piwi Dashboard options (uses `serverUrl`, `projectName`, …).
+ * @param userSetup An existing global setup to chain after the Piwi registration.
+ */
+declare function createGlobalSetup(options?: PiwiDashboardOptions, userSetup?: (config: any) => any): (config: any) => Promise<any>;
+
+/**
+ * Wrap a Playwright config to auto-inject the Piwi Dashboard reporter and
+ * chain its global setup module. Returns a new config object (shallow merge)
+ * without mutating the original.
+ *
+ * The `globalSetup` field is set to a `string` (or `string[]` if the user
+ * already has a global setup) referencing the Piwi global setup module,
+ * which registers the run on the server. The original setup path(s) are
+ * preserved and executed first.
+ *
+ * Playwright options required in `globalSetup` are forwarded via `PIWI_*`
+ * environment variables (see `applyOptionsToEnv` in `config.ts` for the
+ * supported set — `serverUrl`, `projectName`, `verbose`, `apiKey`,
+ * `username`, `password`, `environment`, `label`, `runLabel`).
+ *
+ * @param config      The user's Playwright config.
+ * @param piwiOptions Optional Piwi Dashboard options (serverUrl, projectName, …).
+ */
+declare function wrapConfig<T extends PlaywrightTestConfig>(config: T, piwiOptions?: PiwiDashboardOptions): T;
+
+/**
+ * Piwi Dashboard Playwright reporter.
+ *
+ * Collects test results, metadata, performance metrics and trace files, then
+ * hands the collected run to a `RunSubmitter` which drives the JSON / multipart
+ * / streaming submit ladder. The reporter itself only owns the Playwright hooks
+ * and the running counters.
+ */
+declare class PiwiDashboardReporter {
+    private options;
+    private testCases;
+    private startTime;
+    private playwrightVersion;
+    private readonly reporterVersion;
+    private totalTests;
+    private passedTests;
+    private failedTests;
+    private skippedTests;
+    private timedOutTests;
+    private didNotRunTests;
+    /** Full set of tests Playwright planned to run this shard (captured in `onBegin`). */
+    private plannedTests;
+    /** Ids of tests that actually reported via `onTestEnd`, to find the ones that never ran. */
+    private reportedTestIds;
+    private instanceId;
+    private runLabel;
+    private shardInfo;
+    private metadata;
+    private enabled;
+    private isFullRun;
+    private filterDetails;
+    private httpClient;
+    private uploader;
+    private fileHandler;
+    private metadataCollector;
+    private streamManager;
+    private recovery;
+    private submitter;
+    private readonly logger;
+    static wrapConfig: typeof wrapConfig;
+    static createGlobalSetup: typeof createGlobalSetup;
+    constructor(rawOptions?: Record<string, any>);
+    /** Playwright reporter hook: called once at the start of the test run */
+    onBegin(config: FullConfig, suite: Suite): void;
+    /** Playwright reporter hook: called when an individual test begins */
+    onTestBegin(test: TestCase, result: TestResult): void;
+    /** Track suite-level setup steps (beforeAll/afterAll) not tied to any test */
+    private setupSteps;
+    /** Playwright reporter hook: called when a step (including hook/fixture) begins */
+    onStepBegin(test: TestCase | undefined, _result: TestResult | undefined, step: any): void;
+    /** Playwright reporter hook: called when a step (including hook/fixture) ends */
+    onStepEnd(test: TestCase | undefined, _result: TestResult | undefined, step: any): void;
+    /** Playwright reporter hook: called when an individual test finishes */
+    onTestEnd(test: TestCase, result: TestResult): void;
+    /**
+     * 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.
+     */
+    private materializeUnrunTests;
+    /** Playwright reporter hook: called when the full test run finishes */
+    onEnd(result: FullResult): Promise<void>;
+}
+
 /**
  * Public API of `@piwitests/reporter`.
  *
@@ -6,11 +208,5 @@
  * 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.
  */
-import { PiwiDashboardReporter } from './public/reporter.js';
-export default PiwiDashboardReporter;
-export { PiwiDashboardReporter };
-export { wrapConfig } from './public/config-wrapper.js';
-export { createGlobalSetup } from './public/global-setup.js';
-export { piwiFixtures, extendPiwiFixtures } from './internal/capture/capture-fixtures.js';
-export type { PiwiFixtures } from './internal/capture/capture-fixtures.js';
-export type { PiwiDashboardOptions, PlaywrightTestConfig } from './public/options.js';
+
+export { type PiwiDashboardOptions, PiwiDashboardReporter, createGlobalSetup, PiwiDashboardReporter as default, wrapConfig };