supercov 0.0.28 → 0.0.30

package/README.md

@@ -154,7 +154,7 @@ Collections accept `--limit` and `--offset` and print a copyable next-page comma
 
 ## Local, private, and zero-edit
 
-Run evidence stays under `.supercov/runs/<run-id>/`. Supercov also maintains a marker-protected isolated build cache under `supercov/workspace/`.
+Everything Supercov writes lives under one hidden `.supercov/` directory: run evidence in `.supercov/runs/<run-id>/` and the isolated build cache in `.supercov/workspaces/`. It ignores itself in Git, so there is nothing to add to your `.gitignore`.
 
 The Supercov CLI does not contact a Supercov service during a coverage run. Package tools such as `npx` may contact the npm registry to download Supercov when it is not already cached.
 

package/docs/coverage-model.md

@@ -124,5 +124,16 @@ When first-party source lives in unusual directories, declare it explicitly:
 SUPERCOV_SOURCE_ROOTS=src,app npx supercov -- npm test
 ```
 
+Supercov never treats these as project source, so they are neither measured
+nor reported as limitations: another checkout nested in the tree (a directory
+with its own `.git`, such as an agent worktree or a vendored clone), hidden
+directories at the project root (`.shopify/`, `.vercel/`, `.idea/`), directories
+named `generated`, and hashed bundler output inside `assets/`, `static/`, or
+`public/`. Packages the root manifest declares in `workspaces` (or
+`pnpm-workspace.yaml`) are discovered wherever they live; a declared package
+without a conventional source directory is measured as a whole. Functions passed
+to compile-time style macros (`stylex.create(...)`) are left as written because
+the bundler consumes them at build time; nothing about them runs.
+
 Choose roots that describe code the repository owns. Do not include dependencies
 or generated output merely to make a warning disappear.

package/docs/troubleshooting.md

@@ -141,3 +141,15 @@ with:
 
 Do not include secrets, private source, or raw evidence from a repository you
 cannot share.
+
+## "malformed evidence record(s) ... were excluded"
+
+Application processes append coverage evidence themselves. When two of them
+share one file — pool runners that restore several VMs from a single snapshot
+run clones of the same server process, with the same process id — an append
+can tear another's line. Supercov skips the unreadable line, counts it under
+`CORRUPT_EVIDENCE_RECORDS`, and treats it as a blocking limitation so the run
+never looks complete. Since 0.0.29 the background and execution-trace writers also detect a
+clone sharing their file and move to a fresh one, so this should be rare; if it
+persists, check whether something outside Supercov appends to
+`.supercov/…/server/background/`.

package/docs/workspace-isolation.md

@@ -32,7 +32,9 @@ synced back to the project after the run, so `supercov -- npm test -- -u`
 updates snapshots in the repository exactly as `npm test -- -u` would. Two
 exceptions are reported instead of applied: changes the command makes to
 instrumented source files (the instrumented copies must never overwrite your
-sources) and deletions (never propagated automatically).
+sources) and deletions (never propagated automatically). Changes inside any
+`node_modules` directory are neither applied nor reported: dependency trees are
+not command outputs.
 
 ## Files Supercov creates
 
@@ -41,7 +43,7 @@ sources) and deletions (never propagated automatically).
 | `.supercov/runs/<run-id>/` | Completed immutable runs |
 | `.supercov/work/` | Temporary state while a run is being prepared |
 | `.supercov/locks/` | Prevents two operations from racing |
-| `.supercov-workspace/workspace/<project>/` | Isolated source and reusable instrumented build cache (safe to delete) |
+| `.supercov/workspaces/` | Isolated source mirror and reusable instrumented build cache (safe to delete) |
 
 Managed directories include Git ignore rules so run evidence and instrumented
 builds do not become ordinary repository changes.
@@ -88,6 +90,15 @@ When a suite launches a container or VM from a mounted workspace, Supercov uses
 the isolated workspace as the source presented to that environment. The runtime
 must be able to cross the launch boundary and return evidence.
 
+Dependencies stay out of the instrumented copy. The root `node_modules` is
+linked entry by entry to the project's own, so an environment that mounts the
+workspace must bring its own root dependencies (the supported launchers do).
+Nested `node_modules` inside packages and extensions are materialised as real
+directories: cloned copy-on-write where the filesystem allows it (APFS), and
+hard-linked file by file elsewhere on Unix, so they resolve inside the mount
+either way. Only when neither is possible, such as a dependency tree on another
+volume, are they linked entry by entry like the root.
+
 If a remote executor hides the launch or mount boundary, Supercov reports the
 limitation instead of claiming unseen code was measured. See
 [Supported suites](supported-suites.md) for the current boundary.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supercov",
-  "version": "0.0.28",
+  "version": "0.0.30",
   "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.28",
-    "@supercov/cli-darwin-x64": "0.0.28",
-    "@supercov/cli-linux-arm64-gnu": "0.0.28",
-    "@supercov/cli-linux-arm64-musl": "0.0.28",
-    "@supercov/cli-linux-x64-gnu": "0.0.28",
-    "@supercov/cli-linux-x64-musl": "0.0.28"
+    "@supercov/cli-darwin-arm64": "0.0.30",
+    "@supercov/cli-darwin-x64": "0.0.30",
+    "@supercov/cli-linux-arm64-gnu": "0.0.30",
+    "@supercov/cli-linux-arm64-musl": "0.0.30",
+    "@supercov/cli-linux-x64-gnu": "0.0.30",
+    "@supercov/cli-linux-x64-musl": "0.0.30"
   },
   "peerDependencies": {
     "@playwright/test": ">=1.55.0",

package/runtime/javascript/launchSupervisor.js

@@ -1,6 +1,6 @@
 import childProcess from "node:child_process";
-import { createHash } from "node:crypto";
-import { appendFileSync, mkdirSync } from "node:fs";
+import { createHash, randomBytes } from "node:crypto";
+import { appendFileSync, mkdirSync, statSync } from "node:fs";
 import Module, { syncBuiltinESMExports } from "node:module";
 import { dirname, isAbsolute, relative, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
@@ -30,9 +30,26 @@ function isClassConstructor(value) {
         return false;
     }
 }
-function executionLogPath(path) {
+// A pid is not an identity: pool VMs restored from one snapshot run clones
+// of this very process with the same pid, and their appends to one file over
+// a shared mount tear each other's lines. The log name carries a token, and
+// an append that finds the file a different size than this writer left it
+// has met a clone and rotates to a fresh file. The token mixes time in as
+// well as randomness because clones may also share their entropy state.
+function writerToken() {
+    let random = "";
+    try {
+        random = randomBytes(3).toString("hex");
+    }
+    catch {
+        random = Math.floor(Math.random() * 16777215).toString(16);
+    }
+    return `${random}${process.hrtime.bigint().toString(36).slice(-5)}`;
+}
+let executionLog = { token: writerToken(), path: undefined, size: 0 };
+function executionLogPath(path, token = executionLog.token) {
     const shard = (process.env["SUPERCOV_EXECUTION_LOG_SHARD"] ?? "host").replace(/[^A-Za-z0-9_.-]/g, "_");
-    const suffix = `.${shard}.${process.pid}.jsonl`;
+    const suffix = `.${shard}.${process.pid}-${token}.jsonl`;
     return path.endsWith(".jsonl")
         ? `${path.slice(0, -".jsonl".length)}${suffix}`
         : `${path}${suffix}`;
@@ -41,15 +58,30 @@ function record(value) {
     const configuredPath = process.env["SUPERCOV_EXECUTION_LOG"];
     if (!configuredPath)
         return;
-    const path = executionLogPath(configuredPath);
     try {
-        mkdirSync(dirname(path), { recursive: true });
-        appendFileSync(path, `${JSON.stringify({
+        let path = executionLogPath(configuredPath);
+        if (executionLog.path === path) {
+            let currentSize = 0;
+            try {
+                currentSize = statSync(path).size;
+            }
+            catch {
+                currentSize = 0;
+            }
+            if (currentSize !== executionLog.size) {
+                executionLog = { token: writerToken(), path: undefined, size: 0 };
+                path = executionLogPath(configuredPath);
+            }
+        }
+        const line = `${JSON.stringify({
             at: new Date().toISOString(),
             pid: process.pid,
             ppid: process.ppid,
             ...value,
-        })}\n`);
+        })}\n`;
+        mkdirSync(dirname(path), { recursive: true });
+        appendFileSync(path, line);
+        executionLog = { token: executionLog.token, path, size: executionLog.size + Buffer.byteLength(line) };
     }
     catch {
         // Process tracing is diagnostic and must never change test behavior.

package/runtime/javascript/playwright.js

@@ -6,7 +6,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     }
     return path;
 };
-import { createHash } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
 import childProcess from "node:child_process";
 import { mkdirSync, readFileSync, rmSync } from "node:fs";
 import http from "node:http";
@@ -33,7 +33,22 @@ const adapter = (targetModule === "@playwright/test"
 const base = (adapter[targetTestExport] ?? adapter.test);
 const baseExpect = adapter.expect;
 const GENERATED_EVIDENCE_DIRECTORY = "__SUPERCOV_EVIDENCE_DIRECTORY__";
-const evidenceWriterIdentity = () => (process.env.SUPERCOV_EXECUTION_LOG_SHARD ?? `pid-${process.pid}`)
+// A pid is not an identity. Pool runners restore several VMs from one
+// snapshot and re-execute tests in fresh workers that all carry the same
+// pid; without a per-process token their attempts hash to one identity and
+// their journals land in one file. The token mixes time with randomness
+// because restored clones may also share entropy state.
+const processInstanceToken = (() => {
+    let random = "";
+    try {
+        random = randomBytes(3).toString("hex");
+    }
+    catch {
+        random = Math.floor(Math.random() * 16777215).toString(16);
+    }
+    return `${random}${process.hrtime.bigint().toString(36).slice(-5)}`;
+})();
+const evidenceWriterIdentity = () => (process.env.SUPERCOV_EXECUTION_LOG_SHARD ?? `pid-${process.pid}-${processInstanceToken}`)
     .replace(/[^A-Za-z0-9_-]/g, "_");
 const GENERATED_RUN_ID = "__SUPERCOV_RUN_ID__";
 const PHASE_STORAGE_KEY = "__supercov_phase";
@@ -755,7 +770,7 @@ function currentRunId() {
 }
 function executionScope(testInfo) {
     const runId = currentRunId();
-    const workerId = `pid-${process.pid}-worker-${testInfo.workerIndex}`;
+    const workerId = `pid-${process.pid}-${processInstanceToken}-worker-${testInfo.workerIndex}`;
     const testKey = createHash("sha256")
         .update(testInfo.testId)
         .digest("hex")

package/runtime/javascript/runnerEvidence.js

@@ -1,10 +1,25 @@
-import { createHash } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
 import { mkdirSync, readFileSync } from "node:fs";
 import { relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { atomicWriteFileSync } from "./atomic.js";
 import { inferTestProvenance } from "./provenance.js";
 import { serverEvidencePath } from "./transport.js";
+
+let cachedProcessInstanceToken;
+function processInstanceToken() {
+    if (cachedProcessInstanceToken)
+        return cachedProcessInstanceToken;
+    let random = "";
+    try {
+        random = randomBytes(3).toString("hex");
+    }
+    catch {
+        random = Math.floor(Math.random() * 16777215).toString(16);
+    }
+    cachedProcessInstanceToken = `${random}${process.hrtime.bigint().toString(36).slice(-5)}`;
+    return cachedProcessInstanceToken;
+}
 function localFile(file) {
     if (!file)
         return undefined;
@@ -24,7 +39,9 @@ export function runnerTestId(identity) {
 export function runnerExecutionScope(identity) {
     const testId = runnerTestId(identity);
     const retry = identity.retry ?? 0;
-    const workerId = `${identity.runner}-${process.env["JEST_WORKER_ID"] ?? process.pid}`;
+    // Same hazard as the Playwright shim: a pooled runner's fresh workers can
+    // share a pid, so the worker identity carries a per-process token.
+    const workerId = `${identity.runner}-${process.env["JEST_WORKER_ID"] ?? process.pid}-${processInstanceToken()}`;
     const testKey = createHash("sha256").update(testId).digest("hex").slice(0, 24);
     return {
         version: 1,

package/runtime/javascript/runtime.js

@@ -150,6 +150,7 @@ function createState() {
     persistedServerRecords: /* @__PURE__ */ new Set(),
     backgroundBuffers: /* @__PURE__ */ new Map(),
     backgroundWriters: /* @__PURE__ */ new Map(),
+    backgroundShardSizes: /* @__PURE__ */ new Map(),
     backgroundSequence: 0,
     runtimeSnapshots: false,
     assertionPhases: /* @__PURE__ */ new Map(),
@@ -427,6 +428,16 @@ function writeExclusiveBackgroundRecord(fs, runId, writer, initialSequence, payl
   }
   throw Object.assign(new Error("Could not allocate a collision-free Supercov background evidence record"), { code: "SUPERCOV_BACKGROUND_COLLISION_LIMIT" });
 }
+function backgroundWriterToken() {
+  try {
+    const getBuiltinModule = process.getBuiltinModule;
+    const crypto = getBuiltinModule == null ? void 0 : getBuiltinModule("node:crypto");
+    if (crypto)
+      return crypto.randomBytes(4).toString("hex");
+  } catch (e) {
+  }
+  return Math.floor(Math.random() * 4294967295).toString(16);
+}
 function appendDurableBackgroundRecord(fs, runId, record) {
   var _a8;
   const records = state.backgroundBuffers.get(runId) != null ? state.backgroundBuffers.get(runId) : /* @__PURE__ */ new Map();
@@ -437,15 +448,32 @@ function appendDurableBackgroundRecord(fs, runId, record) {
   const payload = JSON.stringify(record) + "\n";
   fs.mkdirSync(directory, { recursive: true });
   let path = state.backgroundWriters.get(runId);
+  // A pid is not an identity: pool VMs restored from one snapshot run clones
+  // of this very process, same pid and same cached shard path, and their
+  // appends over a shared mount tear each other's lines. The shard name gets
+  // a fresh random token, and an append that finds the file a different size
+  // than this writer left it has met a clone: it moves to a new shard.
+  if (path) {
+    let currentSize = -1;
+    try {
+      currentSize = fs.statSync(path).size;
+    } catch (e) {
+    }
+    if (currentSize !== (state.backgroundShardSizes.get(path) ?? -1)) {
+      path = void 0;
+    }
+  }
   if (!path) {
     const shard = (_a8 = process.env["SUPERCOV_EXECUTION_LOG_SHARD"]) != null ? _a8 : "process";
-    const writer = `${shard}-${process.pid}`;
+    const writer = `${shard}-${process.pid}-${backgroundWriterToken()}`;
     const nextSequence = writeExclusiveBackgroundRecord(fs, runId, writer, state.backgroundSequence, payload);
     state.backgroundSequence = nextSequence;
     path = backgroundEvidencePath(runId, `${writer}-${nextSequence - 1}`);
     state.backgroundWriters.set(runId, path);
+    state.backgroundShardSizes.set(path, Buffer.byteLength(payload));
   } else {
     fs.appendFileSync(path, payload);
+    state.backgroundShardSizes.set(path, (state.backgroundShardSizes.get(path) ?? 0) + Buffer.byteLength(payload));
   }
   records.set(key, record);
   state.backgroundBuffers.set(runId, records);