supercov 0.0.24 → 0.0.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supercov",
-  "version": "0.0.24",
+  "version": "0.0.25",
   "description": "Zero-edit, runner-aware coverage completeness for JavaScript test suites",
   "license": "MIT",
   "repository": {
@@ -68,12 +68,12 @@
     "prepublishOnly": "npm run release:check"
   },
   "optionalDependencies": {
-    "@supercov/cli-darwin-arm64": "0.0.24",
-    "@supercov/cli-darwin-x64": "0.0.24",
-    "@supercov/cli-linux-arm64-gnu": "0.0.24",
-    "@supercov/cli-linux-arm64-musl": "0.0.24",
-    "@supercov/cli-linux-x64-gnu": "0.0.24",
-    "@supercov/cli-linux-x64-musl": "0.0.24"
+    "@supercov/cli-darwin-arm64": "0.0.25",
+    "@supercov/cli-darwin-x64": "0.0.25",
+    "@supercov/cli-linux-arm64-gnu": "0.0.25",
+    "@supercov/cli-linux-arm64-musl": "0.0.25",
+    "@supercov/cli-linux-x64-gnu": "0.0.25",
+    "@supercov/cli-linux-x64-musl": "0.0.25"
   },
   "peerDependencies": {
     "@playwright/test": ">=1.55.0",

package/runtime/javascript/playwright.js

@@ -37,6 +37,50 @@ const evidenceWriterIdentity = () => (process.env.SUPERCOV_EXECUTION_LOG_SHARD ?
     .replace(/[^A-Za-z0-9_-]/g, "_");
 const GENERATED_RUN_ID = "__SUPERCOV_RUN_ID__";
 const PHASE_STORAGE_KEY = "__supercov_phase";
+// Wall-clock accounting for every browser round-trip this shim performs,
+// enabled by SUPERCOV_PHASE_TIMING=1. One summary line per test on stderr;
+// a single boolean check when disabled.
+const generatedPhaseTiming = "__SUPERCOV_PHASE_TIMING__";
+const PHASE_TIMING = process.env["SUPERCOV_PHASE_TIMING"] === "1" || generatedPhaseTiming === "1";
+const timingBuckets = PHASE_TIMING ? new Map() : undefined;
+function timingCount(bucket, milliseconds = 0) {
+    if (!timingBuckets)
+        return;
+    const entry = timingBuckets.get(bucket) ?? { calls: 0, ms: 0 };
+    entry.calls += 1;
+    entry.ms += milliseconds;
+    timingBuckets.set(bucket, entry);
+}
+async function timed(bucket, work) {
+    if (!timingBuckets)
+        return work();
+    const started = performance.now();
+    try {
+        return await work();
+    }
+    finally {
+        timingCount(bucket, performance.now() - started);
+    }
+}
+function timingReport(label) {
+    if (!timingBuckets)
+        return;
+    const summary = Object.fromEntries([...timingBuckets.entries()].map(([bucket, entry]) => [bucket, { calls: entry.calls, ms: Math.round(entry.ms) }]));
+    const line = JSON.stringify({ label, summary });
+    console.error(`[supercov-timing] ${line}`);
+    // Pooled runners swallow worker stderr for passing tests, so the report
+    // also lands as a file beside the evidence, which rides the workspace
+    // mount back to the host.
+    try {
+        const resolved = resolve(process.cwd(), ".supercov/phase-timing");
+        mkdirSync(resolved, { recursive: true });
+        appendJsonLineSync(resolve(resolved, `phase-timing-${process.pid}.jsonl`), `${line}\n`);
+    }
+    catch {
+        // Timing must never affect the run.
+    }
+    timingBuckets.clear();
+}
 const ACTION_METHODS = new Set([
     "blur",
     "check",
@@ -125,6 +169,7 @@ class CoveragePhaseController {
     async collectRuntimeSnapshots() {
         if (this.runtimeSnapshots)
             return this.runtimeSnapshots;
+        timingCount("collectRuntimeSnapshots.cold");
         const snapshots = [];
         for (const page of this.allPages()) {
             for (const frame of page.frames()) {
@@ -160,6 +205,7 @@ class CoveragePhaseController {
     async registerPage(page) {
         if (this.pages.has(page))
             return;
+        timingCount("registerPage");
         this.pages.add(page);
         await this.registerContext(page.context());
         const cdp = await page.context().newCDPSession(page).catch(() => undefined);
@@ -251,19 +297,21 @@ class CoveragePhaseController {
             .catch(() => undefined);
     }
     async beginAction(operation) {
+        timingCount("beginAction");
         const phase = this.createPhase("action", operation);
         this.lastActionId = phase.id;
         this.activePhaseId = phase.id;
-        await this.activateInBrowser(phase.id);
+        await timed("action.activateInBrowser", () => this.activateInBrowser(phase.id));
         return phase;
     }
     beginAssertion(operation, source = callerSource()) {
+        timingCount("beginAssertion");
         const phase = this.createPhase("assertion", operation, this.lastActionId, source);
         this.activePhaseId = phase.id;
         // Playwright queues browser protocol commands in order. Starting this
         // evaluation before an async locator assertion is sufficient to tag its
         // polling work without turning synchronous expect matchers into promises.
-        void this.activateInBrowser(phase.id);
+        void timed("assertion.activateInBrowser", () => this.activateInBrowser(phase.id));
         return phase;
     }
     requestPhaseId() {
@@ -409,8 +457,8 @@ class CoveragePhaseController {
         return scoped;
     }
     async activateInBrowser(phaseId) {
-        await Promise.all([...this.contexts].map((context) => this.updateContextHeaders(context, phaseId)));
-        await Promise.all([...this.pages].flatMap((page) => page.frames()).map((frame) => frame
+        await timed("activate.contextHeaders", () => Promise.all([...this.contexts].map((context) => this.updateContextHeaders(context, phaseId))));
+        await timed("activate.frameEvaluate", () => Promise.all([...this.pages].flatMap((page) => page.frames()).map((frame) => frame
             .evaluate(({ id, storageKey, scopeCookie, scopeValue, phaseCookie }) => {
             globalThis.__SUPERCOV_PHASE_ID__ = id;
             const coverageGlobal = globalThis;
@@ -430,15 +478,15 @@ class CoveragePhaseController {
             scopeValue: encodeCoverageScope(this.scope),
             phaseCookie: COVERAGE_PHASE_COOKIE,
         })
-            .catch(() => undefined)));
-        await Promise.all([...this.workers].map((worker) => worker
+            .catch(() => undefined))));
+        await timed("activate.workerEvaluate", () => Promise.all([...this.workers].map((worker) => worker
             .evaluate((id) => {
             const coverageGlobal = globalThis;
             coverageGlobal.__SUPERCOV_PHASE_ID__ = id;
             coverageGlobal.__SUPERCOV_ACTIVATE_PROBE_CONTEXT__?.(coverageGlobal.__SUPERCOV_MCDC_TEST_ID__ ?? "unscoped", id);
         }, phaseId)
-            .catch(() => undefined)));
-        await Promise.all([...this.pages].map((page) => this.activatePage(page, phaseId)));
+            .catch(() => undefined))));
+        await timed("activate.pageScript", () => Promise.all([...this.pages].map((page) => this.activatePage(page, phaseId))));
     }
     async updateContextHeaders(context, phaseId) {
         await context
@@ -877,7 +925,8 @@ const instrumentedTest = base.extend({
                     }
                 }
                 finally {
-                    await controller.dispose();
+                    await timed("controller.dispose", () => controller.dispose());
+                    timingReport(testInfo.title);
                     directRuntime()?.activateCoverageScope();
                     if (activeController === controller)
                         activeController = undefined;

package/runtime/javascript/runtime.js

@@ -157,7 +157,12 @@ function createState() {
     probeV2Clock: { epoch: Number.NaN, fast: false },
     probeV2ContextEpochs: /* @__PURE__ */ new Map(),
     probeV2NextEpoch: 1,
-    probeV2HookInstalled: false
+    probeV2HookInstalled: false,
+    pendingServerAppends: /* @__PURE__ */ new Map(),
+    createdEvidenceDirectories: /* @__PURE__ */ new Set(),
+    serverFlushScheduled: false,
+    serverExitHookInstalled: false,
+    serverTransportFailure: void 0
   };
   if (!isBrowser)
     return state2;
@@ -313,7 +318,9 @@ function resetCoverage(testId2) {
 runtimeGlobal.__SUPERCOV_MCDC_SNAPSHOT__ = decisionSnapshot;
 runtimeGlobal.__SUPERCOV_COVERAGE_SNAPSHOT__ = coverageSnapshot;
 runtimeGlobal.__SUPERCOV_RESET__ = resetCoverage;
-function persistBrowser() {
+var persistBrowserScheduled = false;
+var persistBrowserListenersInstalled = false;
+function persistBrowserNow() {
   if (!isBrowser)
     return;
   try {
@@ -321,6 +328,32 @@ function persistBrowser() {
   } catch (e) {
   }
 }
+function persistBrowser() {
+  if (!isBrowser)
+    return;
+  // Persistence exists so evidence survives navigation, not to mirror every
+  // event: serializing the whole snapshot per event is quadratic in a
+  // render burst. Coalesce to one write per macrotask and flush when the
+  // page is actually leaving.
+  if (!persistBrowserListenersInstalled) {
+    persistBrowserListenersInstalled = true;
+    try {
+      addEventListener("pagehide", persistBrowserNow);
+      addEventListener("visibilitychange", () => {
+        if (typeof document !== "undefined" && document.visibilityState === "hidden")
+          persistBrowserNow();
+      });
+    } catch (e) {
+    }
+  }
+  if (persistBrowserScheduled)
+    return;
+  persistBrowserScheduled = true;
+  setTimeout(() => {
+    persistBrowserScheduled = false;
+    persistBrowserNow();
+  }, 0);
+}
 function attemptKey(scope) {
   return `${scope.runId}\0${scope.workerId}\0${scope.attemptId}`;
 }
@@ -432,6 +465,66 @@ if (!isBrowser) {
     runtimeGlobal.__SUPERCOV_BUFFER_EXIT_INSTALLED__ = true;
   }
 }
+function serverTransportError(runId, cause) {
+  const detail = cause instanceof Error ? cause.message : String(cause);
+  const failure = new Error(`Supercov could not persist coverage evidence for run ${runId}: ${detail}`);
+  failure.code = "SUPERCOV_EVIDENCE_TRANSPORT_FAILED";
+  failure.cause = cause;
+  return failure;
+}
+function flushServerAppends() {
+  const pending = state.pendingServerAppends;
+  if (pending.size === 0)
+    return;
+  const fs = getFs();
+  for (const [path, entry] of pending) {
+    pending.delete(path);
+    try {
+      if (!fs)
+        throw new Error("node:fs is unavailable");
+      if (!state.createdEvidenceDirectories.has(entry.directory)) {
+        fs.mkdirSync(entry.directory, { recursive: true });
+        state.createdEvidenceDirectories.add(entry.directory);
+      }
+      fs.appendFileSync(path, entry.lines.join(""));
+    } catch (cause) {
+      const failure = serverTransportError(entry.runId, cause);
+      state.serverTransportFailure = failure;
+      throw failure;
+    }
+  }
+}
+function enqueueServerAppend(directory, path, line, runId) {
+  // Fail closed with the original context: after one transport failure the
+  // very next probe re-raises it synchronously.
+  if (state.serverTransportFailure)
+    throw state.serverTransportFailure;
+  const entry = state.pendingServerAppends.get(path);
+  if (entry) {
+    entry.lines.push(line);
+    if (entry.lines.length >= 2048)
+      flushServerAppends();
+  } else {
+    state.pendingServerAppends.set(path, { directory, runId, lines: [line] });
+  }
+  if (!state.serverExitHookInstalled && typeof process !== "undefined") {
+    state.serverExitHookInstalled = true;
+    try {
+      process.on("exit", flushServerAppends);
+    } catch (e) {
+    }
+  }
+  // One synchronous write per event-loop turn instead of one per probe: a
+  // request handler's burst of first-touch records becomes a single append
+  // that is still on disk before the process yields past this turn.
+  if (!state.serverFlushScheduled) {
+    state.serverFlushScheduled = true;
+    queueMicrotask(() => {
+      state.serverFlushScheduled = false;
+      flushServerAppends();
+    });
+  }
+}
 function appendServer(record) {
   var _a8, _b, _c, _d;
   if (state.runtimeSnapshots) {
@@ -487,16 +580,13 @@ function appendServer(record) {
       appendDurableBackgroundRecord(fs, runId, serialized);
       return;
     }
-    fs.mkdirSync(directory, { recursive: true });
-    fs.appendFileSync(path, JSON.stringify(serialized) + "\n");
+    enqueueServerAppend(directory, path, JSON.stringify(serialized) + "\n", runId);
     if (deduplicationKey)
       state.persistedServerRecords.add(deduplicationKey);
   } catch (cause) {
-    const detail = cause instanceof Error ? cause.message : String(cause);
-    const failure = new Error(`Supercov could not persist coverage evidence for run ${runId}: ${detail}`);
-    failure.code = "SUPERCOV_EVIDENCE_TRANSPORT_FAILED";
-    failure.cause = cause;
-    throw failure;
+    if (cause instanceof Error && cause.code === "SUPERCOV_EVIDENCE_TRANSPORT_FAILED")
+      throw cause;
+    throw serverTransportError(runId, cause);
   }
 }
 function environmentRequestContext() {