supercov 2.0.1 → 3.0.1

package/runtime/javascript/runtime.mjs

@@ -1,10 +1,13 @@
 var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+// The runtime runs inside the application under test, and its tests may
+// pollute Object.prototype on purpose: axios's set `Object.prototype.get`, and
+// a descriptor that inherits `get` makes defineProperty throw "Getter must be a
+// function", failing tests that pass without Supercov. Every descriptor here has
+// no prototype, and spreading copies values rather than descriptors.
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { __proto__: null, enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __spreadValues = (a, b) => {
   for (var prop in b || (b = {}))
     if (__hasOwnProp.call(b, prop))
@@ -16,7 +19,15 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __spreadProps = (a, b) => __spreadValues(a, b);
+
+// Buffer as it was when Supercov loaded. Tests replace globals -- axios's set
+// `globalThis.Buffer = undefined` to check it copes -- and the runtime runs
+// inside those tests; it must not fail where the application does not.
+var capturedBuffer = typeof Buffer === "undefined" ? void 0 : Buffer;
+// Likewise the timer: a test that installs fake timers would otherwise hold
+// the browser's evidence back until it advanced its clock.
+var capturedSetTimeout = setTimeout;
 
 // dist/transport.js
 var COVERAGE_SCOPE_HEADER = "x-supercov-scope";
@@ -77,13 +88,13 @@ function decodeCoverageScope(encoded) {
   }
 }
 function encodeCoverageCarrier(carrier) {
-  return Buffer.from(JSON.stringify(carrier), "utf8").toString("base64url");
+  return capturedBuffer.from(JSON.stringify(carrier), "utf8").toString("base64url");
 }
 function decodeCoverageCarrier(encoded) {
   if (!encoded)
     return void 0;
   try {
-    const value = JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
+    const value = JSON.parse(capturedBuffer.from(encoded, "base64url").toString("utf8"));
     if (value.version !== 1)
       return void 0;
     if (value.scope) {
@@ -154,6 +165,8 @@ function createState() {
     backgroundBuffers: /* @__PURE__ */ new Map(),
     backgroundWriters: /* @__PURE__ */ new Map(),
     backgroundShardSizes: /* @__PURE__ */ new Map(),
+    backgroundDescriptors: /* @__PURE__ */ new Map(),
+    pendingBackgroundAppends: /* @__PURE__ */ new Map(),
     backgroundSequence: 0,
     runtimeSnapshots: false,
     assertionPhases: /* @__PURE__ */ new Map(),
@@ -330,6 +343,80 @@ function resetCoverage(testId2) {
 runtimeGlobal.__SUPERCOV_MCDC_SNAPSHOT__ = decisionSnapshot;
 runtimeGlobal.__SUPERCOV_COVERAGE_SNAPSHOT__ = coverageSnapshot;
 runtimeGlobal.__SUPERCOV_RESET__ = resetCoverage;
+// A dedicated worker blocked in `Atomics.wait` runs no evaluation, so the
+// test runner could not read its evidence and reported the test as a lower
+// bound: Actual's database worker waits that way between every query. The
+// worker pushes its evidence to its pages instead, on a BroadcastChannel,
+// each time it is about to block with something recorded since its last
+// push; a worker that wakes and records something new says its push is no
+// longer current. A page keeps the latest push of each worker, and the runner
+// reads that when the worker itself does not answer: complete when current.
+var workerEvidenceChannelName = "__supercov_worker_evidence__";
+var workerEvidence = null;
+function workerEvidenceChanged() {
+  if (workerEvidence === null || workerEvidence.changed)
+    return;
+  workerEvidence.changed = true;
+  if (!workerEvidence.pushed)
+    return;
+  workerEvidence.pushed = false;
+  try {
+    workerEvidence.channel.postMessage({ token: workerEvidence.token, current: false });
+  } catch (e) {
+  }
+}
+function pushWorkerEvidence() {
+  if (workerEvidence === null || workerEvidence.pushed)
+    return;
+  workerEvidence.changed = false;
+  workerEvidence.pushed = true;
+  try {
+    workerEvidence.channel.postMessage({ token: workerEvidence.token, url: workerEvidence.url, current: true, snapshot: coverageSnapshot() });
+  } catch (e) {
+    workerEvidence.pushed = false;
+  }
+}
+(function installWorkerEvidenceTransport() {
+  if (!isBrowser || typeof BroadcastChannel !== "function")
+    return;
+  if (typeof WorkerGlobalScope === "function" && runtimeGlobal instanceof WorkerGlobalScope) {
+    if (typeof Atomics !== "object" || typeof Atomics.wait !== "function" || runtimeGlobal.__SUPERCOV_WORKER_TOKEN__)
+      return;
+    try {
+      const token = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+      const url = runtimeGlobal.location ? String(runtimeGlobal.location.href) : "";
+      workerEvidence = { channel: new BroadcastChannel(workerEvidenceChannelName), token, url, changed: true, pushed: false };
+      runtimeGlobal.__SUPERCOV_WORKER_TOKEN__ = token;
+      const wait = Atomics.wait;
+      Atomics.wait = function wait2(typedArray, index, value, timeout) {
+        pushWorkerEvidence();
+        return Reflect.apply(wait, Atomics, arguments);
+      };
+    } catch (e) {
+      workerEvidence = null;
+    }
+    return;
+  }
+  if (typeof document === "undefined" || runtimeGlobal.__SUPERCOV_WORKER_EVIDENCE__)
+    return;
+  const received = /* @__PURE__ */ new Map();
+  try {
+    const channel = new BroadcastChannel(workerEvidenceChannelName);
+    channel.onmessage = (event) => {
+      const message = event.data;
+      if (!message || typeof message.token !== "string")
+        return;
+      const pushed = received.get(message.token);
+      if (message.current)
+        received.set(message.token, { url: message.url, snapshot: message.snapshot, current: true });
+      else if (pushed)
+        pushed.current = false;
+    };
+  } catch (e) {
+    return;
+  }
+  runtimeGlobal.__SUPERCOV_WORKER_EVIDENCE__ = () => Array.from(received, ([token, pushed]) => ({ token, url: pushed.url, current: pushed.current, snapshot: pushed.snapshot }));
+})();
 var persistBrowserScheduled = false;
 var persistBrowserListenersInstalled = false;
 function persistBrowserNow() {
@@ -361,7 +448,7 @@ function persistBrowser() {
   if (persistBrowserScheduled)
     return;
   persistBrowserScheduled = true;
-  setTimeout(() => {
+  capturedSetTimeout(() => {
     persistBrowserScheduled = false;
     persistBrowserNow();
   }, 0);
@@ -449,15 +536,54 @@ function backgroundWriterToken() {
   }
   return Math.floor(Math.random() * 4294967295).toString(16);
 }
+// Background records -- every first hit under tap, AVA or Mocha, and code run
+// outside any test -- are written once per event-loop turn, as a test's own
+// records are, and on exit and the terminating signals. Written one by one
+// they cost lru-cache's 10 ms TTL test a write and a stat for each of the 132
+// first hits in its window, and the test missed its deadline under load. A
+// process killed in the middle of a turn loses that turn's records.
 function appendDurableBackgroundRecord(fs, runId, record) {
-  var _a8;
   const records = state.backgroundBuffers.get(runId) != null ? state.backgroundBuffers.get(runId) : /* @__PURE__ */ new Map();
   const key = serverRecordKey(record);
   if (records.has(key))
     return state.backgroundWriters.get(runId);
+  if (state.serverTransportFailure)
+    throw state.serverTransportFailure;
+  records.set(key, record);
+  state.backgroundBuffers.set(runId, records);
+  let pending = state.pendingBackgroundAppends.get(runId);
+  if (!pending) {
+    pending = [];
+    state.pendingBackgroundAppends.set(runId, pending);
+  }
+  pending.push(JSON.stringify(record) + "\n");
+  if (pending.length >= 2048)
+    flushServerAppends();
+  else
+    scheduleServerFlush();
+  return state.backgroundWriters.get(runId);
+}
+function flushBackgroundAppends(fs) {
+  for (const [runId, lines] of state.pendingBackgroundAppends) {
+    state.pendingBackgroundAppends.delete(runId);
+    try {
+      if (!fs)
+        throw new Error("node:fs is unavailable");
+      writeBackgroundLines(fs, runId, lines.join(""));
+    } catch (cause) {
+      const failure = cause instanceof Error && cause.code === "SUPERCOV_EVIDENCE_TRANSPORT_FAILED" ? cause : serverTransportError(runId, cause);
+      state.serverTransportFailure = failure;
+      throw failure;
+    }
+  }
+}
+function writeBackgroundLines(fs, runId, payload) {
+  var _a8;
   const directory = backgroundEvidenceDirectory(runId);
-  const payload = JSON.stringify(record) + "\n";
-  fs.mkdirSync(directory, { recursive: true });
+  if (!state.createdEvidenceDirectories.has(directory)) {
+    fs.mkdirSync(directory, { recursive: true });
+    state.createdEvidenceDirectories.add(directory);
+  }
   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
@@ -470,7 +596,8 @@ function appendDurableBackgroundRecord(fs, runId, record) {
       currentSize = fs.statSync(path).size;
     } catch (e) {
     }
-    if (currentSize !== (state.backgroundShardSizes.get(path) ?? -1)) {
+    if (currentSize !== (state.backgroundShardSizes.has(path) ? state.backgroundShardSizes.get(path) : -1)) {
+      closeBackgroundShard(fs, path);
       path = void 0;
     }
   }
@@ -481,14 +608,28 @@ function appendDurableBackgroundRecord(fs, runId, record) {
     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));
+    state.backgroundShardSizes.set(path, capturedBuffer.byteLength(payload));
+    return;
+  }
+  let descriptor = state.backgroundDescriptors.get(path);
+  if (descriptor === void 0) {
+    descriptor = fs.openSync(path, "a");
+    state.backgroundDescriptors.set(path, descriptor);
+  }
+  const bytes = capturedBuffer.from(payload);
+  for (let written = 0; written < bytes.length; )
+    written += fs.writeSync(descriptor, bytes, written, bytes.length - written);
+  state.backgroundShardSizes.set(path, (state.backgroundShardSizes.get(path) || 0) + bytes.length);
+}
+function closeBackgroundShard(fs, path) {
+  const descriptor = state.backgroundDescriptors.get(path);
+  if (descriptor === void 0)
+    return;
+  state.backgroundDescriptors.delete(path);
+  try {
+    fs.closeSync(descriptor);
+  } catch (e) {
   }
-  records.set(key, record);
-  state.backgroundBuffers.set(runId, records);
-  return path;
 }
 var _a7;
 // Evidence buffered for the current turn is lost when a signal ends the
@@ -560,9 +701,10 @@ function serverTransportError(runId, cause) {
 }
 function flushServerAppends() {
   const pending = state.pendingServerAppends;
-  if (pending.size === 0)
+  if (pending.size === 0 && state.pendingBackgroundAppends.size === 0)
     return;
   const fs = getFs();
+  flushBackgroundAppends(fs);
   for (const [path, entry] of pending) {
     pending.delete(path);
     try {
@@ -593,6 +735,9 @@ function enqueueServerAppend(directory, path, line, runId) {
   } else {
     state.pendingServerAppends.set(path, { directory, runId, lines: [line] });
   }
+  scheduleServerFlush();
+}
+function scheduleServerFlush() {
   if (!state.serverExitHookInstalled && typeof process !== "undefined") {
     state.serverExitHookInstalled = true;
     try {
@@ -676,11 +821,19 @@ function appendServer(record) {
     throw serverTransportError(runId, cause);
   }
 }
+// Read on every probe outside a test, and the variable rarely changes: decode
+// it once per value.
+var decodedEnvironmentCarrier = { raw: void 0, context: void 0 };
 function environmentRequestContext() {
   if (isBrowser || typeof process === "undefined")
     return void 0;
-  const carrier = decodeCoverageCarrier(process.env[COVERAGE_CARRIER_ENV]);
-  return carrier ? __spreadValues(__spreadValues({}, carrier.scope ? { scope: carrier.scope } : {}), carrier.phaseId ? { phaseId: carrier.phaseId } : {}) : void 0;
+  const raw = process.env[COVERAGE_CARRIER_ENV];
+  if (raw === decodedEnvironmentCarrier.raw)
+    return decodedEnvironmentCarrier.context;
+  const carrier = decodeCoverageCarrier(raw);
+  const context = carrier ? __spreadValues(__spreadValues({}, carrier.scope ? { scope: carrier.scope } : {}), carrier.phaseId ? { phaseId: carrier.phaseId } : {}) : void 0;
+  decodedEnvironmentCarrier = { raw, context };
+  return context;
 }
 function currentRequestContext() {
   const stored = serverPhaseStorage == null ? void 0 : serverPhaseStorage.getStore();
@@ -718,7 +871,8 @@ function assertionPhaseState(scope) {
   const key = attemptKey(scope);
   const existing = state.assertionPhases.get(key);
   if (existing) {
-    existing.phaseIds ??= new Set(existing.phases.filter(phase => phase.kind === "assertion").map(phase => phase.id));
+    if (existing.phaseIds == null)
+      existing.phaseIds = new Set(existing.phases.filter(phase => phase.kind === "assertion").map(phase => phase.id));
     return existing;
   }
   const created = { counter: 0, phases: [], phaseIds: new Set() };
@@ -806,6 +960,92 @@ function bindNodeAssertionPhase(operation, source, target, property = null) {
   const receiver = property === null ? undefined : target;
   return (...args) => withNodeAssertionPhase(operation, source, () => Reflect.apply(callback, receiver, args));
 }
+// withCoverageCarrier for code that runs in place rather than in a callback:
+// the carrier holds until the returned function restores what it replaced.
+// Opened and restored within one synchronous run, it is what run() does.
+function enterCoverageCarrier(carrier) {
+  if (!serverPhaseStorage)
+    return () => {
+    };
+  const previousStore = serverPhaseStorage.getStore();
+  const previousEpoch = state.probeV2Clock.epoch;
+  const context = __spreadValues(__spreadValues({}, carrier.scope ? { scope: carrier.scope } : {}), carrier.phaseId ? { phaseId: carrier.phaseId } : {});
+  serverPhaseStorage.enterWith(context);
+  activateProbeV2Context(context);
+  return () => {
+    serverPhaseStorage.enterWith(previousStore);
+    state.probeV2Clock.epoch = previousEpoch;
+  };
+}
+var inertAssertionPhase = { close: (value) => value, fail: (error) => error };
+// The phase withNodeAssertionPhase runs its callback in, opened before a
+// TypeScript assertion's operands and closed after its call. The rewrite calls
+// the assertion in place because TypeScript narrows nothing into a callback:
+// `prior < id` under `if (prior !== undefined)`, an evolving `const ids = []`
+// and an `asserts` signature all failed to typecheck once wrapped in one.
+function openNodeAssertionPhase(operation, source) {
+  var _a8;
+  const context = currentRequestContext();
+  const scope = context.scope;
+  if (!scope)
+    return inertAssertionPhase;
+  const nested = context.phaseId && assertionPhaseState(scope).phaseIds.has(context.phaseId);
+  if (nested && typeof source !== "string")
+    return inertAssertionPhase;
+  if (typeof source === "function")
+    source = source();
+  let carrier;
+  let finish;
+  let release;
+  const bridged = (_a8 = runtimeGlobal.__SUPERCOV_ASSERTION_PHASE_OPENER__) == null ? void 0 : _a8.call(runtimeGlobal, operation, source);
+  if (bridged) {
+    ({ carrier, finish, release } = bridged);
+  } else {
+    const attempt = assertionPhaseState(scope);
+    const phase = __spreadProps(__spreadValues({
+      id: `${scope.attemptId}:assertion:${++attempt.counter}`,
+      kind: "assertion",
+      operation
+    }, source ? { source } : {}), {
+      startedAtMs: Date.now()
+    });
+    attempt.phases.push(phase);
+    attempt.phaseIds.add(phase.id);
+    carrier = { version: 1, scope, phaseId: phase.id };
+    finish = (error) => finishAssertionPhase(phase, error);
+  }
+  const restore = enterCoverageCarrier(carrier);
+  let open = true;
+  const settle = () => {
+    if (!open)
+      return false;
+    open = false;
+    restore();
+    release == null ? void 0 : release();
+    return true;
+  };
+  return {
+    close(value) {
+      if (!settle())
+        return value;
+      if (value && typeof value.then === "function")
+        return Promise.resolve(value).then((resolved) => {
+          finish();
+          return resolved;
+        }, (error) => {
+          finish(error);
+          throw cleanInstrumentationStack(error);
+        });
+      finish();
+      return value;
+    },
+    fail(error) {
+      if (settle())
+        finish(error);
+      return cleanInstrumentationStack(error);
+    }
+  };
+}
 function takeNodeAssertionPhases(scope) {
   var _a8, _b;
   const key = attemptKey(scope);
@@ -846,6 +1086,35 @@ function installServerFetchPropagation() {
   runtimeGlobal.__SUPERCOV_FETCH_PATCHED__ = true;
 }
 installServerFetchPropagation();
+// util.promisify(exec) and util.promisify(execFile) resolve { stdout, stderr }
+// through a function Node keeps on the original, and that function calls the
+// original. A wrapper carries its own, which calls the wrapper, or a promisified
+// call resolves the bare stdout string and skips the wrapper.
+const promisifyCustom = Symbol.for("nodejs.util.promisify.custom");
+function keepPromisifiedShape(original, wrapper) {
+  if (typeof original[promisifyCustom] !== "function")
+    return wrapper;
+  Object.defineProperty(wrapper, promisifyCustom, {
+    configurable: true,
+    value: (...args) => {
+      let settle, reject;
+      const promise = new Promise((ok, fail) => {
+        settle = ok;
+        reject = fail;
+      });
+      promise.child = wrapper(...args, (error, stdout, stderr) => {
+        if (error !== null) {
+          error.stdout = stdout;
+          error.stderr = stderr;
+          reject(error);
+        } else
+          settle({ stdout, stderr });
+      });
+      return promise;
+    }
+  });
+  return wrapper;
+}
 function installServerChildPropagation() {
   var _a8;
   if (isBrowser || runtimeGlobal.__SUPERCOV_CHILD_PATCHED__ || typeof process === "undefined")
@@ -855,9 +1124,12 @@ function installServerChildPropagation() {
   if (!child)
     return;
   const mutableChild = child;
+  // (file, args?, options?, callback?): options follow an argument list, or an
+  // explicit null or undefined in its place. exec itself calls execFile as
+  // (file, options, callback), and that object is the options, not a list.
   const optionIndex = (method, args) => {
     if (method === "spawn" || method === "spawnSync" || method === "fork" || method === "execFile" || method === "execFileSync")
-      return Array.isArray(args[1]) || args.length > 2 && args[2] !== void 0 ? 2 : 1;
+      return Array.isArray(args[1]) || args[1] == null && args.length > 2 ? 2 : 1;
     return 1;
   };
   for (const method of [
@@ -872,12 +1144,15 @@ function installServerChildPropagation() {
     const original = mutableChild[method];
     if (typeof original !== "function")
       continue;
-    mutableChild[method] = function(...args) {
+    mutableChild[method] = keepPromisifiedShape(original, function(...args) {
       var _a9;
       const index = optionIndex(method, args);
       const existing = args[index] && typeof args[index] === "object" ? args[index] : {};
+      // An env the caller passed is the child's whole environment -- execa's
+      // extendEnv: false keeps the parent's CI out of chalk's fixtures -- so
+      // only the carrier joins it. Without one, the child inherits ours.
       const options = __spreadProps(__spreadValues({}, existing), {
-        env: __spreadValues(__spreadValues(__spreadValues({}, process.env), (_a9 = existing.env) != null ? _a9 : {}), coverageContextEnvironment())
+        env: __spreadValues(__spreadValues({}, (_a9 = existing.env) != null ? _a9 : process.env), coverageContextEnvironment())
       });
       const scoped = [...args];
       if (typeof scoped[index] === "function")
@@ -885,7 +1160,7 @@ function installServerChildPropagation() {
       else
         scoped[index] = options;
       return Reflect.apply(original, child, scoped);
-    };
+    });
   }
   const moduleBuiltin = getBuiltinModule == null ? void 0 : getBuiltinModule("node:module");
   (_a8 = moduleBuiltin == null ? void 0 : moduleBuiltin.syncBuiltinESMExports) == null ? void 0 : _a8.call(moduleBuiltin);
@@ -897,13 +1172,26 @@ installServerChildPropagation();
  * against the attempt it claims to belong to without a lookup.
  */
 function phaseBelongsToAttempt(phaseId, attemptId) {
-  return typeof phaseId === "string" && typeof attemptId === "string" && attemptId.length > 0 && phaseId.startsWith(`${attemptId}:phase:`);
+  return typeof phaseId === "string" && typeof attemptId === "string" && attemptId.length > 0 && phaseId.startsWith(`${attemptId}:`);
 }
 function currentPhaseId() {
   if (runtimeGlobal.__SUPERCOV_PHASE_ID__)
     return runtimeGlobal.__SUPERCOV_PHASE_ID__;
-  if (!isBrowser)
-    return currentRequestContext().phaseId;
+  if (!isBrowser) {
+    // Async work an earlier test started -- a stream, a socket, a timer --
+    // keeps that test's context and can run after the next test has begun.
+    // Its phase belongs to the earlier attempt, and tagging this test's
+    // evidence with it made the whole run unreadable ("unknown frontend phase
+    // reference"): axios's HTTP/2 upload tests did it three times in 2,201.
+    // Where the process knows which test is running, only that test's phases
+    // are honoured; a server process, which learns its test from the request,
+    // keeps the carried phase.
+    const context = currentRequestContext();
+    const active = runtimeGlobal.__SUPERCOV_ACTIVE_SCOPE__;
+    if (context.phaseId && active && !phaseBelongsToAttempt(context.phaseId, active.attemptId))
+      return void 0;
+    return context.phaseId;
+  }
   try {
     // The stored phase is per origin, so in a browser context that outlives
     // its test (a persistent profile shared by a whole worker) it still holds
@@ -976,15 +1264,23 @@ function requestCoverageContext(value) {
 }
 // Keep connection ownership on the emitter, without changing listener
 // identity (removeListener/off and once still see the original callbacks).
-const emitterContextMaps = runtimeGlobal.__SUPERCOV_EMITTER_CONTEXT_MAPS__ ??= new Map();
-const emitterCoverageContexts = emitterContextMaps.get(runtimeInstance) ?? new WeakMap();
+if (runtimeGlobal.__SUPERCOV_EMITTER_CONTEXT_MAPS__ == null)
+  runtimeGlobal.__SUPERCOV_EMITTER_CONTEXT_MAPS__ = new Map();
+const emitterContextMaps = runtimeGlobal.__SUPERCOV_EMITTER_CONTEXT_MAPS__;
+const emitterCoverageContexts = emitterContextMaps.get(runtimeInstance) || new WeakMap();
 emitterContextMaps.set(runtimeInstance, emitterCoverageContexts);
-const patchedEmitterInstances = runtimeGlobal.__SUPERCOV_EMITTER_PATCHED_INSTANCES__ ??= new Set();
+if (runtimeGlobal.__SUPERCOV_EMITTER_PATCHED_INSTANCES__ == null)
+  runtimeGlobal.__SUPERCOV_EMITTER_PATCHED_INSTANCES__ = new Set();
+const patchedEmitterInstances = runtimeGlobal.__SUPERCOV_EMITTER_PATCHED_INSTANCES__;
 function installNodeRequestPropagation() {
   if (isBrowser || patchedEmitterInstances.has(runtimeInstance) || typeof process === "undefined") return;
-  const EventEmitter = process.getBuiltinModule?.("node:events")?.EventEmitter;
-  const Server = process.getBuiltinModule?.("node:http")?.Server;
-  const SecureServer = process.getBuiltinModule?.("node:https")?.Server;
+  const builtin = (name) => typeof process.getBuiltinModule === "function" ? process.getBuiltinModule(name) : void 0;
+  const events = builtin("node:events");
+  const http = builtin("node:http");
+  const https = builtin("node:https");
+  const EventEmitter = events && events.EventEmitter;
+  const Server = http && http.Server;
+  const SecureServer = https && https.Server;
   if (!EventEmitter) return;
   const original = EventEmitter.prototype.emit;
   EventEmitter.prototype.emit = function(event, ...args) {
@@ -994,7 +1290,7 @@ function installNodeRequestPropagation() {
       // HTTP headers establish ownership even when Express/SDK listeners and
       // the server process were created by a shared before hook.
       const incoming = requestCoverageContext(args[0]);
-      if (incoming) context = incoming.scope ? incoming : context ?? currentRequestContext();
+      if (incoming) context = incoming.scope ? incoming : context != null ? context : currentRequestContext();
     }
     const invoke = () => Reflect.apply(original, this, [event, ...args]);
     try {
@@ -1016,7 +1312,7 @@ function withRequestPhase(handler, event) {
     const requestContext = args.map((argument) => requestCoverageContext(argument)).find((context2) => context2 !== void 0);
     // An untagged request to a test-owned server must not erase that server's
     // owner. Shared servers have no captured test scope and stay unattributed.
-    const inheritedContext = requestContext?.scope ? {} : registeredContext.scope ? registeredContext : requestContext === void 0 ? currentRequestContext() : {};
+    const inheritedContext = requestContext && requestContext.scope ? {} : registeredContext.scope ? registeredContext : requestContext === void 0 ? currentRequestContext() : {};
     const context = __spreadValues(__spreadValues({}, ((_a8 = requestContext == null ? void 0 : requestContext.scope) != null ? _a8 : inheritedContext.scope) ? { scope: (_b = requestContext == null ? void 0 : requestContext.scope) != null ? _b : inheritedContext.scope } : {}), ((_c = requestContext == null ? void 0 : requestContext.phaseId) != null ? _c : inheritedContext.phaseId) ? { phaseId: (_d = requestContext == null ? void 0 : requestContext.phaseId) != null ? _d : inheritedContext.phaseId } : {});
     const invoke = () => {
       if (event === "connection" && context.scope && args[0] &&
@@ -1038,10 +1334,36 @@ function recordBrowserEvent(event) {
     return false;
   state.eventKeys.add(key);
   state.events.push(event);
+  workerEvidenceChanged();
   return true;
 }
+// A hit is recorded once per context, as a statement probe's is: selections,
+// optional chains, defaults and loops reach here on every evaluation, and
+// each built and serialized its record before the transport dropped it as a
+// repeat.
 function coverageHit(id) {
+  const clock = state.probeV2Clock;
+  if (clock.fast && state.hitEpochs !== void 0 && state.hitEpochs.get(id) === clock.epoch)
+    return;
+  recordCoverageHit(id);
+}
+// resetCoverage forces a fresh epoch, so a hit skipped above was recorded in
+// this epoch after the last reset and is in state.hits already.
+function recordCoverageHit(id) {
   state.hits.add(id);
+  const clock = state.probeV2Clock;
+  let epoch = clock.epoch;
+  if (!clock.fast) {
+    const previousEpoch = clock.epoch;
+    activateProbeV2Context(currentRequestContext());
+    epoch = clock.epoch;
+    clock.epoch = previousEpoch;
+  }
+  if (!state.hitEpochs)
+    state.hitEpochs = /* @__PURE__ */ new Map();
+  if (state.hitEpochs.get(id) === epoch)
+    return;
+  state.hitEpochs.set(id, epoch);
   const timestampMs = Date.now();
   const phaseId = currentPhaseId();
   if (isBrowser) {
@@ -1075,7 +1397,12 @@ function registerProbeV2(definition) {
     }),
     decisionObservationEpochs: new Uint32Array(definition.decisions.length),
     decisionObservationCounts: new Uint16Array(definition.decisions.length),
-    decisionCompleteEpochs: new Uint32Array(definition.decisions.length)
+    decisionCompleteEpochs: new Uint32Array(definition.decisions.length),
+    pendingDefaults: new Uint32Array(definition.defaultCount || 0),
+    // A selection's outcomes -- short falsy, short truthy, right falsy, right
+    // truthy -- are four consecutive points per site from the first index.
+    selectionPoints: definition.selectionPoints,
+    none: optionalCallEmptySpread
   };
   state.probeV2Files.add(file);
   if (isBrowser) {
@@ -1083,10 +1410,27 @@ function registerProbeV2(definition) {
     activateProbeV2Key(`browser\0${(_a8 = runtimeGlobal.__SUPERCOV_MCDC_TEST_ID__) != null ? _a8 : testId}\0${(_b = runtimeGlobal.__SUPERCOV_PHASE_ID__) != null ? _b : "unscoped"}`);
   } else {
     installProbeV2AsyncHook();
+    // The hook sets the epoch when an async callback begins. Code that runs
+    // before any did -- a script's own top level -- found it NaN, which no
+    // epoch equals, so every probe there took the slow path every time: a
+    // million-iteration loop ran 1,700 times slower than without Supercov.
+    if (Number.isNaN(state.probeV2Clock.epoch))
+      activateProbeV2Context(currentRequestContext());
   }
   return file;
 }
+// Every repeat of a probe in the same context ends at the first check, so it
+// stays small enough for V8 to inline into the instrumented function; the
+// rest runs once per context. minimatch's backtracking guard test needs a
+// pathological match inside a second, and the full body in every call put it
+// at ten times the uninstrumented time.
 function coverageHitV2(file, index) {
+  const clock = file.clock;
+  if (clock.fast && file.hitEpochs[index] === clock.epoch)
+    return;
+  recordCoverageHitV2(file, index);
+}
+function recordCoverageHitV2(file, index) {
   const id = file.pointIds[index];
   if (!id)
     return;
@@ -1100,6 +1444,9 @@ function coverageHitV2(file, index) {
       return;
     file.hitEpochs[index] = epoch;
     coverageHit(id);
+    const selections = file.selectionPoints;
+    if (selections !== void 0 && index >= selections[0] && index < selections[0] + 4 * selections[1])
+      recordSelectionOutcome(id, index - selections[0] & 3);
   } finally {
     if (fallbackEpoch)
       file.clock.epoch = previousEpoch;
@@ -1118,6 +1465,15 @@ function decodeProbeV2Vector(conditionCount, encoded, outcome) {
   return remaining === 0 ? { values, outcome } : void 0;
 }
 function mcdcEndV2(file, decisionIndex, encoded, value) {
+  const clock = file.clock;
+  if (clock.fast) {
+    const seen = file.decisionEpochs[decisionIndex];
+    if (seen instanceof Uint32Array && seen[encoded * 2 + (value ? 1 : 0)] === clock.epoch)
+      return value;
+  }
+  return recordMcdcEndV2(file, decisionIndex, encoded, value);
+}
+function recordMcdcEndV2(file, decisionIndex, encoded, value) {
   var _a8, _b;
   const meta = file.decisions[decisionIndex];
   if (!meta || !Number.isSafeInteger(encoded) || encoded < 0)
@@ -1170,6 +1526,7 @@ function selectionBegin(shortId, rightId) {
 function applyInferredName(value, inferredName) {
   if (inferredName && typeof value === "function" && value.name === "") {
     Object.defineProperty(value, "name", {
+      __proto__: null,
       value: inferredName,
       configurable: true
     });
@@ -1189,24 +1546,38 @@ function selectionRight(frame, value, inferredName) {
   frame.rightEvaluated = true;
   return applyInferredName(value, inferredName);
 }
+var selectionOutcomeKeys = ["SF", "ST", "RF", "RT"];
+var selectionBranchIds = /* @__PURE__ */ new Map();
 function selectionEnd(frame, value) {
-  coverageHit(frame.rightEvaluated ? frame.rightId : frame.shortId);
-  // Per-operand outcomes for the verifier: which side was selected and whether the result is
-  // truthy. With the operator (known from the manifest) this gives each operand's outcome.
-  const separator = frame.shortId.lastIndexOf(":");
-  if (separator > 0) {
-    const branchId = frame.shortId.slice(0, separator);
-    const right = frame.rightEvaluated;
-    const truthy = Boolean(value);
-    let vectors = state.logicals.get(branchId);
-    if (!vectors) {
-      vectors = /* @__PURE__ */ new Map();
-      state.logicals.set(branchId, vectors);
-    }
-    vectors.set(`${right ? "R" : "S"}${truthy ? "T" : "F"}`, { right, truthy });
-  }
+  const right = frame.rightEvaluated;
+  coverageHit(right ? frame.rightId : frame.shortId);
+  recordSelectionOutcome(frame.shortId, (right ? 2 : 0) + (value ? 1 : 0));
   return value;
 }
+// Per-operand outcomes for the verifier: which side was selected and whether
+// the result is truthy. With the operator (known from the manifest) this gives
+// each operand's outcome. The branch id is cut from the outcome's id -- its
+// short or right id, which share it -- once, not on every evaluation.
+function recordSelectionOutcome(id, outcome) {
+  let branchId = selectionBranchIds.get(id);
+  if (branchId === void 0) {
+    const separator = id.lastIndexOf(":");
+    branchId = separator > 0 ? id.slice(0, separator) : null;
+    selectionBranchIds.set(id, branchId);
+  }
+  if (branchId === null)
+    return;
+  let vectors = state.logicals.get(branchId);
+  if (!vectors) {
+    vectors = /* @__PURE__ */ new Map();
+    state.logicals.set(branchId, vectors);
+  }
+  const key = selectionOutcomeKeys[outcome];
+  if (!vectors.has(key)) {
+    vectors.set(key, { right: outcome >= 2, truthy: (outcome & 1) === 1 });
+    workerEvidenceChanged();
+  }
+}
 // A JSX expression container has nowhere to put a statement and cannot hold a
 // bare comma operator, so a rendered expression carries its probe as a call
 // that returns the value through. Like optionalSelect, it records after the
@@ -1220,6 +1591,75 @@ function optionalSelect(shortId, continuedId, value) {
   coverageHit(value === null || value === void 0 ? shortId : continuedId);
   return value;
 }
+// `a || b` (kind 0), `a && b` (1), `a ?? b` (2), with the program's own
+// operator between the two calls: the left operand records its short outcome
+// when it decides the result -- truthy, falsy, present -- and the right one
+// whether it came out truthy. The outcomes are the selection's four points.
+function selectShortV2(file, first, value, kind) {
+  if (kind === 0 ? value : kind === 1 ? !value : value !== null && value !== void 0)
+    coverageHitV2(file, value ? first + 1 : first);
+  return value;
+}
+function selectRightV2(file, first, value) {
+  coverageHitV2(file, value ? first + 3 : first + 2);
+  return value;
+}
+// A leaf of nested selections, `(a && b) || c`: the program's operators stay
+// between the leaves, so a coverage tool the tests run flattens them into the
+// one branch it reads without Supercov. Each step after the value names a
+// selection above the leaf, nearest first, as `first * 4 + code`: code 3 when
+// the leaf is on its right side, which records that side's outcome, and the
+// operator's kind (0 `||`, 1 `&&`, 2 `??`) when on its left, which records the
+// short outcome when the value decides it; otherwise the selection goes on to
+// its right side, and the leaf decides nothing further up.
+function selectPathV2(file, value) {
+  for (let index = 2; index < arguments.length; index += 1) {
+    const step = arguments[index];
+    const code = step & 3;
+    const first = (step - code) / 4;
+    if (code === 3)
+      coverageHitV2(file, value ? first + 3 : first + 2);
+    else if (code === 0 ? value : code === 1 ? !value : value !== null && value !== void 0)
+      coverageHitV2(file, value ? first + 1 : first);
+    else
+      break;
+  }
+  return value;
+}
+// `x ||= y`, `x &&= y`, `x ??= y` keep their operator and their single
+// evaluation of the target: the right side goes through selectRightV2 (or the
+// named form, for an anonymous function the assignment would have named), and
+// a site temporary set to 1 after it tells the end whether the assignment was
+// skipped, which is then the short outcome for the value the target kept.
+function selectNamedRightV2(file, first, value, inferredName) {
+  coverageHitV2(file, value ? first + 3 : first + 2);
+  return applyInferredName(value, inferredName);
+}
+function selectAssignEndV2(file, first, value, right) {
+  if (!right)
+    coverageHitV2(file, value ? first + 1 : first);
+  return value;
+}
+// `object?.member`: the short and continued outcomes are two V2 points.
+// Whether the previous optional link of the chain being evaluated cut it
+// short. In `a?.b?.c` the object of `?.c` is undefined when `a` is, though
+// `?.c` never ran: `?.b` says so here and `?.c` records nothing. `links` has
+// 1 when an earlier link of the chain runs first and 2 when a later one
+// follows. Every link with a later one writes this and that later one reads
+// and clears it, so code run in between -- a getter, a call -- that
+// evaluates chains of its own leaves it as it found it. 4 means the earlier
+// link is an optional call, whose frame `call` is 2 only if it went ahead.
+var optionalChainCut = false;
+function optionalSelectV2(file, first, value, links, call) {
+  if (links & 1 && optionalChainCut || links & 4 && call !== 2) {
+    optionalChainCut = (links & 2) !== 0;
+    return value;
+  }
+  var nullish = value === null || value === void 0;
+  coverageHitV2(file, nullish ? first : first + 1);
+  optionalChainCut = nullish && (links & 2) !== 0;
+  return value;
+}
 function optionalCallBegin(shortId, continuedId) {
   return { shortId, continuedId, reached: false, continued: false };
 }
@@ -1227,13 +1667,17 @@ function optionalCallReached(frame, value) {
   frame.reached = true;
   return value;
 }
+// Spread into an optional call's arguments to mark that the call went ahead:
+// it yields nothing, and allocates nothing per call.
+var optionalCallDone = { done: true, value: void 0 };
+var optionalCallEmptyIterator = {
+  next() {
+    return optionalCallDone;
+  }
+};
 var optionalCallEmptySpread = {
   [Symbol.iterator]() {
-    return {
-      next() {
-        return { done: true, value: void 0 };
-      }
-    };
+    return optionalCallEmptyIterator;
   }
 };
 function optionalCallContinued(frame) {
@@ -1245,6 +1689,13 @@ function optionalCallEnd(frame, value) {
     coverageHit(frame.continued ? frame.continuedId : frame.shortId);
   return value;
 }
+// The site's state, read after the chain: 0 not reached, 1 reached and
+// short-circuited, 2 called. Short and continued are two V2 points.
+function optionalCallEndV2(file, first, value, state) {
+  if (state)
+    coverageHitV2(file, state === 2 ? first + 1 : first);
+  return value;
+}
 function defaultSelected(defaultId, value, inferredName) {
   var _a8;
   pendingDefaults.set(defaultId, ((_a8 = pendingDefaults.get(defaultId)) != null ? _a8 : 0) + 1);
@@ -1260,6 +1711,24 @@ function defaultEntered(defaultId, providedId) {
     coverageHit(providedId);
   }
 }
+// The same count per default, in a slot of the file's typed array instead of
+// a Map keyed by the default's id, and the outcome recorded through the V2
+// point check, which ends at one comparison once it fired in this context.
+// lru-cache's set and get destructure options with defaults: the Map and the
+// two calls behind each were a third of a hot loop.
+function defaultSelectedV2(file, slot, value, inferredName) {
+  file.pendingDefaults[slot] += 1;
+  return inferredName ? applyInferredName(value, inferredName) : value;
+}
+function defaultEnteredV2(file, slot, defaultPoint, providedPoint) {
+  const pending = file.pendingDefaults;
+  if (pending[slot] > 0) {
+    pending[slot] -= 1;
+    coverageHitV2(file, defaultPoint);
+  } else {
+    coverageHitV2(file, providedPoint);
+  }
+}
 function tryBegin(successId, catchId) {
   return { successId, catchId, caught: false };
 }
@@ -1349,7 +1818,9 @@ const directRuntimeApi = {
   coverageSnapshot,
   decodeProbeV2Vector,
   defaultEntered,
+  defaultEnteredV2,
   defaultSelected,
+  defaultSelectedV2,
   enableRuntimeSnapshotEvidence,
   flushBufferedBackgroundEvidence,
   flushBufferedServerEvidence,
@@ -1364,7 +1835,9 @@ const directRuntimeApi = {
   optionalCallContinued,
   optionalCallEnd,
   optionalCallReached,
+  optionalCallEndV2,
   optionalSelect,
+  optionalSelectV2,
   renderedValueV2,
   parenthesizedAssignmentValue,
   phaseBelongsToAttempt,
@@ -1373,6 +1846,11 @@ const directRuntimeApi = {
   selectionBegin,
   selectionEnd,
   selectionRight,
+  selectShortV2,
+  selectRightV2,
+  selectNamedRightV2,
+  selectAssignEndV2,
+  selectPathV2,
   takeNodeAssertionPhases,
   tryBegin,
   tryCatch,
@@ -1380,12 +1858,14 @@ const directRuntimeApi = {
   withCoverageCarrier,
   withNodeAssertionPhase,
   bindNodeAssertionPhase,
+  openNodeAssertionPhase,
   withRequestPhase,
   writeExclusiveBackgroundRecord
 };
-globalThis.__SUPERCOV_DIRECT_RUNTIME__ ??= directRuntimeApi;
-if (typeof process !== "undefined")
-  process.__SUPERCOV_DIRECT_RUNTIME__ ??= directRuntimeApi;
+if (globalThis.__SUPERCOV_DIRECT_RUNTIME__ == null)
+  globalThis.__SUPERCOV_DIRECT_RUNTIME__ = directRuntimeApi;
+if (typeof process !== "undefined" && process.__SUPERCOV_DIRECT_RUNTIME__ == null)
+  process.__SUPERCOV_DIRECT_RUNTIME__ = directRuntimeApi;
 export {
   activateCoverageScope,
   beginBufferedServerEvidence,
@@ -1399,7 +1879,9 @@ export {
   coverageSnapshot,
   decodeProbeV2Vector,
   defaultEntered,
+  defaultEnteredV2,
   defaultSelected,
+  defaultSelectedV2,
   enableRuntimeSnapshotEvidence,
   flushBufferedBackgroundEvidence,
   flushBufferedServerEvidence,
@@ -1415,7 +1897,9 @@ export {
   optionalCallContinued,
   optionalCallEnd,
   optionalCallReached,
+  optionalCallEndV2,
   optionalSelect,
+  optionalSelectV2,
   renderedValueV2,
   parenthesizedAssignmentValue,
   phaseBelongsToAttempt,
@@ -1424,6 +1908,11 @@ export {
   selectionBegin,
   selectionEnd,
   selectionRight,
+  selectShortV2,
+  selectRightV2,
+  selectNamedRightV2,
+  selectAssignEndV2,
+  selectPathV2,
   takeNodeAssertionPhases,
   tryBegin,
   tryCatch,
@@ -1431,6 +1920,7 @@ export {
   withCoverageCarrier,
   withNodeAssertionPhase,
   bindNodeAssertionPhase,
+  openNodeAssertionPhase,
   withRequestPhase,
   writeExclusiveBackgroundRecord
 };