@piwitests/reporter 0.53.0 → 0.54.0

package/dist/index.js

@@ -5700,6 +5700,9 @@ function boxCaptureFrames(extraPrefixes = []) {
   } catch {
   }
 }
+function callMethod(target, prop, args) {
+  return target[prop](...args);
+}
 function internalCall(owner, run) {
   const wrap = owner?._wrapApiCall;
   if (typeof wrap !== "function") return run();
@@ -13157,6 +13160,143 @@ function readPageInteraction() {
   return out;
 }
 
+// src/internal/capture/api-requests.ts
+var SENDING_METHODS = /* @__PURE__ */ new Set(["fetch", "get", "post", "put", "patch", "delete", "head"]);
+var PROXIES = /* @__PURE__ */ new WeakMap();
+var OBSERVED = /* @__PURE__ */ new WeakSet();
+var PATCHED_REQUESTS = /* @__PURE__ */ new WeakSet();
+function observeApiRequests(playwright, recorder) {
+  const apiRequest = playwright?.request;
+  if (!apiRequest || typeof apiRequest !== "object" || typeof apiRequest.newContext !== "function") return;
+  if (PATCHED_REQUESTS.has(apiRequest)) return;
+  PATCHED_REQUESTS.add(apiRequest);
+  const create = apiRequest.newContext.bind(apiRequest);
+  apiRequest.newContext = async function newContext(...args) {
+    const context = await create(...args);
+    return observeApiRequestContext(context, recorder, baseUrlOption(args[0]));
+  };
+}
+function observeApiRequestContext(context, recorder, baseURL = null) {
+  if (!context || typeof context !== "object" || OBSERVED.has(context)) return context;
+  const known = PROXIES.get(context);
+  if (known) return known;
+  const forwarders = /* @__PURE__ */ new Map();
+  const proxy = new Proxy(context, {
+    get(target, prop) {
+      const value = Reflect.get(target, prop);
+      if (typeof value !== "function" || prop === "constructor") return value;
+      const cached = forwarders.get(prop);
+      if (cached?.method === value) return cached.forward;
+      const forward = typeof prop === "string" && SENDING_METHODS.has(prop) ? sendingMethod(target, prop, recorder, baseURL) : value.bind(target);
+      forwarders.set(prop, { method: value, forward });
+      return forward;
+    }
+  });
+  PROXIES.set(context, proxy);
+  OBSERVED.add(proxy);
+  return proxy;
+}
+function sendingMethod(target, prop, recorder, baseURL) {
+  return function send(...args) {
+    const record = recorder();
+    if (!record) return callMethod(target, prop, args);
+    const startedAt = Date.now();
+    const result = callMethod(target, prop, args);
+    if (typeof result?.then !== "function") return result;
+    const report = (response, error) => {
+      try {
+        record({
+          method: methodOf(prop, args),
+          url: urlOf(args[0]),
+          baseURL,
+          startedAt,
+          endedAt: Date.now(),
+          response,
+          error
+        });
+      } catch {
+      }
+    };
+    return result.then(
+      (response) => {
+        report(response);
+        return response;
+      },
+      (error) => {
+        report(null, error);
+        throw error;
+      }
+    );
+  };
+}
+function methodOf(prop, args) {
+  if (prop !== "fetch") return prop.toUpperCase();
+  const option = args[1]?.method;
+  if (typeof option === "string" && option) return option.toUpperCase();
+  const request4 = args[0];
+  const method = typeof request4?.method === "function" ? request4.method() : null;
+  return typeof method === "string" && method ? method.toUpperCase() : "GET";
+}
+function urlOf(target) {
+  if (typeof target === "string") return target;
+  const url = typeof target?.url === "function" ? target.url() : null;
+  return typeof url === "string" ? url : null;
+}
+function baseUrlOption(options) {
+  const baseURL = options?.baseURL;
+  return typeof baseURL === "string" && baseURL ? baseURL : null;
+}
+var MAX_FAILURE_LENGTH = 300;
+var API_ERROR_PREFIX = /^apiRequestContext\.\w+: /;
+var STATUS_FAILURE = /^(\d{3}) /;
+function apiCallEntry(call, baseURL) {
+  const response = call.response;
+  if (response) {
+    const timing = responseTiming(response) ?? { startTime: call.startedAt, duration: call.endedAt - call.startedAt };
+    return {
+      method: call.method,
+      url: response.url(),
+      status: response.status(),
+      duration: timing.duration,
+      startTime: timing.startTime
+    };
+  }
+  const url = resolveUrl(call.url, call.baseURL ?? baseURL);
+  if (!url) return null;
+  const failure = failureText(call.error);
+  const status = STATUS_FAILURE.exec(failure);
+  return {
+    method: call.method,
+    url,
+    status: status ? Number(status[1]) : 0,
+    duration: Math.max(0, call.endedAt - call.startedAt),
+    startTime: call.startedAt,
+    ...status ? {} : { failure }
+  };
+}
+function responseTiming(response) {
+  if (typeof response.timing !== "function") return null;
+  const timing = response.timing();
+  if (!(timing.startTime > 0) || !(timing.responseEnd >= 0)) return null;
+  return {
+    startTime: timing.startTime,
+    duration: Math.max(0, Math.round(timing.responseEnd - Math.max(0, timing.requestStart)))
+  };
+}
+function resolveUrl(url, baseURL) {
+  if (!url) return null;
+  try {
+    return new URL(url, baseURL ?? void 0).toString();
+  } catch {
+    return url;
+  }
+}
+function failureText(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const line = message.split("\n", 1)[0].replace(API_ERROR_PREFIX, "").trim();
+  return (line || "failed").slice(0, MAX_FAILURE_LENGTH);
+}
+
 // src/internal/capture/capture-fixtures.ts
 function computeCoreVitals(lcpEntries, shiftEntries, eventEntries) {
   const lastLcp = lcpEntries && lcpEntries.length > 0 ? lcpEntries[lcpEntries.length - 1] : null;
@@ -13217,7 +13357,8 @@ function createSink() {
     pause: null,
     locatorPages: new LocatorPageLog(),
     codeReach: null,
-    serverCoverage: /* @__PURE__ */ new Map()
+    serverCoverage: /* @__PURE__ */ new Map(),
+    baseURL: null
   };
 }
 function maybeStartCodeReach(page) {
@@ -13672,9 +13813,6 @@ function startElementCapture(sink, page, target, seq, callerLocation, used) {
   })();
   sink.capturePromises.push(resolveAttrs);
 }
