@piwitests/reporter 0.60.0 → 0.61.0

package/dist/index.js

@@ -203,6 +203,7 @@ var PIWI_ENV_KEYS = {
   codeReachRoots: "PIWI_CODE_REACH_ROOTS",
   coverageBrowser: "PIWI_COVERAGE_BROWSER",
   coverageServer: "PIWI_COVERAGE_SERVER",
+  coverageCss: "PIWI_COVERAGE_CSS",
   externalIdPattern: "PIWI_EXTERNAL_ID_PATTERN",
   externalIdOnDuplicate: "PIWI_EXTERNAL_ID_ON_DUPLICATE",
   captureServerTraces: "PIWI_CAPTURE_SERVER_TRACES",
@@ -357,10 +358,14 @@ function resolveOptions(raw, configDir) {
   const coverage = { ...mergedRaw.coverage };
   const coverageBrowser = env[PIWI_ENV_KEYS.coverageBrowser];
   const coverageServer = env[PIWI_ENV_KEYS.coverageServer];
+  const coverageCss = env[PIWI_ENV_KEYS.coverageCss];
   if (coverage.browser === void 0 && coverageBrowser)
     coverage.browser = coverageBrowser;
   if (coverage.server === void 0 && coverageServer) coverage.server = coverageServer;
-  if (coverage.browser !== void 0 || coverage.server !== void 0) mergedRaw.coverage = coverage;
+  if (coverage.css === void 0 && coverageCss) coverage.css = coverageCss;
+  if (coverage.browser !== void 0 || coverage.server !== void 0 || coverage.css !== void 0) {
+    mergedRaw.coverage = coverage;
+  }
   const externalId = { ...mergedRaw.externalId };
   const externalIdPattern = env[PIWI_ENV_KEYS.externalIdPattern];
   const externalIdOnDuplicate = env[PIWI_ENV_KEYS.externalIdOnDuplicate];
@@ -406,9 +411,11 @@ function applyOptionsToEnv(options) {
   if (options.collectPerformanceMetrics === false) {
     env[PIWI_ENV_KEYS.coverageBrowser] = "off";
     env[PIWI_ENV_KEYS.coverageServer] = "off";
+    env[PIWI_ENV_KEYS.coverageCss] = "off";
   } else {
     if (options.coverage?.browser !== void 0) env[PIWI_ENV_KEYS.coverageBrowser] = options.coverage.browser;
     if (options.coverage?.server !== void 0) env[PIWI_ENV_KEYS.coverageServer] = options.coverage.server;
+    if (options.coverage?.css !== void 0) env[PIWI_ENV_KEYS.coverageCss] = options.coverage.css;
   }
   if (options.captureServerTraces === false || options.collectPerformanceMetrics === false)
     env[PIWI_ENV_KEYS.captureServerTraces] = "false";
@@ -1312,6 +1319,8 @@ var ATTACHMENT_NAMES = {
   codeReach: "piwi-code-reach",
   browserCoverage: "piwi-browser-coverage",
   browserFunctions: "piwi-browser-functions",
+  cssCoverage: "piwi-css-coverage",
+  cssRules: "piwi-css-rules",
   serverCoverageRequests: "piwi-server-coverage-requests",
   webVitals: "piwi-web-vitals",
   locatorSuggestion: "piwi-locator-suggestion",
@@ -1478,10 +1487,10 @@ var FileHandler = class {
   /** Parse Piwi-internal attachment bodies (`piwi-network`, `piwi-web-vitals`, `piwi-console`, `piwi-aria-snapshot`, `piwi-aria-snapshot-json`) into structured fields on the test case */
   parsePerformanceAttachments(testCase, attachments) {
     const find = (name) => attachments.find((a) => a.name === name);
-    const net2 = find(ATTACHMENT_NAMES.network);
-    if (net2?.body) {
+    const net3 = find(ATTACHMENT_NAMES.network);
+    if (net3?.body) {
       try {
-        testCase.networkRequests = JSON.parse(net2.body.toString());
+        testCase.networkRequests = JSON.parse(net3.body.toString());
       } catch {
       }
     }
@@ -2119,6 +2128,8 @@ var StreamManager = class {
     this._token = null;
     this._auth = null;
     this._startPromise = null;
+    /** Called when the dashboard says someone opened the run. */
+    this.onWatched = null;
     const maxBytes = this.options.maxStreamBufferBytes ?? 0;
     this.pendingEvents = new BoundedEventQueue(maxBytes);
     this.pendingBeginEvents = new BoundedEventQueue(maxBytes);
@@ -2143,6 +2154,10 @@ var StreamManager = class {
   get startPromise() {
     return this._startPromise;
   }
+  /** Whether anyone has the run open live, as the dashboard last said; `null` until it says. */
+  get isWatched() {
+    return this.watched;
+  }
   /**
    * Whether a test-result (`complete`) event never reached the server through
    * the live stream: shed under buffer pressure, too large for any request the
@@ -2393,8 +2408,11 @@ var StreamManager = class {
       if (this.pendingEvents.length > 0) this.flush();
     }, delay);
   }
-  // Take the dashboard's answer on whether anyone watches the run. An answer
-  // without the flag (an older dashboard) keeps step events flowing.
+  /**
+   * Take the dashboard's answer on whether anyone watches the run, from any
+   * request of the stream. An answer without the flag (an older dashboard)
+   * keeps step events flowing.
+   */
   noteWatched(response) {
     const watched = response?.watched;
     const next = typeof watched === "boolean" ? watched : null;
@@ -2403,7 +2421,9 @@ var StreamManager = class {
         next ? "The run is open on the dashboard: streaming live steps." : "Nobody is watching the run: live steps are not sent."
       );
     }
+    const opened = next === true && this.watched !== true;
     this.watched = next;
+    if (opened) this.onWatched?.();
   }
   // Idle time after which a heartbeat goes out.
   heartbeatDelay() {
@@ -3903,7 +3923,7 @@ function collectSourceFrames(errorText, testFile2, declLine, opts = {}) {
   const maxFrames = opts.maxFrames ?? 4;
   const picked = [];
   const seen = /* @__PURE__ */ new Set();
-  const add = (absFile, line) => {
+  const add2 = (absFile, line) => {
     const key = `${absFile}:${line}`;
     if (seen.has(key)) return;
     seen.add(key);
@@ -3920,12 +3940,12 @@ function collectSourceFrames(errorText, testFile2, declLine, opts = {}) {
       }
       const rel = path11.relative(projectRoot, abs);
       if (rel.startsWith("..") || path11.isAbsolute(rel)) continue;
-      if (!isNaN(frame.line)) add(abs, frame.line);
+      if (!isNaN(frame.line)) add2(abs, frame.line);
     }
   }
   const absTest = path11.resolve(testFile2);
   if (!picked.some((p) => p.absFile === absTest)) {
-    add(absTest, extractFailingLine(errorText, testFile2, declLine));
+    add2(absTest, extractFailingLine(errorText, testFile2, declLine));
   }
   const frames = [];
   for (const p of picked.slice(0, maxFrames)) {
@@ -4085,6 +4105,7 @@ function isDueForAriaSample(testInfo) {
 }
 
 // src/internal/support/base-url-check.ts
+var net = __toESM(require("net"));
 var BASE_URL_CHECK_ATTEMPTS = 3;
 var BASE_URL_CHECK_TIMEOUT_MS = 1e4;
 var BASE_URL_CHECK_DELAY_MS = 2e3;
@@ -4106,9 +4127,9 @@ function cliProjectNames(argv = process.argv) {
   }
   return names;
 }
-function wildcard(pattern) {
+function wildcard(pattern, flags = "i") {
   const escaped = pattern.split("*").map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
-  return new RegExp(`^${escaped.join(".*")}$`, "i");
+  return new RegExp(`^${escaped.join(".*")}$`, flags);
 }
 function selectedProjects(projects, argv = process.argv, filtered) {
   let chosen;
@@ -4118,7 +4139,7 @@ function selectedProjects(projects, argv = process.argv, filtered) {
   } else {
     const names = cliProjectNames(argv);
     if (!names || names.length === 0) return projects;
-    const patterns = names.map(wildcard);
+    const patterns = names.map((name) => wildcard(name));
     chosen = new Set(projects.filter((p) => patterns.some((re) => re.test(p.name ?? ""))));
   }
   if (!argv.includes("--no-deps")) {
@@ -4140,23 +4161,58 @@ function asProxy(value) {
   const proxy = value;
   return proxy && typeof proxy === "object" && typeof proxy.server === "string" ? proxy : void 0;
 }
-function baseUrlTargets(config, argv = process.argv) {
+function exposeNetworkCovers(rule, url) {
+  if (!rule) return false;
+  let parsed2;
+  try {
+    parsed2 = new URL(url);
+  } catch {
+    return false;
+  }
+  const host = parsed2.hostname;
+  const port = parsed2.port ? Number(parsed2.port) : parsed2.protocol === "https:" ? 443 : 80;
+  return rule.split(",").some((token) => {
+    const match = token.match(/^(.*?)(?::(\d+))?$/);
+    if (!match) return false;
+    if (match[2] !== void 0 && Number(match[2]) !== port) return false;
+    const tokenHost = match[1];
+    if (tokenHost === "<loopback>") {
+      return host === "localhost" || host.endsWith(".localhost") || host === "127.0.0.1" || host === "[::1]";
+    }
+    if (tokenHost === "*") return true;
+    if (net.isIP(tokenHost)) return host === tokenHost;
+    if (net.isIP(host)) return false;
+    return wildcard(tokenHost.startsWith(".") ? `*${tokenHost}` : tokenHost, "").test(host);
+  });
+}
+function reachedRemotely(use, url, env) {
+  if (use?.connectOptions === void 0) {
+    return !!env.PW_TEST_CONNECT_WS_ENDPOINT && !exposeNetworkCovers(env.PW_TEST_CONNECT_EXPOSE_NETWORK, url);
+  }
+  const connect2 = use.connectOptions;
+  if (!connect2 || typeof connect2 !== "object" || typeof connect2.wsEndpoint !== "string") return false;
+  return !exposeNetworkCovers(typeof connect2.exposeNetwork === "string" ? connect2.exposeNetwork : void 0, url);
+}
+function baseUrlTargets(config, argv = process.argv, env = process.env) {
   const projects = config.projects?.length ? config.projects : [{ name: "", use: config.use }];
   const filtered = config.projects?.length ? config.filteredProjects : void 0;
   const targets = /* @__PURE__ */ new Map();
   for (const project of selectedProjects(projects, argv, filtered)) {
     const url = project.use?.baseURL;
     if (typeof url !== "string" || !/^https?:\/\//i.test(url)) continue;
+    const remoteBrowser = reachedRemotely(project.use, url, env);
     const target = targets.get(url);
     if (target) {
       if (project.name) target.projects.push(project.name);
+      target.remoteBrowser ||= remoteBrowser;
       continue;
     }
     targets.set(url, {
       url,
       projects: project.name ? [project.name] : [],
       ignoreHTTPSErrors: project.use?.ignoreHTTPSErrors === true,
-      proxy: asProxy(project.use?.proxy)
+      proxy: asProxy(project.use?.proxy),
+      remoteBrowser
     });
   }
   return [...targets.values()];
@@ -4197,14 +4253,21 @@ async function checkBaseUrl(target, options = {}) {
   }
   return `${reason} (${attempts} ${attempts === 1 ? "attempt" : "attempts"})`;
 }
+function remoteBrowserNote(target) {
+  if (!target.remoteBrowser) return null;
+  const { host } = new URL(target.url);
+  return `The check ran from this machine's network, but a project's remote browser reaches ${host} from its own, since its exposeNetwork rule does not cover that address.`;
+}
 async function checkBaseUrls(config, options = {}) {
-  const targets = baseUrlTargets(config, options.argv);
+  const targets = baseUrlTargets(config, options.argv, options.env);
   const reasons = await Promise.all(targets.map((target) => checkBaseUrl(target, options)));
   const down = targets.flatMap((target, i) => reasons[i] ? [{ target, reason: reasons[i] }] : []);
   if (down.length === 0) return targets;
   const lines = down.map(({ target, reason }) => {
     const used = target.projects.length > 0 ? ` (${target.projects.join(", ")})` : "";
-    return `  ${target.url}${used}: ${reason}`;
+    const note = remoteBrowserNote(target);
+    return `  ${target.url}${used}: ${reason}${note ? `
+    ${note}` : ""}`;
   });
   const message = [
     `[Piwi Dashboard] The app under test did not answer, so no test ran:`,
@@ -4709,7 +4772,7 @@ function instanceOf(answer) {
   return { id: instance.id, startedAt };
 }
 function processKeyOf(id) {
-  const dot = id.lastIndexOf(".");
+  const dot = id.indexOf(".");
   return dot > 0 ? id.slice(0, dot) : null;
 }
 function withTestCoverage(files, tests) {
@@ -5127,7 +5190,16 @@ function createGlobalSetup(options, userSetup) {
     }
     if (opts.checkBaseUrl === true) {
       const checked = await checkBaseUrls(config ?? {});
-      for (const target of checked) logger.debug(`Base URL answered: ${target.url}`);
+      for (const target of checked) {
+        const note = remoteBrowserNote(target);
+        if (note) {
+          logger.info(
+            `Base URL answered: ${target.url}. ${note} A navigation failure from that browser can mean its machine cannot reach the app, not that the app is down.`
+          );
+        } else {
+          logger.debug(`Base URL answered: ${target.url}`);
+        }
+      }
     }
     if (opts.enabled === false || !opts.serverUrl) {
       logger.info("Not enabled \u2014 set PIWI_DASHBOARD_URL or serverUrl to enable.");
@@ -8446,6 +8518,12 @@ async function dirBytes(dir, budget) {
   }
   return bytes;
 }
+function memoryOf(container) {
+  const totalMemory = os8.totalmem();
+  const constrained = typeof process.constrainedMemory === "function" ? process.constrainedMemory() : void 0;
+  const limit = container?.memoryLimitBytes ?? (constrained && constrained > 0 ? constrained : null);
+  return { memoryBytes: totalMemory, memoryLimitBytes: limit !== null && limit < totalMemory ? limit : null };
+}
 var RunSampler = class {
   constructor(options = {}) {
     this.timer = null;
@@ -8514,6 +8592,18 @@ var RunSampler = class {
     }
     return this.profile(await this.leftoverBytes());
   }
+  /**
+   * What a live run's memory is drawn against: the machine's memory, or its
+   * container's limit when lower, read once, and how the run's memory is
+   * measured so far.
+   */
+  liveMemory() {
+    if (this.capacityBytes === void 0) {
+      const machine = memoryOf(this.linux ? this.cgroup.read() : null);
+      this.capacityBytes = machine.memoryLimitBytes ?? machine.memoryBytes;
+    }
+    return { capacityBytes: this.capacityBytes || null, kind: this.memoryKind };
+  }
   /** The series read so far, each point at the time it was read. */
   timedSeries() {
     return {
@@ -8810,9 +8900,6 @@ var RunSampler = class {
     if (cpuPressure === null) notMeasured.push("CPU pressure");
     const container = this.linux ? this.cgroup.read() : null;
     const startContainer = this.containerStart;
-    const totalMemory = os8.totalmem();
-    const constrained = typeof process.constrainedMemory === "function" ? process.constrainedMemory() : void 0;
-    const limit = container?.memoryLimitBytes ?? (constrained && constrained > 0 ? constrained : null);
     const raisedPeak = container?.memoryPeakBytes != null && startContainer?.memoryPeakBytes != null && container.memoryPeakBytes > startContainer.memoryPeakBytes ? container.memoryPeakBytes : null;
     const delta = (to, from) => to != null && from != null ? Math.max(0, to - from) : null;
     return {
@@ -8820,8 +8907,7 @@ var RunSampler = class {
       wallMs,
       machine: {
         cores: typeof os8.availableParallelism === "function" ? os8.availableParallelism() : os8.cpus().length,
-        memoryBytes: totalMemory,
-        memoryLimitBytes: limit !== null && limit < totalMemory ? limit : null,
+        ...memoryOf(container),
         cpuQuotaCores: container?.cpuQuotaCores ?? null
       },
       cpu: {
@@ -9093,7 +9179,7 @@ function openPagesByWorker(censuses) {
   }
   return out;
 }
-function pagesOverTime(censuses) {
+function pagesOverTime(censuses, live = false) {
   const byWorker = /* @__PURE__ */ new Map();
   for (const census of censuses) {
     const list = byWorker.get(census.worker) ?? [];
@@ -9126,7 +9212,7 @@ function pagesOverTime(censuses) {
       if (last && last[0] === at) last[1] = open;
       else events.push([at, open]);
     }
-    if (open > 0 && lastAt >= events[events.length - 1][0]) events.push([lastAt, 0]);
+    if (!live && open > 0 && lastAt >= events[events.length - 1][0]) events.push([lastAt, 0]);
     out.push({ worker, events });
   }
   return out;
@@ -9195,6 +9281,144 @@ function resourceReportWire(input) {
   };
 }
 
+// src/internal/streaming/live-resources.ts
+var LIVE_INTERVAL_MS = 5e3;
+function since(points, cursor, cap, merge) {
+  const fresh = cursor === void 0 ? points : points.filter(([at]) => at > cursor);
+  return downsamplePoints(fresh, cap, merge);
+}
+var LiveResources = class {
+  constructor(stream, httpClient, options, logger = new Logger()) {
+    this.stream = stream;
+    this.httpClient = httpClient;
+    this.options = options;
+    this.logger = logger;
+    this.timer = null;
+    this.inFlight = null;
+    this.stopped = false;
+    /** Whether the next post must carry every point: the first one, and after the dashboard lost them. */
+    this.reset = true;
+    /** The time of the last point the dashboard took, per series. */
+    this.sent = /* @__PURE__ */ new Map();
+    /** How many censuses the open pages last posted came from. */
+    this.censusCount = 0;
+  }
+  /** Post on a timer that never keeps the process alive. */
+  start() {
+    if (this.timer || this.stopped) return;
+    this.timer = setInterval(() => this.tick(), this.options.intervalMs ?? LIVE_INTERVAL_MS);
+    this.timer.unref?.();
+  }
+  /** Post nothing more, and wait for a post in flight. */
+  async stop() {
+    this.stopped = true;
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+    await this.inFlight;
+  }
+  /** Post now, when the run is watched and no post is in flight: the dashboard says someone just opened it. */
+  tick() {
+    if (this.stopped || this.inFlight) return null;
+    const { enabled, runId, token } = this.stream;
+    if (!enabled || runId === null || !token || this.stream.isWatched !== true) return null;
+    let draft;
+    try {
+      draft = this.draft();
+    } catch (error) {
+      this.logger.debug(`Live resources not read: ${errorMessage(error)}`);
+      return null;
+    }
+    if (!draft) return null;
+    this.inFlight = this.send(runId, token, draft).finally(() => {
+      this.inFlight = null;
+    });
+    return this.inFlight;
+  }
+  /** What is new since the last post the dashboard took; null when nothing is. */
+  draft() {
+    const samples = this.options.sampler?.timedSeries() ?? null;
+    const startedAt = samples?.startedAt || this.options.runStartedAt;
+    const censuses = this.options.censuses();
+    const cursors = this.reset ? /* @__PURE__ */ new Map() : this.sent;
+    const sent = new Map(cursors);
+    let fresh = false;
+    const take = (key, points, cap, merge) => {
+      const out = since(points, cursors.get(key), cap, merge);
+      const last = points[points.length - 1];
+      if (out.length > 0 && last) {
+        sent.set(key, last[0]);
+        fresh = true;
+      }
+      return out;
+    };
+    const timeline = { startedAt, cpuPct: [], memoryBytes: [], pages: [], workers: [] };
+    if (samples) {
+      timeline.cpuPct = take("cpu", samples.cpuPct, TIMELINE_SERIES_CAP, "mean");
+      timeline.memoryBytes = take("memory", samples.memoryBytes, TIMELINE_SERIES_CAP, "max");
+      for (const tree of workerTreesByIndex(samples, censuses)) {
+        const cpuCores = take(`cores:${tree.worker}`, tree.cpuCores, TIMELINE_WORKER_POINTS_CAP, "mean");
+        const memoryBytes = take(`bytes:${tree.worker}`, tree.memoryBytes, TIMELINE_WORKER_POINTS_CAP, "max");
+        if (cpuCores.length > 0 || memoryBytes.length > 0) {
+          timeline.workers.push({ worker: tree.worker, cpuCores, memoryBytes });
+        }
+      }
+    }
+    if (this.reset || censuses.length !== this.censusCount) {
+      for (const { worker, events } of pagesOverTime(censuses, true)) {
+        const points = events.map(([at, open]) => [at - startedAt, open]);
+        const last = points.pop();
+        timeline.pages.push({
+          worker,
+          points: [...downsamplePoints(points, TIMELINE_WORKER_POINTS_CAP - 1, "max"), last]
+        });
+      }
+      fresh ||= timeline.pages.length > 0;
+    }
+    if (!fresh) return null;
+    const memory = this.options.sampler?.liveMemory() ?? { capacityBytes: null, kind: null };
+    return {
+      post: {
+        shardIndex: this.options.shardIndex,
+        reset: this.reset,
+        timeline,
+        memoryCapacityBytes: memory.capacityBytes,
+        memoryKind: memory.kind
+      },
+      sent,
+      censusCount: censuses.length
+    };
+  }
+  async send(runId, token, draft) {
+    try {
+      const answer = await this.httpClient.postJSON(
+        `/api/test-runs/${runId}/live-resources`,
+        { streamToken: token, ...draft.post },
+        this.stream.auth
+      );
+      if (answer?.declined) {
+        this.logger.debug("The project declined resources: live resources are not sent.");
+        this.stopped = true;
+        return;
+      }
+      this.stream.noteWatched(answer);
+      if (answer?.resync) {
+        this.reset = true;
+        return;
+      }
+      this.sent = draft.sent;
+      this.censusCount = draft.censusCount;
+      this.reset = false;
+    } catch (error) {
+      if (error instanceof HttpError && error.status === 404) {
+        this.logger.debug("The dashboard takes no live resources.");
+        this.stopped = true;
+        return;
+      }
+      this.logger.debug(`Live resources not sent: ${errorMessage(error)}`);
+    }
+  }
+};
+
 // ../core/src/describe-failure.ts
 var HEADLINE_MAX_CHARS = 120;
 var VALUE_MAX_CHARS = 40;
@@ -9724,10 +9948,14 @@ function isServerGranularity(value) {
   return typeof value === "string" && SERVER_VALUES.has(value);
 }
 function coverageSettings(options) {
-  if (options.collectPerformanceMetrics === false) return { browser: "off", server: "off" };
+  if (options.collectPerformanceMetrics === false) return { browser: "off", server: "off", css: "off" };
   const browser = options.coverage?.browser === "functions" ? "functions" : options.coverage?.browser === "files" || options.captureCodeReach === true ? "files" : "off";
   const server = isServerGranularity(options.coverage?.server) ? options.coverage.server : "off";
-  return { browser, server };
+  const css = options.coverage?.css === "rules" ? "rules" : "off";
+  return { browser, server, css };
+}
+function cssCoverageInWorker() {
+  return process.env[PIWI_ENV_KEYS.coverageCss] === "rules";
 }
 function browserCoverageInWorker() {
   const browser = process.env[PIWI_ENV_KEYS.coverageBrowser];
@@ -9847,10 +10075,10 @@ function joinRoot(root, source) {
 function decodeLines(raw) {
   const sources = [];
   const decoded = [];
-  const add = (map, lineOffset, columnOffset) => {
+  const add2 = (map, lineOffset, columnOffset) => {
     if (map.sections) {
       for (const section of map.sections) {
-        if (!add(section.map, section.offset.line, section.offset.column)) return false;
+        if (!add2(section.map, section.offset.line, section.offset.column)) return false;
       }
       return true;
     }
@@ -9871,7 +10099,7 @@ function decodeLines(raw) {
     });
     return true;
   };
-  return add(raw, 0, 0) ? { sources, lines: decoded } : null;
+  return add2(raw, 0, 0) ? { sources, lines: decoded } : null;
 }
 function compactSegments(lines) {
   let total = 0;
@@ -10047,7 +10275,7 @@ function functionLines(entry, map, text, all) {
   const read = textOf(entry, text);
   const ranges = executedFunctionRanges(entry, read?.length, all);
   if (!ranges.length || !read) return out;
-  const add = (source, range) => {
+  const add2 = (source, range) => {
     const list = out.get(source);
     if (list) list.push(range);
     else out.set(source, [range]);
@@ -10057,7 +10285,7 @@ function functionLines(entry, map, text, all) {
     const start = offsetToPosition(starts, range.start);
     if (!map) {
       const last = offsetToPosition(starts, Math.max(range.start, range.end - 1));
-      add(-1, [start.line + 1, last.line + 1]);
+      add2(-1, [start.line + 1, last.line + 1]);
       continue;
     }
     const at = map.originalAt(start.line, start.column);
@@ -10067,7 +10295,7 @@ function functionLines(entry, map, text, all) {
     if (first === null) continue;
     const header = first === at.line || first === at.line + 1 ? at.line : first;
     const lines = map.originalLinesBetween(at.source, start, end, header);
-    if (lines) add(at.source, [header + 1, lines[1] + 1]);
+    if (lines) add2(at.source, [header + 1, lines[1] + 1]);
   }
   return out;
 }
@@ -10261,7 +10489,7 @@ async function resolveFunctions(entries, roots, fetchMap, pageUrl, withKnown) {
     if (listed) listed.push(...functions);
     else into.set(path34, [...functions]);
   };
-  const add = (file, functions) => addTo(files, file, functions);
+  const add2 = (file, functions) => addTo(files, file, functions);
   const bases = viteBases(entries);
   const scripts = entries.filter((entry) => entry.url && entry.functions?.length && !REPLAYED_SCRIPT.test(entry.url));
   const cached = scripts.map((entry) => scriptCache.get(entry.url, scriptVersion(entry)));
@@ -10288,14 +10516,14 @@ async function resolveFunctions(entries, roots, fetchMap, pageUrl, withKnown) {
       const text = textOf2(covered, resolution);
       if (resolution.lookup) {
         const reached = reachedFunctionLines(covered, resolution.lookup, text);
-        if (reached.size > 0) add(resolution.file, [...reached.values()].flat());
+        if (reached.size > 0) add2(resolution.file, [...reached.values()].flat());
       } else if (scriptRan(covered, text)) {
-        add(resolution.file, reachedFunctionLines(covered, null, text).get(-1) ?? []);
+        add2(resolution.file, reachedFunctionLines(covered, null, text).get(-1) ?? []);
       }
     } else if (resolution.kind === "map") {
       for (const [index, functions] of reachedFunctionLines(covered, resolution.lookup, textOf2(covered, resolution))) {
         const file = mapFile(resolution, index);
-        if (file) add(file, functions);
+        if (file) add2(file, functions);
       }
     }
     if (!withKnown || resolution.kind === "none") continue;
@@ -10374,10 +10602,13 @@ async function markCurrentDocument(page, cdp) {
 }
 function onPaused(page, capture, event) {
   const leaving = event.reason === "EventListener" && event.data?.eventName === "listener:beforeunload" && (event.callFrames?.[0]?.functionName ?? MARK_FUNCTION) === MARK_FUNCTION;
-  const read = leaving ? readCoverage(page, capture.cdp) : null;
+  const read = leaving ? Promise.all([
+    capture.js ? readCoverage(page, capture.cdp) : Promise.resolve([]),
+    capture.css ? readCssUsage(page, capture.cdp, capture.css) : Promise.resolve()
+  ]) : null;
   if (read) {
     const merging = read.then(
-      (coverage) => mergeCoverageRead(capture.ran, capture.scripts, coverage, capture.keepIdle)
+      ([coverage]) => mergeCoverageRead(capture.ran, capture.scripts, coverage, capture.keepIdle)
     );
     capture.reading.add(merging);
     void merging.finally(() => capture.reading.delete(merging));
@@ -10391,7 +10622,7 @@ function versionKey(url, hash) {
   return `${hash} ${url}`;
 }
 function onScriptParsed(page, capture, event) {
-  if (!event.url || REPLAYED_SCRIPT.test(event.url)) return;
+  if (!capture.js || !event.url || REPLAYED_SCRIPT.test(event.url)) return;
   capture.scripts.set(event.scriptId, { url: event.url, hash: event.hash, pageUrl: capture.pageUrl });
   if (NEVER_REACHED.test(event.url)) return;
   const key = versionKey(event.url, event.hash);
@@ -10420,6 +10651,53 @@ function readCoverage(page, cdp) {
   );
   return Promise.race([taken, late]).finally(() => clearTimeout(timer));
 }
+function onStyleSheetAdded(page, cdp, css, pageUrl, header) {
+  if (header.isConstructed) return;
+  const sheet = {
+    sourceURL: header.sourceURL,
+    ...header.sourceMapURL ? { sourceMapURL: header.sourceMapURL } : {},
+    isInline: header.isInline,
+    startLine: header.startLine,
+    pageUrl,
+    used: /* @__PURE__ */ new Map()
+  };
+  css.sheets.set(header.styleSheetId, sheet);
+  const reading = (async () => {
+    try {
+      if (header.ownerNode !== void 0 && !/\.css(?:[?#]|$)/i.test(header.sourceURL)) {
+        const { node } = await internalCall(
+          page,
+          () => cdp.send("DOM.describeNode", { backendNodeId: header.ownerNode })
+        );
+        const attributes = node.attributes ?? [];
+        const at = attributes.indexOf("data-vite-dev-id");
+        if (at >= 0 && typeof attributes[at + 1] === "string") sheet.devId = attributes[at + 1];
+      }
+      if (/\/node_modules\//.test(sheet.devId ?? header.sourceURL)) return;
+      const { text } = await internalCall(
+        page,
+        () => cdp.send("CSS.getStyleSheetText", { styleSheetId: header.styleSheetId })
+      );
+      sheet.text = text;
+    } catch {
+    }
+  })();
+  css.reading.add(reading);
+  void reading.finally(() => css.reading.delete(reading));
+}
+async function readCssUsage(page, cdp, css) {
+  try {
+    const { coverage } = await internalCall(page, () => cdp.send("CSS.takeCoverageDelta"));
+    for (const rule of coverage) {
+      if (!rule.used) continue;
+      css.sheets.get(rule.styleSheetId)?.used.set(`${rule.startOffset}:${rule.endOffset}`, {
+        startOffset: rule.startOffset,
+        endOffset: rule.endOffset
+      });
+    }
+  } catch {
+  }
+}
 function mergeCoverageRead(ran, scripts, read, keepIdle = true) {
   for (const covered of read) {
     const script = scripts.get(covered.scriptId);
@@ -10454,11 +10732,15 @@ async function detach(page, cdp) {
 }
 async function startCodeReach(page) {
   if (!isChromiumPage(page) || captures.has(page)) return false;
+  const withCss = cssCoverageInWorker();
+  const js = browserCoverageInWorker() || !withCss;
   let cdp = null;
   try {
     cdp = await internalCall(page, () => page.context().newCDPSession(page));
     const capture = {
       cdp,
+      js,
+      css: withCss ? { sheets: /* @__PURE__ */ new Map(), reading: /* @__PURE__ */ new Set() } : null,
       scripts: /* @__PURE__ */ new Map(),
       sources: /* @__PURE__ */ new Map(),
       ran: /* @__PURE__ */ new Map(),
@@ -10468,6 +10750,9 @@ async function startCodeReach(page) {
     };
     const marks = marksOf(page);
     cdp.on("Debugger.scriptParsed", (event) => onScriptParsed(page, capture, event));
+    const css = capture.css;
+    if (css)
+      cdp.on("CSS.styleSheetAdded", (event) => onStyleSheetAdded(page, cdp, css, capture.pageUrl, event.header));
     cdp.on("Debugger.paused", (event) => onPaused(page, capture, event));
     cdp.on("Page.frameNavigated", (event) => {
       if (event.frame.parentId) return;
@@ -10478,8 +10763,17 @@ async function startCodeReach(page) {
       page,
       () => Promise.all([
         capture.cdp.send("Debugger.enable"),
-        capture.cdp.send("Profiler.enable"),
-        capture.cdp.send("Profiler.startPreciseCoverage", { callCount: false, detailed: false }),
+        ...js ? [
+          capture.cdp.send("Profiler.enable"),
+          capture.cdp.send("Profiler.startPreciseCoverage", { callCount: false, detailed: false })
+        ] : [],
+        // The style sheets' rule usage records nothing without the DOM and CSS domains. A failure there leaves the
+        // scripts' coverage running.
+        ...css ? [
+          capture.cdp.send("DOM.enable").then(() => capture.cdp.send("CSS.enable")).then(() => capture.cdp.send("CSS.startRuleUsageTracking")).catch(() => {
+            capture.css = null;
+          })
+        ] : [],
         capture.cdp.send("Page.enable"),
         capture.cdp.send("Page.addScriptToEvaluateOnNewDocument", { source: MARK_SOURCE, worldName: MARK_WORLD }),
         capture.cdp.send("DOMDebugger.setEventListenerBreakpoint", { eventName: "beforeunload" })
@@ -10493,18 +10787,26 @@ async function startCodeReach(page) {
     return false;
   }
 }
-async function stopCodeReach(page) {
+async function stopPageCoverage(page) {
   const capture = captures.get(page);
-  if (!capture) return null;
+  if (!capture) return { scripts: null, sheets: [] };
   captures.delete(page);
   const { cdp } = capture;
-  try {
+  const sheets = async () => {
+    if (!capture.css) return [];
+    await readCssUsage(page, cdp, capture.css);
+    await Promise.all(capture.css.reading);
+    await internalCall(page, () => cdp.send("CSS.stopRuleUsageTracking")).catch(() => {
+    });
+    return [...capture.css.sheets.values()].filter((sheet) => sheet.used.size > 0 || sheet.text !== void 0);
+  };
+  const scripts = async () => {
+    if (!capture.js) return null;
     const last = await internalCall(page, async () => {
       const taken = await cdp.send("Profiler.takePreciseCoverage");
       await cdp.send("Profiler.stopPreciseCoverage");
       return taken.result;
     });
-    await Promise.all(capture.reading);
     mergeCoverageRead(capture.ran, capture.scripts, last, capture.keepIdle);
     const entries = [];
     for (const [key, { script, functions }] of capture.ran) {
@@ -10514,8 +10816,11 @@ async function stopCodeReach(page) {
       entries.push(entry);
     }
     return entries;
-  } catch {
-    return null;
+  };
+  try {
+    await Promise.all(capture.reading);
+    const [read, styles] = await Promise.all([scripts().catch(() => null), sheets().catch(() => [])]);
+    return { scripts: read, sheets: styles };
   } finally {
     await detach(page, cdp);
   }
@@ -10632,7 +10937,7 @@ var SETTLE_WAIT_MS = 15e3;
 var RUN_COVERAGE_FILES_PER_REQUEST = 5e3;
 var RUN_COVERAGE_BYTES_PER_REQUEST = 8 * 1024 * 1024;
 var INCOMPLETE = { files: [], incomplete: true };
-function composeTestCoverage(server, browserFiles, settings) {
+function composeTestCoverage(server, browserFiles, settings, cssFiles) {
   const serverCapture = settings.server !== "off" && server ? reduceCoverage(
     {
       v: 1,
@@ -10650,7 +10955,19 @@ function composeTestCoverage(server, browserFiles, settings) {
     },
     settings.browser
   ) : null;
-  const merged = mergeCoverage(serverCapture, browserCapture);
+  const wholeFiles = new Set(
+    settings.browser === "functions" ? [] : (browserFiles ?? []).map((file) => typeof file === "string" ? file : file.path)
+  );
+  const cssCapture = settings.css === "rules" && cssFiles?.length ? reduceCoverage(
+    {
+      v: 1,
+      files: cssFiles.map(
+        (file) => wholeFiles.has(file.path) ? { path: file.path, runtime: "browser" } : { ...file, runtime: "browser" }
+      )
+    },
+    "functions"
+  ) : null;
+  const merged = mergeCoverage(serverCapture, mergeCoverage(browserCapture, cssCapture));
   return merged ? sanitizeCoverage(merged) : null;
 }
 function addRanges(into, filePath2, ranges) {
@@ -10710,7 +11027,7 @@ var CoverageCollection = class {
     this.browserKnown = /* @__PURE__ */ new Map();
     this.logger = options.logger ?? new Logger();
     this.waitMs = options.waitMs ?? TEST_COVERAGE_WAIT_MS;
-    this.browserBlobs = options.settings.browser === "functions" ? new BlobIds(() => repositoryRoot(options.configDir)) : null;
+    this.browserBlobs = options.settings.browser === "functions" || options.settings.css === "rules" ? new BlobIds(() => repositoryRoot(options.configDir)) : null;
     const granularity = options.settings.server;
     this.collector = granularity === "off" ? null : new ServerCoverageCollector({
       granularity,
@@ -10727,28 +11044,40 @@ var CoverageCollection = class {
   /**
    * The browser side of a test's coverage: its code reach paths, or, at
    * `functions` granularity, the files of its `piwi-browser-coverage` attachment
-   * with their blob ids, once read. Never rejects.
+   * with their blob ids, once read; with `coverage.css: 'rules'`, the style
+   * sheet files of its `piwi-css-coverage` attachment too. Never rejects.
    */
   browserCoverage(testCase, attachments) {
-    if (this.options.settings.browser === "off") return void 0;
-    const paths = testCase.codeReach;
-    const attachment = this.browserBlobs ? attachments?.find((a) => a.name === ATTACHMENT_NAMES.browserCoverage) : void 0;
-    if (this.browserBlobs) {
-      for (const known of attachments ?? []) {
-        if (known.name === ATTACHMENT_NAMES.browserFunctions) this.addKnownFunctions(known);
-      }
-    }
-    if (!this.browserBlobs || !attachment?.body) return paths;
+    const { browser, css } = this.options.settings;
+    if (browser === "off" && css !== "rules") return {};
+    const paths = browser === "off" ? void 0 : testCase.codeReach;
+    for (const known of attachments ?? []) {
+      if (browser === "functions" && known.name === ATTACHMENT_NAMES.browserFunctions) this.addKnownFunctions(known);
+      if (css === "rules" && known.name === ATTACHMENT_NAMES.cssRules) this.addKnownFunctions(known);
+    }
+    const scripts = browser === "functions" ? this.rangedFiles(attachments, ATTACHMENT_NAMES.browserCoverage) : [];
+    const sheets = css === "rules" ? this.rangedFiles(attachments, ATTACHMENT_NAMES.cssCoverage) : [];
+    const blobs = this.browserBlobs;
+    if (!blobs || scripts.length === 0 && sheets.length === 0) return { files: paths };
+    const withBlobs = (files) => blobs.withBlobs(files).catch(() => files);
+    return Promise.all([
+      scripts.length > 0 ? withBlobs(scripts) : Promise.resolve(null),
+      sheets.length > 0 ? withBlobs(sheets) : Promise.resolve([])
+    ]).then(([files, rules]) => ({ files: files ?? paths, css: rules }));
+  }
+  /** The browser files of a test's attachment holding line ranges, added to the run's. */
+  rangedFiles(attachments, name) {
+    const attachment = attachments?.find((a) => a.name === name);
+    if (!attachment?.body) return [];
     let files = [];
     try {
       files = sanitizeCoverage(JSON.parse(attachment.body.toString("utf8")))?.files ?? [];
     } catch {
-      return paths;
+      return [];
     }
     const browser = files.filter((file) => file.runtime === "browser");
-    if (browser.length === 0) return paths;
     for (const file of browser) addRanges(this.browserRan, file.path, file.functions ?? []);
-    return this.browserBlobs.withBlobs(browser).catch(() => browser);
+    return browser;
   }
   /** Add the functions of a `piwi-browser-functions` attachment, one of a test's, to the run's. */
   addKnownFunctions(attachment) {
@@ -10803,11 +11132,11 @@ var CoverageCollection = class {
     const requests = attachment?.body ? parseServerCoverageRequests(attachment.body) : null;
     if (!this.collector || !requests) {
       if (!(browser instanceof Promise)) {
-        this.assign(testCase, composeTestCoverage(null, browser, this.options.settings));
+        this.assign(testCase, composeTestCoverage(null, browser.files, this.options.settings, browser.css));
         return null;
       }
       const ready = browser.then(
-        (files) => this.assign(testCase, composeTestCoverage(null, files, this.options.settings))
+        (side) => this.assign(testCase, composeTestCoverage(null, side.files, this.options.settings, side.css))
       );
       this.browserPending.add(ready);
       return ready.finally(() => this.browserPending.delete(ready));
@@ -10821,8 +11150,8 @@ var CoverageCollection = class {
         settled = true;
         clearTimeout(timer);
         this.pending.delete(entry);
-        void Promise.resolve(browser).then((files) => {
-          this.assign(testCase, composeTestCoverage(server, files, this.options.settings));
+        void Promise.resolve(browser).then((side) => {
+          this.assign(testCase, composeTestCoverage(server, side.files, this.options.settings, side.css));
           resolve11();
         });
       };
@@ -10959,6 +11288,8 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
     this.resourcesFile = null;
     /** Samples the run's processes and the machine from `onBegin` to `onEnd`. */
     this.sampler = null;
+    /** Posts what the sampler and the censuses add while someone has the run open on the dashboard. */
+    this.liveResources = null;
     /** Bytes of the files the tests attached, by kind. */
     this.artifactBytes = emptyArtifacts();
     /** The run's resource report for the dashboard, built in `onEnd`. */
@@ -11117,8 +11448,9 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
       );
     }
     if (coverage.server !== "off") this.lastTestWatch = new LastTestWatch(this.plannedTests.length);
-    if (coverage.browser !== "off" || coverage.server !== "off") {
+    if (coverage.browser !== "off" || coverage.server !== "off" || coverage.css === "rules") {
       if (coverage.browser !== "off") process.env[PIWI_ENV_KEYS.coverageBrowser] = coverage.browser;
+      if (coverage.css === "rules") process.env[PIWI_ENV_KEYS.coverageCss] = coverage.css;
       if (coverage.server !== "off") {
         process.env[PIWI_ENV_KEYS.coverageServer] = coverage.server;
       }
@@ -11143,6 +11475,22 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
       // the dashboard shows the real total from the first render.
       this.plannedTests.length
     );
+    if (this.streamManager && this.options.captureResources !== false) {
+      const live = new LiveResources(
+        this.streamManager,
+        this.httpClient,
+        {
+          sampler: this.sampler,
+          censuses: () => this.resourceCensuses,
+          shardIndex: this.shardInfo?.current ?? null,
+          runStartedAt: Date.now()
+        },
+        this.logger
+      );
+      this.streamManager.onWatched = () => void live.tick();
+      live.start();
+      this.liveResources = live;
+    }
   }
   /**
    * Settle each planned test's external ID before any test runs, name the IDs two tests share, and record them on
@@ -11445,6 +11793,8 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
    */
   async reportResources() {
     if (this.options.captureResources === false) return;
+    await this.liveResources?.stop();
+    this.liveResources = null;
     const profile = this.sampler ? await this.sampler.stop() : null;
     const samples = this.sampler?.timedSeries() ?? null;
     this.sampler = null;
@@ -13011,7 +13361,7 @@ var TEST_DATA_ATTRS = /* @__PURE__ */ new Set(["data-test", "data-test-id", "dat
 function generateAlternatives(attrs, options = {}) {
   const alts = [];
   const seen = /* @__PURE__ */ new Set();
-  const add = (loc) => {
+  const add2 = (loc) => {
     if (!seen.has(loc.locator)) {
       seen.add(loc.locator);
       alts.push(loc);
@@ -13028,7 +13378,7 @@ function generateAlternatives(attrs, options = {}) {
   const selectable = (name2) => name2.toLowerCase() !== testIdAttribute.toLowerCase();
   const testId = attr(attrs, testIdAttribute);
   if (testId && isUnique(counts?.testId)) {
-    add({
+    add2({
       locator: `getByTestId(${quoteJsString(testId)})`,
       method: "getByTestId",
       args: { testId },
@@ -13039,7 +13389,7 @@ function generateAlternatives(attrs, options = {}) {
   const levelPart = level != null ? `, level: ${level}` : "";
   const withLevel = (base) => level != null ? { ...base, level } : base;
   if (role && accessibleName) {
-    add({
+    add2({
       locator: `getByRole(${quoteJsString(role)}, { name: ${quoteJsString(accessibleName)}${levelPart} })`,
       method: "getByRole",
       args: withLevel({ role, name: accessibleName }),
@@ -13048,7 +13398,7 @@ function generateAlternatives(attrs, options = {}) {
   }
   const ariaLabel = attr(attrs, "aria-label");
   if (role && ariaLabel && ariaLabel !== accessibleName) {
-    add({
+    add2({
       locator: `getByRole(${quoteJsString(role)}, { name: ${quoteJsString(ariaLabel)}${levelPart} })`,
       method: "getByRole",
       args: withLevel({ role, name: ariaLabel }),
@@ -13059,7 +13409,7 @@ function generateAlternatives(attrs, options = {}) {
     const label = attr(attrs, "aria-label");
     const labelBacked = attrs.hasLabel === void 0 ? true : attrs.hasLabel === true || label === accessibleName;
     if (labelBacked) {
-      add({
+      add2({
         locator: `getByLabel(${quoteJsString(accessibleName)})`,
         method: "getByLabel",
         args: { label: accessibleName },
@@ -13069,7 +13419,7 @@ function generateAlternatives(attrs, options = {}) {
   }
   const placeholder = attr(attrs, "placeholder");
   if (placeholder) {
-    add({
+    add2({
       locator: `getByPlaceholder(${quoteJsString(placeholder)})`,
       method: "getByPlaceholder",
       args: { placeholder },
@@ -13077,7 +13427,7 @@ function generateAlternatives(attrs, options = {}) {
     });
   }
   if (text && text.length < 80) {
-    add({
+    add2({
       locator: `getByText(${quoteJsString(text)})`,
       method: "getByText",
       args: { text },
@@ -13087,7 +13437,7 @@ function generateAlternatives(attrs, options = {}) {
   const id = attr(attrs, "id");
   if (id && selectable("id") && !isAutoGenerated(id) && isUnique(counts?.id)) {
     const selector = isCssSafeId(id) ? `#${id}` : `[id="${escCssAttrValue(id)}"]`;
-    add({
+    add2({
       locator: `locator(${quoteJsString(selector)})`,
       method: "locator",
       args: { selector },
@@ -13097,7 +13447,7 @@ function generateAlternatives(attrs, options = {}) {
   const name = attr(attrs, "name");
   if (name && selectable("name") && isUnique(counts?.name)) {
     const selector = `[name="${escCssAttrValue(name)}"]`;
-    add({
+    add2({
       locator: `locator(${quoteJsString(selector)})`,
       method: "locator",
       args: { selector },
@@ -13106,7 +13456,7 @@ function generateAlternatives(attrs, options = {}) {
   }
   const alt = attr(attrs, "alt");
   if (alt) {
-    add({
+    add2({
       locator: `getByAltText(${quoteJsString(alt)})`,
       method: "getByAltText",
       args: { text: alt },
@@ -13115,7 +13465,7 @@ function generateAlternatives(attrs, options = {}) {
   }
   const title = attr(attrs, "title");
   if (title) {
-    add({
+    add2({
       locator: `getByTitle(${quoteJsString(title)})`,
       method: "getByTitle",
       args: { title },
@@ -13133,7 +13483,7 @@ function generateAlternatives(attrs, options = {}) {
       if (scopedCount(anc) !== 1) continue;
       if (!testIdAnchorDone && anc.testId && anc.testIdCount === 1) {
         testIdAnchorDone = true;
-        add({
+        add2({
           locator: `getByTestId(${quoteJsString(anc.testId)}).${leaf.expr}`,
           method: leaf.method,
           args: { ...leaf.args, anchorTestId: anc.testId },
@@ -13143,7 +13493,7 @@ function generateAlternatives(attrs, options = {}) {
       if (!idAnchorDone && anc.id && selectable("id") && !isAutoGenerated(anc.id) && anc.idCount === 1) {
         idAnchorDone = true;
         const anchorSelector = isCssSafeId(anc.id) ? `#${anc.id}` : `[id="${escCssAttrValue(anc.id)}"]`;
-        add({
+        add2({
           locator: `locator(${quoteJsString(anchorSelector)}).${leaf.expr}`,
           method: leaf.method,
           args: { ...leaf.args, anchorSelector },
@@ -13154,7 +13504,7 @@ function generateAlternatives(attrs, options = {}) {
         dataAnchorDone = true;
         const { name: name2, value } = anc.dataAttr;
         const anchorSelector = `[${name2}="${escCssAttrValue(value)}"]`;
-        add({
+        add2({
           locator: `locator(${quoteJsString(anchorSelector)}).${leaf.expr}`,
           method: leaf.method,
           args: { ...leaf.args, anchorSelector },
@@ -13164,7 +13514,7 @@ function generateAlternatives(attrs, options = {}) {
       const ancestorRole = anc.role || TAG_TO_ROLE[anc.tag] || null;
       if (!roleAnchorDone && ancestorRole && ancestorRole !== leaf.role && anc.roleCount === 1) {
         roleAnchorDone = true;
-        add({
+        add2({
           locator: `getByRole(${quoteJsString(ancestorRole)}).${leaf.expr}`,
           method: leaf.method,
           args: { ...leaf.args, anchorRole: ancestorRole },
@@ -13173,7 +13523,7 @@ function generateAlternatives(attrs, options = {}) {
       }
       if (!filterAnchorDone && ancestorRole && anc.filterText && anc.filterRoleCount === 1) {
         filterAnchorDone = true;
-        add({
+        add2({
           locator: `getByRole(${quoteJsString(ancestorRole)}).filter({ hasText: ${quoteJsString(anc.filterText)} }).${leaf.expr}`,
           method: leaf.method,
           args: { ...leaf.args, anchorRole: ancestorRole, anchorHasText: anc.filterText },
@@ -13192,7 +13542,7 @@ function generateAlternatives(attrs, options = {}) {
     );
     const pos = attrs.rolePosition;
     if (pos && pos.role === role && (pos.count === 1 || level != null && pos.levelCount === 1)) {
-      add({
+      add2({
         locator: `getByRole(${rolePart})`,
         method: "getByRole",
         args: leafArgs,
@@ -13211,7 +13561,7 @@ function generateAlternatives(attrs, options = {}) {
     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({
+      add2({
         locator: `locator(${quoteJsString(`.${cls}`)})`,
         method: "locator",
         args: { selector: `.${cls}` },
@@ -13268,7 +13618,7 @@ function generateAnchoredAlternatives(leaf, anchors, chainLeafCount) {
   const seen = /* @__PURE__ */ new Set();
   const rolePart = leaf.level != null ? `${quoteJsString(leaf.role)}, { level: ${leaf.level} }` : quoteJsString(leaf.role);
   const leafArgs = leaf.level != null ? { role: leaf.role, level: leaf.level } : { role: leaf.role };
-  const add = (l) => {
+  const add2 = (l) => {
     if (!seen.has(l.locator)) {
       seen.add(l.locator);
       out.push(l);
@@ -13278,7 +13628,7 @@ function generateAnchoredAlternatives(leaf, anchors, chainLeafCount) {
     if (anchor.scopedLeafCount !== 1) continue;
     const seg = anchorSegment(anchor);
     if (!seg) continue;
-    add({
+    add2({
       locator: `${seg.code}.getByRole(${rolePart})`,
       method: "getByRole",
       args: { ...leafArgs, ...seg.flatArgs },
@@ -13291,7 +13641,7 @@ function generateAnchoredAlternatives(leaf, anchors, chainLeafCount) {
     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({
+      add2({
         locator: `${segments.map((s) => s.code).join(".")}.getByRole(${rolePart})`,
         method: "getByRole",
         // Flat args describe the innermost anchor (what the healing fingerprint
@@ -14488,7 +14838,7 @@ async function pauseHere(page, point, probe, onPick, onRecord, ended) {
 
 // src/internal/capture/record-handoff.ts
 var fs26 = __toESM(require("fs"));
-var net = __toESM(require("net"));
+var net2 = __toESM(require("net"));
 var path29 = __toESM(require("path"));
 
 // ../core/src/ide-recorder.ts
@@ -14577,7 +14927,7 @@ async function recordFromHere(options) {
   const use = testInfo.project?.use ?? {};
   const context = page.context();
   return new Promise((resolve11) => {
-    const socket = net.connect(channel.path);
+    const socket = net2.connect(channel.path);
     socket.setEncoding("utf8");
     const answers = /* @__PURE__ */ new Map();
     let calls = 0;
@@ -14726,6 +15076,267 @@ async function recordFromHere(options) {
   });
 }
 
+// src/internal/capture/css-coverage.ts
+var crypto7 = __toESM(require("crypto"));
+var fs27 = __toESM(require("fs"));
+
+// ../core/src/css-rules.ts
+var GROUPING = /* @__PURE__ */ new Set(["media", "supports", "layer", "container", "scope", "starting-style", "document"]);
+function parseCssRules(text) {
+  const rules = [];
+  const open = [];
+  let preludeStart = -1;
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (c === "/" && text[i + 1] === "*") {
+      const end = text.indexOf("*/", i + 2);
+      i = end < 0 ? text.length : end + 1;
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      if (preludeStart < 0) preludeStart = i;
+      for (i++; i < text.length && text[i] !== c && text[i] !== "\n"; i++) if (text[i] === "\\") i++;
+      continue;
+    }
+    if (c === "\\") {
+      if (preludeStart < 0) preludeStart = i;
+      i++;
+      continue;
+    }
+    if ((c === "u" || c === "U") && /^url\(/i.test(text.slice(i, i + 4)) && !/[\w-]/.test(text[i - 1] ?? "")) {
+      let j = i + 4;
+      while (j < text.length && /\s/.test(text[j])) j++;
+      if (text[j] !== '"' && text[j] !== "'") {
+        if (preludeStart < 0) preludeStart = i;
+        for (; j < text.length && text[j] !== ")"; j++) if (text[j] === "\\") j++;
+        i = j;
+        continue;
+      }
+    }
+    if (text.startsWith("<!--", i) || text.startsWith("-->", i)) {
+      i += text.startsWith("<!--", i) ? 3 : 2;
+      continue;
+    }
+    if (c === "{") {
+      const start = preludeStart < 0 ? i : preludeStart;
+      const atRule = /^@([\w-]+)/.exec(text.slice(start, i));
+      const parent = open[open.length - 1];
+      const kind = atRule ? GROUPING.has(atRule[1].toLowerCase()) ? "group" : "other" : parent?.kind === "other" ? "other" : "style";
+      open.push({ kind, start, open: i });
+      preludeStart = -1;
+      continue;
+    }
+    if (c === "}") {
+      const block = open.pop();
+      if (block && block.kind !== "other")
+        rules.push({ kind: block.kind, start: block.start, open: block.open, end: i + 1 });
+      preludeStart = -1;
+      continue;
+    }
+    if (c === ";") {
+      preludeStart = -1;
+      continue;
+    }
+    if (preludeStart < 0 && !/\s/.test(c)) preludeStart = i;
+  }
+  for (const block of open) {
+    if (block.kind !== "other")
+      rules.push({ kind: block.kind, start: block.start, open: block.open, end: text.length });
+  }
+  return rules.sort((a, b) => a.start - b.start);
+}
+function usedCssRules(rules, used) {
+  const styleAt = /* @__PURE__ */ new Map();
+  const groups = [];
+  for (const rule of rules) {
+    if (rule.kind === "style") styleAt.set(rule.start, rule);
+    else groups.push(rule);
+  }
+  const out = /* @__PURE__ */ new Map();
+  for (const range of used) {
+    const style = styleAt.get(range.startOffset);
+    if (style) {
+      out.set(`${style.start}`, [style.start, style.end]);
+      continue;
+    }
+    const group = groups.find((rule) => rule.start <= range.startOffset && range.startOffset <= rule.open);
+    if (group) out.set(`${group.start}`, [group.start, group.start + 1]);
+  }
+  return [...out.values()].sort((a, b) => a[0] - b[0]);
+}
+function allCssRules(rules) {
+  return rules.map((rule) => rule.kind === "style" ? [rule.start, rule.end] : [rule.start, rule.start + 1]);
+}
+function cssRuleLines(text, offsets, options = {}) {
+  const starts = lineStarts(text);
+  const lineOffset = options.lineOffset ?? 0;
+  const out = /* @__PURE__ */ new Map();
+  const add2 = (source, range) => {
+    const ranges = out.get(source);
+    if (ranges) ranges.push(range);
+    else out.set(source, [range]);
+  };
+  for (const [startOffset, endOffset] of offsets) {
+    const start = offsetToPosition(starts, startOffset);
+    const end = offsetToPosition(starts, Math.max(startOffset, endOffset - 1));
+    if (!options.lookup) {
+      add2(-1, [start.line + lineOffset + 1, end.line + lineOffset + 1]);
+      continue;
+    }
+    const first = options.lookup.originalAt(start.line, start.column);
+    if (!first) continue;
+    const last = options.lookup.originalAt(end.line, end.column);
+    const lastLine = last && last.source === first.source && last.line >= first.line ? last.line : first.line;
+    add2(first.source, [first.line + 1, lastLine + 1]);
+  }
+  return out;
+}
+
+// src/internal/capture/css-coverage.ts
+var STYLE_SOURCES = /\.(?:css|scss|sass|less|styl|stylus|pcss|postcss|vue|svelte|astro|html?)$/i;
+var BUILD_DIRS2 = /(?:^|\/)(?:dist|build|out|\.output|\.next|\.nuxt|\.svelte-kit)\//;
+var resolutions = /* @__PURE__ */ new Map();
+var MAX_CACHED_SHEETS = 2e3;
+function fileForStyleUrl(url, roots) {
+  let pathname;
+  try {
+    const parsed2 = new URL(url);
+    if (parsed2.protocol !== "http:" && parsed2.protocol !== "https:" && parsed2.protocol !== "file:") return null;
+    pathname = parsed2.pathname;
+  } catch {
+    return null;
+  }
+  return sourceFile(decodeURIComponent(pathname), roots);
+}
+function sourceFile(source, roots) {
+  const bare = source.replace(/[?#].*$/, "");
+  if (!STYLE_SOURCES.test(bare) || /(?:^|\/)node_modules\//.test(bare)) return null;
+  const file = resolveSourcePath(bare, roots);
+  if (!file || BUILD_DIRS2.test(file.replace(/\\/g, "/")) || /(?:^|[\\/])node_modules[\\/]/.test(file)) return null;
+  return file;
+}
+function styleBlockLine(file, index) {
+  let text;
+  try {
+    text = fs27.readFileSync(file, "utf-8");
+  } catch {
+    return 0;
+  }
+  const blocks = [...text.matchAll(/^<style\b[^>]*>/gim)];
+  const block = blocks[index];
+  if (!block) return 0;
+  return text.slice(0, block.index + block[0].length).split("\n").length - 1;
+}
+async function sheetMap(sheet, text, fetchMap) {
+  const ref = sourceMappingUrl(text) ?? sheet.sourceMapURL ?? null;
+  if (!ref) return null;
+  let raw;
+  if (ref.startsWith("data:")) raw = decodeDataUrl(ref);
+  else {
+    try {
+      raw = await fetchMap(new URL(ref, sheet.sourceURL).href);
+    } catch {
+      raw = null;
+    }
+  }
+  if (!raw) return null;
+  try {
+    return decodeSourceMap(JSON.parse(raw));
+  } catch {
+    return null;
+  }
+}
+function sameLines(text, rules, file, lineOffset) {
+  let source;
+  try {
+    source = fs27.readFileSync(file, "utf-8");
+  } catch {
+    return false;
+  }
+  const fileLines = source.split(/\r?\n/);
+  const sheetLineStarts = [0];
+  for (let i = 0; i < text.length; i++) if (text[i] === "\n") sheetLineStarts.push(i + 1);
+  let low = 0;
+  for (const rule of rules) {
+    while (low + 1 < sheetLineStarts.length && sheetLineStarts[low + 1] <= rule.start) low++;
+    const head = text.slice(rule.start, rule.open).split("\n")[0].trim();
+    if (head && !(fileLines[low + lineOffset] ?? "").includes(head)) return false;
+  }
+  return true;
+}
+async function resolveSheet(sheet, text, dirs, fetchMap) {
+  const lookup = await sheetMap(sheet, text, fetchMap);
+  const rules = parseCssRules(text);
+  if (lookup) {
+    const sources = lookup.sources.map((source) => {
+      const direct = sourceFile(source, dirs);
+      if (direct) return direct;
+      try {
+        return /^[a-z][\w+.-]*:/i.test(source) ? null : fileForStyleUrl(new URL(source, sheet.sourceURL).href, dirs);
+      } catch {
+        return null;
+      }
+    });
+    return { rules, lookup, file: null, lineOffset: 0, sources, exact: true };
+  }
+  if (sheet.devId) {
+    const file2 = sourceFile(sheet.devId, dirs);
+    if (!file2) return null;
+    const index = /[?&]index=(\d+)/.exec(sheet.devId);
+    const lineOffset2 = /\.(?:vue|svelte|astro)$/i.test(file2) && index ? styleBlockLine(file2, Number(index[1])) : 0;
+    return { rules, lookup: null, file: file2, lineOffset: lineOffset2, sources: [], exact: sameLines(text, rules, file2, lineOffset2) };
+  }
+  const file = fileForStyleUrl(sheet.sourceURL, dirs);
+  if (!file) return null;
+  const lineOffset = sheet.isInline ? sheet.startLine : 0;
+  return { rules, lookup: null, file, lineOffset, sources: [], exact: sameLines(text, rules, file, lineOffset) };
+}
+function cachedResolution(sheet, text, dirs, fetchMap) {
+  const version = crypto7.createHash("sha1").update(text).digest("hex");
+  const key = [sheet.devId ?? sheet.sourceURL, sheet.isInline ? sheet.startLine : "", dirs.join("\0"), version].join(
+    " "
+  );
+  let pending = resolutions.get(key);
+  if (!pending) {
+    pending = resolveSheet(sheet, text, dirs, fetchMap).catch(() => null);
+    resolutions.set(key, pending);
+    if (resolutions.size > MAX_CACHED_SHEETS) resolutions.delete(resolutions.keys().next().value);
+  }
+  return pending;
+}
+function add(into, file, ranges, repoRoot, fileLevel = false) {
+  if (ranges.length === 0 && !fileLevel) return;
+  const key = relativeToRepo(file, repoRoot);
+  into.set(key, [...into.get(key) ?? [], ...ranges]);
+}
+async function resolveCssCoverage(sheets, roots, fetchMap) {
+  const reached = /* @__PURE__ */ new Map();
+  const known = /* @__PURE__ */ new Map();
+  for (const sheet of sheets) {
+    if (sheet.text === void 0) continue;
+    const dirs = scriptRoots(roots, sheet.sourceURL, sheet.pageUrl);
+    const resolution = await cachedResolution(sheet, sheet.text, dirs, fetchMap);
+    if (!resolution) continue;
+    const used = usedCssRules(resolution.rules, [...sheet.used.values()]);
+    if (!resolution.exact) {
+      if (resolution.file && used.length > 0) add(reached, resolution.file, [], roots.repoRoot, true);
+      continue;
+    }
+    const options = { lookup: resolution.lookup, lineOffset: resolution.lineOffset };
+    const fileOf2 = (source) => source === -1 ? resolution.file : resolution.sources[source] ?? null;
+    const matched = cssRuleLines(sheet.text, used, options);
+    for (const [source, ranges] of matched) {
+      const file = fileOf2(source);
+      if (file) add(reached, file, ranges, roots.repoRoot);
+    }
+    for (const [source, ranges] of cssRuleLines(sheet.text, allCssRules(resolution.rules), options)) {
+      const file = fileOf2(source);
+      if (file) add(known, file, ranges, roots.repoRoot);
+    }
+  }
+  return { reached, known };
+}
+
 // src/internal/capture/page-interaction.ts
 function readPageInteraction() {
   const doc = globalThis.document;
@@ -15029,16 +15640,19 @@ function createSink() {
     onReleasedRequestsEnded: null,
     releasedQuietSince: 0,
     locatorPages: new LocatorPageLog(),
-    codeReach: { sessions: /* @__PURE__ */ new Map(), files: /* @__PURE__ */ new Map(), known: /* @__PURE__ */ new Map() },
+    codeReach: { sessions: /* @__PURE__ */ new Map(), files: /* @__PURE__ */ new Map(), known: /* @__PURE__ */ new Map(), cssFiles: /* @__PURE__ */ new Map(), cssKnown: /* @__PURE__ */ new Map() },
     serverCoverage: /* @__PURE__ */ new Map(),
     baseURL: null
   };
 }
 var MAX_CODE_REACH_PAGES = 16;
 var CODE_REACH_START_WAIT_MS = 2e3;
+function pageCoverageInWorker() {
+  return browserCoverageInWorker() || cssCoverageInWorker();
+}
 function maybeStartCodeReach(page, alreadyOpen = false) {
   const sink = currentSink;
-  if (!sink || !browserCoverageInWorker() || isPageClosed(page)) return Promise.resolve(false);
+  if (!sink || !pageCoverageInWorker() || isPageClosed(page)) return Promise.resolve(false);
   const known = sink.codeReach.sessions.get(page);
   if (known) return known.started;
   if (alreadyOpen) {
@@ -15051,7 +15665,7 @@ function maybeStartCodeReach(page, alreadyOpen = false) {
   return started;
 }
 async function startCodeReachOnOpenPages() {
-  if (!browserCoverageInWorker() || OPEN_PAGES.size === 0) return;
+  if (!pageCoverageInWorker() || OPEN_PAGES.size === 0) return;
   const started = Promise.all([...OPEN_PAGES].map((page) => maybeStartCodeReach(page, true)));
   await Promise.race([started, new Promise((resolve11) => setTimeout(resolve11, CODE_REACH_START_WAIT_MS).unref())]);
 }
@@ -15094,22 +15708,28 @@ async function stopSinkCodeReach(sink, closing) {
 async function stopPageCodeReach(sink, page, session, roots) {
   try {
     if (!await session.started || isPageClosed(page)) return;
-    const entries = await stopCodeReach(page);
-    if (!entries) return;
-    const { reached, known } = await resolveCodeReachFunctions(entries, roots, pageMapFetcher(page), page.url(), {
+    const { scripts, sheets } = await stopPageCoverage(page);
+    const fetchMap = pageMapFetcher(page);
+    const append = (into, from) => {
+      for (const [file, ranges] of from) into.set(file, [...into.get(file) ?? [], ...ranges]);
+    };
+    if (sheets.length > 0) {
+      const rules = await resolveCssCoverage(sheets, roots, fetchMap);
+      append(sink.codeReach.cssFiles, rules.reached);
+      append(sink.codeReach.cssKnown, rules.known);
+    }
+    if (!scripts) return;
+    const { reached, known } = await resolveCodeReachFunctions(scripts, roots, fetchMap, page.url(), {
       known: browserFunctionsInWorker()
     });
-    for (const [file, functions] of reached) {
-      sink.codeReach.files.set(file, [...sink.codeReach.files.get(file) ?? [], ...functions]);
-    }
-    for (const [file, functions] of known) {
-      sink.codeReach.known.set(file, [...sink.codeReach.known.get(file) ?? [], ...functions]);
-    }
+    append(sink.codeReach.files, reached);
+    append(sink.codeReach.known, known);
   } catch {
   }
 }
 var currentSink = null;
 var KNOWN_FUNCTIONS_SENT = /* @__PURE__ */ new Map();
+var KNOWN_CSS_RULES_SENT = /* @__PURE__ */ new Map();
 var PENDING_PROBES = /* @__PURE__ */ new Set();
 async function drainPendingProbes(capMs) {
   if (PENDING_PROBES.size === 0) return;
@@ -16265,6 +16885,21 @@ async function flushSink(sink, testInfo) {
       body: Buffer.from(JSON.stringify(part))
     });
   }
+  if (cssCoverageInWorker()) {
+    const rules = sink.codeReach.cssFiles.size > 0 ? browserFunctionCoverage(sink.codeReach.cssFiles) : null;
+    if (rules) {
+      await testInfo.attach(ATTACHMENT_NAMES.cssCoverage, {
+        contentType: "application/json",
+        body: Buffer.from(JSON.stringify(rules))
+      });
+    }
+    for (const part of newKnownFunctions(sink.codeReach.cssKnown, KNOWN_CSS_RULES_SENT)) {
+      await testInfo.attach(ATTACHMENT_NAMES.cssRules, {
+        contentType: "application/json",
+        body: Buffer.from(JSON.stringify(part))
+      });
+    }
+  }
   if (sink.serverCoverage.size > 0) {
     const requests = {};
     for (const [origin, ids] of sink.serverCoverage) requests[origin] = [...ids];
@@ -16546,12 +17181,12 @@ function extendPiwiFixtures(test) {
 }
 
 // src/internal/ai/ai-fixtures.ts
-var fs28 = __toESM(require("fs"));
+var fs29 = __toESM(require("fs"));
 var path33 = __toESM(require("path"));
 var import_test = require("@playwright/test");
 
 // src/internal/ai/artifact.ts
-var fs27 = __toESM(require("fs"));
+var fs28 = __toESM(require("fs"));
 var path31 = __toESM(require("path"));
 var ARTIFACT_VERSION = 1;
 var LOCATOR_METHOD_SET2 = new Set(LOCATOR_METHODS);
@@ -16645,7 +17280,7 @@ function parseEntry(text) {
 function readEntry(file) {
   let text;
   try {
-    text = fs27.readFileSync(file, "utf8");
+    text = fs28.readFileSync(file, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") return null;
     throw error;
@@ -16655,28 +17290,28 @@ function readEntry(file) {
 function writeEntry(file, entry) {
   const canonical = serializeEntry(entry);
   return withEntryLock(file, () => {
-    if (fs27.existsSync(file) && fs27.readFileSync(file, "utf8") === canonical) return { written: false };
-    fs27.mkdirSync(path31.dirname(file), { recursive: true });
+    if (fs28.existsSync(file) && fs28.readFileSync(file, "utf8") === canonical) return { written: false };
+    fs28.mkdirSync(path31.dirname(file), { recursive: true });
     const tmp = `${file}.${process.pid}.tmp`;
-    fs27.writeFileSync(tmp, canonical);
-    fs27.renameSync(tmp, file);
+    fs28.writeFileSync(tmp, canonical);
+    fs28.renameSync(tmp, file);
     return { written: true };
   });
 }
 function withEntryLock(file, fn) {
   const lock = `${file}.lock`;
-  fs27.mkdirSync(path31.dirname(file), { recursive: true });
+  fs28.mkdirSync(path31.dirname(file), { recursive: true });
   const deadline = Date.now() + 5e3;
   for (; ; ) {
     try {
-      const fd = fs27.openSync(lock, "wx");
-      fs27.closeSync(fd);
+      const fd = fs28.openSync(lock, "wx");
+      fs28.closeSync(fd);
       break;
     } catch (error) {
       if (error.code !== "EEXIST") throw error;
       if (Date.now() > deadline) {
         try {
-          fs27.unlinkSync(lock);
+          fs28.unlinkSync(lock);
         } catch {
         }
       }
@@ -16686,14 +17321,14 @@ function withEntryLock(file, fn) {
     return fn();
   } finally {
     try {
-      fs27.unlinkSync(lock);
+      fs28.unlinkSync(lock);
     } catch {
     }
   }
 }
 
 // src/internal/ai/keys.ts
-var crypto7 = __toESM(require("crypto"));
+var crypto8 = __toESM(require("crypto"));
 var path32 = __toESM(require("path"));
 var DEFAULT_AI_DIR = "__piwi__";
 function normalizeTemplate(template) {
@@ -16701,7 +17336,7 @@ function normalizeTemplate(template) {
 }
 function hashTemplate(normalized, ordinal = 0) {
   const input = ordinal > 0 ? `${normalized}#${ordinal}` : normalized;
-  return crypto7.createHash("sha256").update(input).digest("hex").slice(0, 8);
+  return crypto8.createHash("sha256").update(input).digest("hex").slice(0, 8);
 }
 function slug(text, maxLength = 40) {
   const base = text.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
@@ -17320,15 +17955,15 @@ function relativeToCwd(file) {
   return path33.relative(process.cwd(), file).split(path33.sep).join("/");
 }
 function recordIntents(intents, entry) {
-  const add = (locator, kind) => {
+  const add2 = (locator, kind) => {
     intents.set(`${entry.template}\0${locator}`, { template: entry.template, locator, kind });
   };
   if (entry.kind === "locator") {
-    add(locatorSource2(entry.locator), "locator");
+    add2(locatorSource2(entry.locator), "locator");
     return;
   }
-  for (const step of entry.steps) add(locatorSource2(step.locator), "run");
-  if (entry.postcondition.locator) add(locatorSource2(entry.postcondition.locator), "run");
+  for (const step of entry.steps) add2(locatorSource2(step.locator), "run");
+  if (entry.postcondition.locator) add2(locatorSource2(entry.postcondition.locator), "run");
 }
 function missMessage(template, testTitle, relPath) {
   return [
@@ -17344,7 +17979,7 @@ function createAiApi(page, testInfo, config, used, intents) {
   const readSource = () => {
     if (source === null) {
       try {
-        source = fs28.readFileSync(testInfo.file, "utf8");
+        source = fs29.readFileSync(testInfo.file, "utf8");
       } catch {
         source = "";
       }