supercov 4.24.2 → 4.24.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supercov",
-  "version": "4.24.2",
+  "version": "4.24.4",
   "description": "Coverage, security and code quality for coding agents",
   "keywords": [
     "coverage",
@@ -123,14 +123,14 @@
     "test:windows-tls": "node scripts/windows-tls-test.mjs"
   },
   "optionalDependencies": {
-    "@supercov/cli-darwin-arm64": "4.24.2",
-    "@supercov/cli-darwin-x64": "4.24.2",
-    "@supercov/cli-linux-arm64-gnu": "4.24.2",
-    "@supercov/cli-linux-arm64-musl": "4.24.2",
-    "@supercov/cli-linux-x64-gnu": "4.24.2",
-    "@supercov/cli-linux-x64-musl": "4.24.2",
-    "@supercov/cli-win32-arm64": "4.24.2",
-    "@supercov/cli-win32-x64": "4.24.2"
+    "@supercov/cli-darwin-arm64": "4.24.4",
+    "@supercov/cli-darwin-x64": "4.24.4",
+    "@supercov/cli-linux-arm64-gnu": "4.24.4",
+    "@supercov/cli-linux-arm64-musl": "4.24.4",
+    "@supercov/cli-linux-x64-gnu": "4.24.4",
+    "@supercov/cli-linux-x64-musl": "4.24.4",
+    "@supercov/cli-win32-arm64": "4.24.4",
+    "@supercov/cli-win32-x64": "4.24.4"
   },
   "peerDependencies": {
     "@playwright/test": ">=1.55.0",

package/runtime/javascript/launchSupervisor.mjs

@@ -314,7 +314,7 @@ function wrapResult(value, mapping) {
 // non-writable own data property (and `undefined` for a non-configurable
 // accessor without a getter). Constructors commonly expose `prototype` this
 // way. Returning another capability proxy is a TypeError before user code can
-// run, as seen with PrismaSessionStorage during an Essential Apps VM bake.
+// run, as seen with PrismaSessionStorage during a VM bake.
 function fixedProxyValue(target, property) {
     const descriptor = Reflect.getOwnPropertyDescriptor(target, property);
     if (!descriptor || descriptor.configurable)
@@ -729,6 +729,49 @@ function injectChildEnvironment(method, args) {
     });
     return next;
 }
+// A signal a crash raises, never the SIGTERM or SIGKILL a suite's teardown
+// sends. A child it ends says nothing: on 2026-11-06 a backend that died so
+// right after it listened read as one that never became ready, and a
+// Playwright worker as one that "exited unexpectedly".
+const CRASH_SIGNALS = new Set(["SIGSEGV", "SIGBUS", "SIGILL", "SIGFPE", "SIGABRT", "SIGTRAP", "SIGSYS"]);
+// The command a child ran, its arguments too: `spawn("npm", ["run",
+// "build"])` names its build only with them.
+function commandLine(args) {
+    const words = Array.isArray(args[1]) ? args[1] : [];
+    return [args[0], ...words].map((word) => String(word ?? "")).join(" ");
+}
+// A child that a crash signal ended, or that exited non-zero: a build the
+// command started from its own code, which the command's words do not
+// name, is told apart from one it never ran by this.
+function noteExit(signal, code, child, args, started) {
+    const crashed = CRASH_SIGNALS.has(signal);
+    if (!crashed && !(signal == null && typeof code === "number" && code !== 0))
+        return;
+    record({
+        event: "child-exit",
+        ...(typeof child === "number" ? { child } : {}),
+        ...(crashed ? { signal } : { code }),
+        command: safeArgument(commandLine(args)),
+        ranMs: Date.now() - started,
+    });
+}
+function watchChild(method, args, run) {
+    const started = Date.now();
+    let launched;
+    try {
+        launched = run();
+    }
+    catch (error) {
+        // execSync and execFileSync throw for a child that failed.
+        noteExit(error?.signal, error?.status, error?.pid, args, started);
+        throw error;
+    }
+    if (method === "spawnSync")
+        noteExit(launched?.signal, launched?.status, launched?.pid, args, started);
+    else if (typeof launched?.once === "function")
+        launched.once("exit", (code, signal) => noteExit(signal, code, launched.pid, args, started));
+    return launched;
+}
 function patchChildProcesses() {
     const methods = [
         "spawn",
@@ -745,7 +788,7 @@ function patchChildProcesses() {
             configurable: true,
             enumerable: true,
             writable: true,
-            value: keepPromisifiedShape(original, (...args) => Reflect.apply(original, childProcess, injectChildEnvironment(method, args))),
+            value: keepPromisifiedShape(original, (...args) => watchChild(method, args, () => Reflect.apply(original, childProcess, injectChildEnvironment(method, args)))),
         });
     }
     syncBuiltinESMExports();

package/runtime/javascript/register.mjs

@@ -13,6 +13,27 @@ import { fileURLToPath } from "node:url";
 import { installLaunchSupervisor, wrapImportedCapability } from "./launchSupervisor.mjs";
 import { __supercovBindCapabilityWrapper } from "./capability.mjs";
 installLaunchSupervisor();
+// Playwright 1.59 writes each file it compiles into its cache in place and
+// reads it back unchecked: a process that read one while another wrote it
+// ran an empty module, and a config of no `default` failed at "Cannot add
+// property metadata, object is not extensible". The cache a run gives it
+// starts empty, so every run compiled; there each file is written whole, or
+// is not there yet and is compiled again. A file written beside the cache's
+// folders, not in one, is never taken for an old entry and removed.
+const transformCache = process.env.PWTEST_CACHE_DIR;
+if (transformCache) {
+    const cacheFolder = resolve(transformCache) + sep;
+    const writeFileSync = fs.writeFileSync;
+    let written = 0;
+    fs.writeFileSync = function (file, ...rest) {
+        if (typeof file !== "string" || !resolve(file).startsWith(cacheFolder))
+            return writeFileSync.call(this, file, ...rest);
+        const partial = resolve(transformCache, `.writing-${process.pid}-${written++}`);
+        writeFileSync.call(this, partial, ...rest);
+        fs.renameSync(partial, file);
+    };
+    syncBuiltinESMExports();
+}
 // Instrumented sources import the browser-safe capability seam; bind the
 // real supervisor implementation before any user module evaluates.
 __supercovBindCapabilityWrapper(wrapImportedCapability);