-function callMethod(target, prop, args) {
-  return target[prop](...args);
-}
 function recordLocatorPage(sink, page, locator, location, arrival) {
   try {
     sink.locatorPages.record({ location, locator: String(locator), url: page.url(), arrival });
@@ -13841,6 +13979,7 @@ function instrumentPage(page) {
   if (!page || INSTRUMENTED_PAGES.has(page)) return;
   INSTRUMENTED_PAGES.add(page);
   void maybeStartCodeReach(page);
+  observeOwnApiRequests(page);
   const probeSink = currentSink;
   if (probeSink?.probeItem && !probeSink.probeInterception) {
     void installProbeInterception(page, probeSink.probeItem).then((interception) => {
@@ -14000,25 +14139,7 @@ function recordRequest(sink, request4, end, response) {
         if (timing.requestStart < 0 && typeof response.serverAddr === "function") {
           if (await response.serverAddr().catch(() => void 0) === null) entry.fulfilled = true;
         }
-        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_zlib2.gunzipSync)(Buffer.from(logHeader, "base64")).toString("utf-8"));
-          } catch {
-          }
-        }
-        const coverageHeader = headers["x-piwi-coverage"];
-        if (coverageHeader && serverCoverageInWorker()) recordServerCoverageIds(sink, url, coverageHeader);
-        const traceHeader = headers["x-piwi-trace"];
-        if (traceHeader && process.env.PIWI_CAPTURE_SERVER_TRACES !== "false") {
-          try {
-            entry.serverTraces = JSON.parse((0, import_node_zlib2.gunzipSync)(Buffer.from(traceHeader, "base64")).toString("utf-8"));
-          } catch {
-          }
-        }
+        readResponseHeaders(sink, entry, url, response.headers());
       }
       sink.networkRequests.push(entry);
     } catch {
@@ -14026,6 +14147,48 @@ function recordRequest(sink, request4, end, response) {
   })();
   sink.pendingHandlers.push(p);
 }
+function readResponseHeaders(sink, entry, url, 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_zlib2.gunzipSync)(Buffer.from(logHeader, "base64")).toString("utf-8"));
+    } catch {
+    }
+  }
+  const coverageHeader = headers["x-piwi-coverage"];
+  if (coverageHeader && serverCoverageInWorker()) recordServerCoverageIds(sink, url, coverageHeader);
+  const traceHeader = headers["x-piwi-trace"];
+  if (traceHeader && process.env.PIWI_CAPTURE_SERVER_TRACES !== "false") {
+    try {
+      entry.serverTraces = JSON.parse((0, import_node_zlib2.gunzipSync)(Buffer.from(traceHeader, "base64")).toString("utf-8"));
+    } catch {
+    }
+  }
+}
+function recordApiCall(sink, call) {
+  try {
+    const entry = apiCallEntry(call, sink.baseURL);
+    if (!entry) return;
+    if (call.response) readResponseHeaders(sink, entry, String(entry.url), call.response.headers());
+    sink.networkRequests.push(entry);
+  } catch {
+  }
+}
+function apiCallRecorder() {
+  const sink = currentSink;
+  return sink ? (call) => recordApiCall(sink, call) : null;
+}
+function observeOwnApiRequests(owner) {
+  try {
+    const holder = owner;
+    if (holder.request && typeof holder.request === "object") {
+      holder.request = observeApiRequestContext(holder.request, apiCallRecorder);
+    }
+  } catch {
+  }
+}
 function recordOpenRequests(sink) {
   for (const [request4, response] of sink.openResponses) {
     RECORDED_OPEN.add(request4);
@@ -14039,6 +14202,7 @@ async function awaitFlakeConditions() {
 function instrumentContext(context) {
   if (!context || INSTRUMENTED_CONTEXTS.has(context)) return;
   INSTRUMENTED_CONTEXTS.add(context);
+  observeOwnApiRequests(context);
   if (process.env.PIWI_CAPTURE_LOCATORS !== "false" && typeof context.addInitScript === "function") {
     void Promise.resolve(context.addInitScript({ content: PROBE_INIT_SCRIPT })).catch(() => {
     });
@@ -14293,14 +14457,17 @@ async function flushSink(sink, testInfo) {
   }
 }
 var piwiFixtures = {
-  // Auto, worker-scoped: the worker's resource ledger. Set up before any hook
-  // (worker fixtures come first), so a `beforeAll` context is in it too, and
-  // torn down after the browser closed, so its census sees what only the
-  // worker's shutdown closed. Depends on `playwright` alone, which launches nothing.
+  // Auto, worker-scoped: the worker's resource ledger, and the API request
+  // contexts its tests create, handed out behind the call proxy. Set up before
+  // any hook (worker fixtures come first), so a `beforeAll` context is in the
+  // ledger and records the calls the tests make through it, and torn down after
+  // the browser closed, so its census sees what only the worker's shutdown
+  // closed. Depends on `playwright` alone, which launches nothing.
   piwiResources: [
     async ({ playwright }, use, workerInfo) => {
       boxCaptureFrames();
       startResourceLedger(playwright, workerInfo.workerIndex);
+      observeApiRequests(playwright, apiCallRecorder);
       try {
         await use();
       } finally {
@@ -14331,12 +14498,13 @@ var piwiFixtures = {
   // (attach the collected data) at teardown. Runs for every test without being
   // requested, so suites that never destructure `page` are still captured.
   piwiCapture: [
-    async ({ screenshot }, use, testInfo) => {
+    async ({ screenshot, baseURL }, use, testInfo) => {
       boxCaptureFrames();
       const conflict = labModeConflict();
       if (conflict) throw new Error(conflict);
       const sink = createSink();
       sink.testInfo = testInfo;
+      sink.baseURL = baseURL ?? null;
       if (keepsFailureScreenshots(screenshot, testInfo.retry)) sink.failureScreenshot = screenshot;
       const pauseSet = currentPauseSet();
       if (pauseSet.size) {

package/dist/internal/capture/capture-fixtures.d.ts

@@ -35,6 +35,13 @@ declare class LocatorPageLog {
  * layout leaves Playwright's defaults untouched.
  */
 declare function boxCaptureFrames(extraPrefixes?: readonly string[]): void;
+/**
+ * Call a Playwright method on its own receiver. Playwright names an API call
+ * after the method frame the call enters, so the call keeps its real name
+ * (`locator.fill: Timeout …`); a call through `Function.prototype.apply` is
+ * named `apply`.
+ */
+declare function callMethod(target: object, prop: string | symbol, args: unknown[]): unknown;
 /**
  * Run a page read as an internal Playwright call: every API call made inside
  * `run` is kept out of the test's steps and the trace. `owner` is the page (or
@@ -553,13 +560,6 @@ declare function ariaSnapshotBestEffort(target: Locator, timeout?: number): Prom
  * yields null and the capture proceeds with the YAML alone.
  */
 declare function ariaSnapshotJSONBestEffort(target: Locator, timeout?: number): Promise<string | null>;
-/**
- * Call a Playwright method on its own receiver. Playwright names an API call
- * after the method frame the call enters, so the call keeps its real name
- * (`locator.fill: Timeout …`); a call through `Function.prototype.apply` is
- * named `apply`.
- */
-declare function callMethod(target: object, prop: string | symbol, args: unknown[]): unknown;
 /**
  * The fixtures `piwiFixtures` / `extendPiwiFixtures` contribute. The single
  * added fixture is `piwiCapture`: an auto, test-scoped teardown hook that
@@ -575,9 +575,11 @@ interface PiwiFixtures {
  * The worker fixture `piwiFixtures` / `extendPiwiFixtures` contribute:
  * `piwiResources`, an auto, worker-scoped fixture that keeps the worker's
  * resource ledger (the browsers, contexts, pages and API request contexts its
- * tests open) from before the first hook to the worker's shutdown. Its name is
- * **reserved** like `piwiCapture`'s: a fixture of your own with that name
- * replaces it and turns the ledger off.
+ * tests open) from before the first hook to the worker's shutdown, and records
+ * the calls tests make through the API request contexts `playwright.request`
+ * creates, the `request` fixture's among them. Its name is **reserved** like
+ * `piwiCapture`'s: a fixture of your own with that name replaces it and turns
+ * the ledger and those calls' capture off.
  */
 interface PiwiWorkerFixtures {
     piwiResources: void;
@@ -588,8 +590,11 @@ interface PiwiWorkerFixtures {
  *
  * Capture is wired at the `browser` level, so it works whether a test uses the
  * standard `page` fixture or builds its own pages from `browser` /
- * `browser.newContext()`. Collected data is attached as `piwi-*`
- * test-info attachments which the Piwi Dashboard reporter parses on `onTestEnd`.
+ * `browser.newContext()`. The calls a test makes through an API request
+ * context (the `request` fixture, `playwright.request.newContext()`,
+ * `page.request`) are recorded with its network requests. Collected data is
+ * attached as `piwi-*` test-info attachments which the Piwi Dashboard reporter
+ * parses on `onTestEnd`.
  */
 declare const piwiFixtures: Fixtures<PiwiFixtures, PiwiWorkerFixtures, PlaywrightTestArgs & PlaywrightTestOptions, PlaywrightWorkerArgs & PlaywrightWorkerOptions>;
 /**

package/dist/internal/capture/capture-fixtures.js

@@ -4039,6 +4039,9 @@ function boxCaptureFrames(extraPrefixes = []) {
   } catch {
   }
 }
+function callMethod(target, prop, args) {
+  return target[prop](...args);
+}
 function internalCall(owner, run) {
   const wrap = owner?._wrapApiCall;
   if (typeof wrap !== "function") return run();
@@ -5522,6 +5525,143 @@ function readPageInteraction() {
   return out;
 }
 
+// src/internal/capture/api-requests.ts
+var SENDING_METHODS = /* @__PURE__ */ new Set(["fetch", "get", "post", "put", "patch", "delete", "head"]);
+var PROXIES = /* @__PURE__ */ new WeakMap();
+var OBSERVED = /* @__PURE__ */ new WeakSet();
+var PATCHED_REQUESTS = /* @__PURE__ */ new WeakSet();
+function observeApiRequests(playwright, recorder) {
+  const apiRequest = playwright?.request;
+  if (!apiRequest || typeof apiRequest !== "object" || typeof apiRequest.newContext !== "function") return;
+  if (PATCHED_REQUESTS.has(apiRequest)) return;
+  PATCHED_REQUESTS.add(apiRequest);
+  const create = apiRequest.newContext.bind(apiRequest);
+  apiRequest.newContext = async function newContext(...args) {
+    const context = await create(...args);
+    return observeApiRequestContext(context, recorder, baseUrlOption(args[0]));
+  };
+}
+function observeApiRequestContext(context, recorder, baseURL = null) {
+  if (!context || typeof context !== "object" || OBSERVED.has(context)) return context;
+  const known = PROXIES.get(context);
+  if (known) return known;
+  const forwarders = /* @__PURE__ */ new Map();
+  const proxy = new Proxy(context, {
+    get(target, prop) {
+      const value = Reflect.get(target, prop);
+      if (typeof value !== "function" || prop === "constructor") return value;
+      const cached = forwarders.get(prop);
+      if (cached?.method === value) return cached.forward;
+      const forward = typeof prop === "string" && SENDING_METHODS.has(prop) ? sendingMethod(target, prop, recorder, baseURL) : value.bind(target);
+      forwarders.set(prop, { method: value, forward });
+      return forward;
+    }
+  });
+  PROXIES.set(context, proxy);
+  OBSERVED.add(proxy);
+  return proxy;
+}
+function sendingMethod(target, prop, recorder, baseURL) {
+  return function send(...args) {
+    const record = recorder();
+    if (!record) return callMethod(target, prop, args);
+    const startedAt = Date.now();
+    const result = callMethod(target, prop, args);
+    if (typeof result?.then !== "function") return result;
+    const report = (response, error) => {
+      try {
+        record({
+          method: methodOf(prop, args),
+          url: urlOf(args[0]),
+          baseURL,
+          startedAt,
+          endedAt: Date.now(),
+          response,
+          error
+        });
+      } catch {
+      }
+    };
+    return result.then(
+      (response) => {
+        report(response);
+        return response;
+      },
+      (error) => {
+        report(null, error);
+        throw error;
+      }
+    );
+  };
+}
+function methodOf(prop, args) {
+  if (prop !== "fetch") return prop.toUpperCase();
+  const option = args[1]?.method;
+  if (typeof option === "string" && option) return option.toUpperCase();
+  const request = args[0];
+  const method = typeof request?.method === "function" ? request.method() : null;
+  return typeof method === "string" && method ? method.toUpperCase() : "GET";
+}
+function urlOf(target) {
+  if (typeof target === "string") return target;
+  const url = typeof target?.url === "function" ? target.url() : null;
+  return typeof url === "string" ? url : null;
+}
+function baseUrlOption(options) {
+  const baseURL = options?.baseURL;
+  return typeof baseURL === "string" && baseURL ? baseURL : null;
+}
+var MAX_FAILURE_LENGTH = 300;
+var API_ERROR_PREFIX = /^apiRequestContext\.\w+: /;
+var STATUS_FAILURE = /^(\d{3}) /;
+function apiCallEntry(call, baseURL) {
+  const response = call.response;
+  if (response) {
+    const timing = responseTiming(response) ?? { startTime: call.startedAt, duration: call.endedAt - call.startedAt };
+    return {
+      method: call.method,
+      url: response.url(),
+      status: response.status(),
+      duration: timing.duration,
+      startTime: timing.startTime
+    };
+  }
+  const url = resolveUrl(call.url, call.baseURL ?? baseURL);
+  if (!url) return null;
+  const failure = failureText(call.error);
+  const status = STATUS_FAILURE.exec(failure);
+  return {
+    method: call.method,
+    url,
+    status: status ? Number(status[1]) : 0,
+    duration: Math.max(0, call.endedAt - call.startedAt),
+    startTime: call.startedAt,
+    ...status ? {} : { failure }
+  };
+}
+function responseTiming(response) {
+  if (typeof response.timing !== "function") return null;
+  const timing = response.timing();
+  if (!(timing.startTime > 0) || !(timing.responseEnd >= 0)) return null;
+  return {
+    startTime: timing.startTime,
+    duration: Math.max(0, Math.round(timing.responseEnd - Math.max(0, timing.requestStart)))
+  };
+}
+function resolveUrl(url, baseURL) {
+  if (!url) return null;
+  try {
+    return new URL(url, baseURL ?? void 0).toString();
+  } catch {
+    return url;
+  }
+}
+function failureText(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const line = message.split("\n", 1)[0].replace(API_ERROR_PREFIX, "").trim();
+  return (line || "failed").slice(0, MAX_FAILURE_LENGTH);
+}
+
 // src/internal/capture/capture-fixtures.ts
 function computeCoreVitals(lcpEntries, shiftEntries, eventEntries) {
   const lastLcp = lcpEntries && lcpEntries.length > 0 ? lcpEntries[lcpEntries.length - 1] : null;
@@ -5582,7 +5722,8 @@ function createSink() {
     pause: null,
     locatorPages: new LocatorPageLog(),
     codeReach: null,
-    serverCoverage: /* @__PURE__ */ new Map()
+    serverCoverage: /* @__PURE__ */ new Map(),
+    baseURL: null
   };
 }
 function maybeStartCodeReach(page) {
@@ -6037,9 +6178,6 @@ function startElementCapture(sink, page, target, seq, callerLocation, used) {
   })();
   sink.capturePromises.push(resolveAttrs);
 }
-function callMethod(target, prop, args) {
-  return target[prop](...args);
-}
 function recordLocatorPage(sink, page, locator, location, arrival) {
   try {
     sink.locatorPages.record({ location, locator: String(locator), url: page.url(), arrival });
@@ -6206,6 +6344,7 @@ function instrumentPage(page) {
   if (!page || INSTRUMENTED_PAGES.has(page)) return;
   INSTRUMENTED_PAGES.add(page);
   void maybeStartCodeReach(page);
+  observeOwnApiRequests(page);
   const probeSink = currentSink;
   if (probeSink?.probeItem && !probeSink.probeInterception) {
     void installProbeInterception(page, probeSink.probeItem).then((interception) => {
@@ -6365,25 +6504,7 @@ function recordRequest(sink, request, end, response) {
         if (timing.requestStart < 0 && typeof response.serverAddr === "function") {
           if (await response.serverAddr().catch(() => void 0) === null) entry.fulfilled = true;
         }
-        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_zlib2.gunzipSync)(Buffer.from(logHeader, "base64")).toString("utf-8"));
-          } catch {
-          }
-        }
-        const coverageHeader = headers["x-piwi-coverage"];
-        if (coverageHeader && serverCoverageInWorker()) recordServerCoverageIds(sink, url, coverageHeader);
-        const traceHeader = headers["x-piwi-trace"];
-        if (traceHeader && process.env.PIWI_CAPTURE_SERVER_TRACES !== "false") {
-          try {
-            entry.serverTraces = JSON.parse((0, import_node_zlib2.gunzipSync)(Buffer.from(traceHeader, "base64")).toString("utf-8"));
-          } catch {
-          }
-        }
+        readResponseHeaders(sink, entry, url, response.headers());
       }
       sink.networkRequests.push(entry);
     } catch {
@@ -6391,6 +6512,48 @@ function recordRequest(sink, request, end, response) {
   })();
   sink.pendingHandlers.push(p);
 }
+function readResponseHeaders(sink, entry, url, 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_zlib2.gunzipSync)(Buffer.from(logHeader, "base64")).toString("utf-8"));
+    } catch {
+    }
+  }
+  const coverageHeader = headers["x-piwi-coverage"];
+  if (coverageHeader && serverCoverageInWorker()) recordServerCoverageIds(sink, url, coverageHeader);
+  const traceHeader = headers["x-piwi-trace"];
+  if (traceHeader && process.env.PIWI_CAPTURE_SERVER_TRACES !== "false") {
+    try {
+      entry.serverTraces = JSON.parse((0, import_node_zlib2.gunzipSync)(Buffer.from(traceHeader, "base64")).toString("utf-8"));
+    } catch {
+    }
+  }
+}
+function recordApiCall(sink, call) {
+  try {
+    const entry = apiCallEntry(call, sink.baseURL);
+    if (!entry) return;
+    if (call.response) readResponseHeaders(sink, entry, String(entry.url), call.response.headers());
+    sink.networkRequests.push(entry);
+  } catch {
+  }
+}
+function apiCallRecorder() {
+  const sink = currentSink;
+  return sink ? (call) => recordApiCall(sink, call) : null;
+}
+function observeOwnApiRequests(owner) {
+  try {
+    const holder = owner;
+    if (holder.request && typeof holder.request === "object") {
+      holder.request = observeApiRequestContext(holder.request, apiCallRecorder);
+    }
+  } catch {
+  }
+}
 function recordOpenRequests(sink) {
   for (const [request, response] of sink.openResponses) {
     RECORDED_OPEN.add(request);
@@ -6404,6 +6567,7 @@ async function awaitFlakeConditions() {
 function instrumentContext(context) {
   if (!context || INSTRUMENTED_CONTEXTS.has(context)) return;
   INSTRUMENTED_CONTEXTS.add(context);
+  observeOwnApiRequests(context);
   if (process.env.PIWI_CAPTURE_LOCATORS !== "false" && typeof context.addInitScript === "function") {
     void Promise.resolve(context.addInitScript({ content: PROBE_INIT_SCRIPT })).catch(() => {
     });
@@ -6658,14 +6822,17 @@ async function flushSink(sink, testInfo) {
   }
 }
 var piwiFixtures = {
-  // Auto, worker-scoped: the worker's resource ledger. Set up before any hook
-  // (worker fixtures come first), so a `beforeAll` context is in it too, and
-  // torn down after the browser closed, so its census sees what only the
-  // worker's shutdown closed. Depends on `playwright` alone, which launches nothing.
+  // Auto, worker-scoped: the worker's resource ledger, and the API request
+  // contexts its tests create, handed out behind the call proxy. Set up before
+  // any hook (worker fixtures come first), so a `beforeAll` context is in the
+  // ledger and records the calls the tests make through it, and torn down after
+  // the browser closed, so its census sees what only the worker's shutdown
+  // closed. Depends on `playwright` alone, which launches nothing.
   piwiResources: [
     async ({ playwright }, use, workerInfo) => {
       boxCaptureFrames();
       startResourceLedger(playwright, workerInfo.workerIndex);
+      observeApiRequests(playwright, apiCallRecorder);
       try {
         await use();
       } finally {
@@ -6696,12 +6863,13 @@ var piwiFixtures = {
   // (attach the collected data) at teardown. Runs for every test without being
   // requested, so suites that never destructure `page` are still captured.
   piwiCapture: [
-    async ({ screenshot }, use, testInfo) => {
+    async ({ screenshot, baseURL }, use, testInfo) => {
       boxCaptureFrames();
       const conflict = labModeConflict();
       if (conflict) throw new Error(conflict);
       const sink = createSink();
       sink.testInfo = testInfo;
+      sink.baseURL = baseURL ?? null;
       if (keepsFailureScreenshots(screenshot, testInfo.retry)) sink.failureScreenshot = screenshot;
       const pauseSet = currentPauseSet();
       if (pauseSet.size) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@piwitests/reporter",
-  "version": "0.53.0",
+  "version": "0.54.0",
   "description": "Playwright reporter that streams results, traces and HTML reports to a Piwi Dashboard instance",
   "url": "https://github.com/PiwiTests/platform",
   "homepage": "https://piwitests.dev",

package/templates/skills/investigate-failure/SKILL.md

@@ -19,7 +19,7 @@ Prefer the **Piwi MCP server** if it is connected to this agent (tools named `li
 
 3. **Group by cause.** Call `get_failure_groups` (or `list_clusters` / `get_cluster`) — failures that share a root cause are clustered, so you fix one thing, not five. Work cluster by cluster.
 
-4. **Read the evidence per cluster.** Call `get_cluster_context` — the same SCM-grounded context the built-in diagnosis uses: representative errors, test steps, console logs, failing network requests, ARIA snapshots, and the **diff of files changed since the last green run**. If a diagnosis already exists, `get_cluster_diagnosis` returns its root cause and suggested fix.
+4. **Read the evidence per cluster.** Call `get_cluster_context` — the same SCM-grounded context the built-in diagnosis uses: representative errors, test steps, console logs, failing network requests, ARIA snapshots, and the **diff of files changed since the last green run**. If a diagnosis already exists, `get_cluster_diagnosis` returns its root cause and suggested fix. When the failure has no change behind it and the project records coverage, call `compare_coverage` with a failing execution's id: the code this run took that the last passing run did not (an error path, a fallback) is where to look.
 
 5. **Form the diagnosis.** Tie the failure to a cause with evidence: a selector that stopped matching, an assertion on changed copy, a slow/500 endpoint (`get_network_requests`), a race, a genuinely flaky test (check `get_test_stability_trend` — if it fails intermittently, treat it as flaky, not a regression). Point at the specific commit/file from the diff when the evidence supports it.
 

package/templates/skills/stabilize-flaky-tests/SKILL.md

@@ -15,7 +15,7 @@ Prefer the **Piwi MCP server** if it is connected (`list_flaky_tests`, `get_flak
 
 1. **Rank the flaky tests.** Call `list_flaky_tests` for the project and take the top few by impact. Do not try to fix the whole list at once.
 
-2. **Read the suspects.** For a chosen test, call `get_flake_profile`. Each suspect carries raw counts ("slow in 7 of 8 failures and 3 of 44 passes"), the condition that would test it, and, once the lab has run, its latest result (`lab`). `experiments` lists what the lab already found; if an experiment reproduced the test, skip to step 4. Read one failing execution (`get_test_run_case` / `explain_failure`) for the error at the moment it flaked.
+2. **Read the suspects.** For a chosen test, call `get_flake_profile`. Each suspect carries raw counts ("slow in 7 of 8 failures and 3 of 44 passes"), the condition that would test it, and, once the lab has run, its latest result (`lab`). `experiments` lists what the lab already found; if an experiment reproduced the test, skip to step 4. Read one failing execution (`get_test_run_case` / `explain_failure`) for the error at the moment it flaked. A test whose root cause is `order` depends on state an earlier test leaves behind: `compare_coverage` with its `testCaseId` names that test and the code whose path changes, so reproduce by running that test before this one in a single worker, and fix the shared state, not the wait.
 
 3. **Reproduce it.** Run the lab on the test (`plan_flake_experiment` gives the exact commands and the arms it will run, with an estimate):
 

package/templates/skills/write-the-missing-test/SKILL.md

@@ -14,7 +14,7 @@ drafts it from the graph, and opens it in the same change.
 ## How you reach Piwi
 
 Prefer the **Piwi MCP server** if it is connected (`list_scenario_gaps`,
-`draft_scenario`, `get_change_coverage`, `triage_gap`). Otherwise use the dashboard's **Gaps**
+`draft_scenario`, `get_change_coverage`, `get_coverage`, `triage_gap`). Otherwise use the dashboard's **Gaps**
 view, or the reporter CLI with `PIWI_DASHBOARD_URL` / `PIWI_API_KEY` /
 `PIWI_PROJECT_NAME` set.
 
@@ -38,7 +38,11 @@ view, or the reporter CLI with `PIWI_DASHBOARD_URL` / `PIWI_API_KEY` /
    skeleton: a title, `piwi:` annotations from the nearest test, the graph path
    from a reached page to the gap as the step list, the catalog page-object
    methods that match the page, and a `TODO` assertion naming what to check.
-   Nothing is committed — the skeleton is yours to finish.
+   Nothing is committed — the skeleton is yours to finish. When the gap points at
+   application code (an uncovered file, a handler, an error path), name the target
+   lines in it and call `get_coverage` with `projectId`, `file` and `lines`:
+   `nearest` is the existing test running most of the function around them, the
+   one whose setup to copy.
 
 4. **Finish the assertion.** The draft reaches the subject; you write the check.
    For a false-comfort gap, assert the effect the probe fault suppressed (the row
@@ -51,11 +55,33 @@ view, or the reporter CLI with `PIWI_DASHBOARD_URL` / `PIWI_API_KEY` /
    for the right reason: temporarily break the behavior it asserts and see it
    fail. Open it in the same pull request as the change that motivated it.
 
-6. **Report.** State which gap you closed (class, subject, score) and how the new
-   test asserts the missing behavior. If the gap had no reachable path, say so —
-   the draft cannot invent an entry point, and the gap may need a fixture.
+6. **Prove it reaches its target lines.** When the project records server
+   coverage (an ASP.NET Core backend in a coverage build), run the new test with
+   it on and reporting to Piwi:
 
-7. **Report back to Piwi.** Tell Piwi what you decided about the gap with
+   ```bash
+   PIWI_COVERAGE_SERVER=lines npx playwright test <file> -g "<title>"
+   ```
+
+   ```powershell
+   $env:PIWI_COVERAGE_SERVER='lines'; npx playwright test <file> -g "<title>"
+   ```
+
+   Then call `get_coverage` with `projectId`, `testFile`, `testTitle`, `file`
+   and `lines` (the target lines). `ran` lists the target lines it executed,
+   `notRan` those it did not, `notExecutable` those that cannot run (blank lines,
+   comments), and `unknown` those the capture could not tell: run it again, and
+   check the backend records `lines`, not only files. While a target line did not
+   run, compare your test with `nearest`, change the steps or the data that lead
+   to that code, and run again, until `allRan` is true. If `get_coverage` says the
+   project records no coverage, skip this step and say so in the report.
+
+7. **Report.** State which gap you closed (class, subject, score), how the new
+   test asserts the missing behavior, and which target lines it ran. If the gap
+   had no reachable path, say so — the draft cannot invent an entry point, and
+   the gap may need a fixture.
+
+8. **Report back to Piwi.** Tell Piwi what you decided about the gap with
    `triage_gap` (reporter or admin access): `verb: "accept"` for the gap you
    wrote the test for, `covered-by` with the covering test's id when a test you
    found already covers it, or `dismiss` with the reason (`not-worth-testing`,