supercov 4.24.7 → 4.25.0

package/runtime/javascript/runtime.mjs

@@ -37,7 +37,8 @@ var COVERAGE_CARRIER_ENV = "SUPERCOV_CONTEXT";
 var DEFAULT_SERVER_EVIDENCE_ROOT = "/tmp/supercov-server-evidence";
 function configuredServerEvidenceRoot() {
   var _a8;
-  return typeof process !== "undefined" && ((_a8 = process.env) == null ? void 0 : _a8["SUPERCOV_SERVER_EVIDENCE_ROOT"]) ? process.env["SUPERCOV_SERVER_EVIDENCE_ROOT"] : DEFAULT_SERVER_EVIDENCE_ROOT;
+  const configured = typeof process !== "undefined" ? (_a8 = process.env) == null ? void 0 : _a8["SUPERCOV_SERVER_EVIDENCE_ROOT"] : void 0;
+  return configured ? configured : DEFAULT_SERVER_EVIDENCE_ROOT;
 }
 function nonEmpty(value) {
   return typeof value === "string" && value.length > 0;
@@ -117,6 +118,18 @@ function serverEvidenceDirectory(scope, root = configuredServerEvidenceRoot()) {
 function serverEvidencePath(scope, root = configuredServerEvidenceRoot()) {
   return `${serverEvidenceDirectory(scope, root)}/${pathComponent(scope.attemptId)}.jsonl`;
 }
+// A scope's evidence directory and file, made once per scope and root: a
+// server works them out for every record it writes, thousands per test.
+var scopedEvidenceLocations = /* @__PURE__ */ new WeakMap();
+function scopedEvidenceLocation(scope) {
+  const root = configuredServerEvidenceRoot();
+  const known = scopedEvidenceLocations.get(scope);
+  if (known !== void 0 && known.root === root)
+    return known;
+  const location = { root, directory: serverEvidenceDirectory(scope, root), path: serverEvidencePath(scope, root) };
+  scopedEvidenceLocations.set(scope, location);
+  return location;
+}
 function backgroundEvidenceDirectory(runId, root = configuredServerEvidenceRoot()) {
   return `${serverRunEvidenceDirectory(runId, root)}/background`;
 }
@@ -241,6 +254,7 @@ function activateProbeV2Key(key, force = false) {
     if (state.probeV2NextEpoch >= 4294967295) {
       state.probeV2NextEpoch = 1;
       state.probeV2ContextEpochs.clear();
+      state.probeV2EpochGeneration = (state.probeV2EpochGeneration || 0) + 1;
       for (const file of state.probeV2Files) {
         file.hitEpochs.fill(0);
         file.decisionObservationEpochs.fill(0);
@@ -260,8 +274,38 @@ function activateProbeV2Key(key, force = false) {
   state.probeV2Clock.epoch = epoch;
   return epoch;
 }
+// The async hook activates the current request's context before every
+// callback the server runs, and building its key and looking it up was most of
+// a Next server's time in the hook. A request's context object is never
+// changed once made, and its key is made of it alone, so each keeps the epoch
+// it was given until the epochs are cleared.
+// Every copy of the runtime in a process shares one state, and the hook is the
+// first copy's, so the cache and its generation live on that state too: a
+// reset from another copy has to reach them.
+var emptyProbeV2Context = Object.freeze({});
 function activateProbeV2Context(context) {
-  return activateProbeV2Key(probeV2ContextKey(context));
+  // Work no request owns is keyed by the test running when it runs, which
+  // changes under the same context: only a request's context keeps its epoch.
+  if (!context.scope)
+    return activateProbeV2Key(probeV2ContextKey(context));
+  if (state.probeV2ContextEpochCache === void 0) {
+    state.probeV2ContextEpochCache = /* @__PURE__ */ new WeakMap();
+    state.probeV2EpochGeneration = 0;
+  }
+  const cached = state.probeV2ContextEpochCache.get(context);
+  if (cached !== void 0 && cached.generation === state.probeV2EpochGeneration) {
+    state.probeV2Clock.epoch = cached.epoch;
+    return cached.epoch;
+  }
+  const epoch = activateProbeV2Key(probeV2ContextKey(context));
+  state.probeV2ContextEpochCache.set(context, { generation: state.probeV2EpochGeneration, epoch });
+  return epoch;
+}
+// The context the async hook leaves to a callback's first probe: the
+// request's store, or else the one the environment carries.
+function resolveProbeV2Epoch() {
+  var _a8, _b;
+  return activateProbeV2Context((_b = (_a8 = serverPhaseStorage == null ? void 0 : serverPhaseStorage.getStore()) != null ? _a8 : environmentRequestContext()) != null ? _b : emptyProbeV2Context);
 }
 function withProbeV2Context(context, callback) {
   const previous = state.probeV2Clock.epoch;
@@ -283,10 +327,14 @@ function installProbeV2AsyncHook() {
       return;
     const epochs = [];
     createHook({
+      // NaN, which no epoch equals: the callback's first probe works out
+      // its context. Most callbacks a server or a test runner runs reach no
+      // instrumented code, and working it out here, for every one, read the
+      // environment twice and built a key each time: on a Next app's suite,
+      // more of the server's time than any of Supercov's other work.
       before() {
-        var _a9, _b;
         epochs.push(state.probeV2Clock.epoch);
-        activateProbeV2Context((_b = (_a9 = serverPhaseStorage == null ? void 0 : serverPhaseStorage.getStore()) != null ? _a9 : environmentRequestContext()) != null ? _b : {});
+        state.probeV2Clock.epoch = NaN;
       },
       after() {
         var _a9;
@@ -329,6 +377,7 @@ function resetCoverage(testId2) {
   state.logicals.clear();
   state.eventKeys.clear();
   state.probeV2ContextEpochs.clear();
+  state.probeV2EpochGeneration = (state.probeV2EpochGeneration || 0) + 1;
   activateProbeV2Key(`reset\0${state.probeV2NextEpoch}`, true);
   if (testId2)
     runtimeGlobal.__SUPERCOV_MCDC_TEST_ID__ = testId2;
@@ -341,6 +390,78 @@ function resetCoverage(testId2) {
 }
 runtimeGlobal.__SUPERCOV_MCDC_SNAPSHOT__ = decisionSnapshot;
 runtimeGlobal.__SUPERCOV_COVERAGE_SNAPSHOT__ = coverageSnapshot;
+// A snapshot as the text the Playwright collector reads back. Its events
+// become rows over one table of the strings they repeat -- point ids, phase
+// ids, kinds -- each row in the key order of its event (`shapes`), and its
+// hits indexes into the same table; snapshots.mjs's expandSnapshot gives
+// back what JSON.parse of the whole would have. A large frontend's page
+// holds tens of thousands of events, each naming its point, phase and
+// environment in full, read back at the end of every test and from every
+// page that leaves: relaying them cost the browser's own process more than
+// its renderers spent running the app.
+function compactSnapshotText(snapshot) {
+  if (!snapshot || typeof snapshot !== "object" || !Array.isArray(snapshot.events) || !Array.isArray(snapshot.hits))
+    return JSON.stringify(snapshot);
+  const strings = [];
+  const stringIndexes = /* @__PURE__ */ new Map();
+  const intern = (value) => {
+    let index = stringIndexes.get(value);
+    if (index === void 0) {
+      index = strings.length;
+      strings.push(value);
+      stringIndexes.set(value, index);
+    }
+    return index;
+  };
+  const shapes = [];
+  const shapeIndexes = /* @__PURE__ */ new Map();
+  const rows = [];
+  for (let position = 0; position < snapshot.events.length; position += 1) {
+    const event = snapshot.events[position];
+    if (!event || typeof event !== "object" || Array.isArray(event))
+      return JSON.stringify(snapshot);
+    const fields = [];
+    const values = [];
+    const keys = Object.keys(event);
+    for (let index = 0; index < keys.length; index += 1) {
+      const value = event[keys[index]];
+      // What JSON.stringify leaves out of an object.
+      if (value === void 0 || typeof value === "function" || typeof value === "symbol")
+        continue;
+      if (typeof value === "string") {
+        fields.push(`s${keys[index]}`);
+        values.push(intern(value));
+      } else {
+        fields.push(`v${keys[index]}`);
+        values.push(value);
+      }
+    }
+    const name = fields.join("\0");
+    let shape = shapeIndexes.get(name);
+    if (shape === void 0) {
+      shape = shapes.length;
+      shapes.push(fields);
+      shapeIndexes.set(name, shape);
+    }
+    rows.push(shape);
+    for (let index = 0; index < values.length; index += 1)
+      rows.push(values[index]);
+  }
+  const hits = [];
+  for (let index = 0; index < snapshot.hits.length; index += 1) {
+    if (typeof snapshot.hits[index] !== "string")
+      return JSON.stringify(snapshot);
+    hits.push(intern(snapshot.hits[index]));
+  }
+  const rest = {};
+  const keys = Object.keys(snapshot);
+  for (let index = 0; index < keys.length; index += 1) {
+    if (keys[index] !== "events" && keys[index] !== "hits")
+      rest[keys[index]] = snapshot[keys[index]];
+  }
+  return JSON.stringify({ supercovCompactSnapshot: 1, order: keys, rest, strings, shapes, rows, hits });
+}
+runtimeGlobal.__SUPERCOV_COMPACT_SNAPSHOT__ = compactSnapshotText;
 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
@@ -417,11 +538,32 @@ function pushWorkerEvidence() {
   runtimeGlobal.__SUPERCOV_WORKER_EVIDENCE__ = () => Array.from(received, ([token, pushed]) => ({ token, url: pushed.url, current: pushed.current, snapshot: pushed.snapshot }));
 })();
 var persistBrowserListenersInstalled = false;
+// How much evidence the document holds. Every part of it only grows until a
+// reset, so the same size twice is the same evidence.
+function evidenceSize() {
+  let size = state.hits.size + state.events.length;
+  for (const decision of state.decisions.values())
+    size += decision.vectors.size;
+  for (const vectors of state.logicals.values())
+    size += vectors.size;
+  return size;
+}
+// The evidence's size when this document gave it to the Playwright collector
+// on the way out. Its next document need not inherit it then: carried through
+// localStorage as well, every page of a test parsed all the evidence of the
+// pages before it on load and wrote it all again on leaving, a test of thirty
+// pages paying for the first one thirty times, and the collector merged the
+// same evidence once per page. What runs after the hand-over -- the rest of a
+// handler that set `location.href`, a render it started -- is still carried.
+var handedOverSize = -1;
 function persistBrowserNow() {
   if (!isBrowser)
     return;
   try {
-    localStorage.setItem(storageKey, JSON.stringify(coverageSnapshot()));
+    if (handedOverSize === evidenceSize())
+      localStorage.removeItem(storageKey);
+    else
+      localStorage.setItem(storageKey, JSON.stringify(coverageSnapshot()));
   } catch (e) {
   }
 }
@@ -433,8 +575,10 @@ function persistBrowserNow() {
 // it does.
 function handOverBrowser() {
   try {
-    if (typeof runtimeGlobal.__supercovLeaving === "function")
-      runtimeGlobal.__supercovLeaving(JSON.stringify(coverageSnapshot()));
+    if (typeof runtimeGlobal.__supercovLeaving === "function") {
+      runtimeGlobal.__supercovLeaving(compactSnapshotText(coverageSnapshot()));
+      handedOverSize = evidenceSize();
+    }
   } catch (e) {
   }
 }
@@ -468,6 +612,19 @@ function persistBrowser() {
 function attemptKey(scope) {
   return `${scope.runId}\0${scope.workerId}\0${scope.attemptId}`;
 }
+// An attempt's file says its scope once per writing process: each line
+// without one is of the scope of the line before it in the same file.
+var scopedPathsWritten = /* @__PURE__ */ new Set();
+function serverLine(record, path) {
+  if (!path)
+    return JSON.stringify(record);
+  const { scope, ...line } = record;
+  if (scope && !scopedPathsWritten.has(path)) {
+    scopedPathsWritten.add(path);
+    line.scope = scope;
+  }
+  return JSON.stringify(line);
+}
 function serverRecordKey(record) {
   var _a8;
   const suffix = record.type === "decision" ? `${record.id}:${vectorKey(record.vector)}` : record.id;
@@ -530,7 +687,7 @@ function flushBufferedServerEvidence(scope) {
     return void 0;
   try {
     makeEvidenceDirectory(fs, buffered.directory);
-    fs.appendFileSync(buffered.path, [...buffered.records.values()].map((record) => JSON.stringify(record)).join("\n") + "\n");
+    fs.appendFileSync(buffered.path, [...buffered.records.values()].map((record) => serverLine(record, buffered.path)).join("\n") + "\n");
     return buffered.path;
   } catch (e) {
     return void 0;
@@ -758,7 +915,8 @@ function flushOnTermination(flush) {
     }
   } catch (e) {
   }
-  for (const signal of ["SIGTERM", "SIGINT", "SIGHUP", "SIGBREAK"]) {
+  const signals = ["SIGTERM", "SIGINT", "SIGHUP", "SIGBREAK"];
+  for (const signal of signals) {
     try {
       process.on(signal, () => {
         drain();
@@ -770,6 +928,24 @@ function flushOnTermination(flush) {
     } catch (e) {
     }
   }
+  // A listener keeps nothing alive, and a signal a process sends itself is
+  // handled on a later turn of its event loop: `process.kill(process.pid,
+  // "SIGTERM")` as a script's last line exited 0, once nothing else held the
+  // loop open, where alone it ended by the signal. A signal to itself that
+  // only this listener would take is drained and left to act at once.
+  try {
+    const kill = process.kill;
+    const numbered = { 1: "SIGHUP", 2: "SIGINT", 15: "SIGTERM", 21: "SIGBREAK" };
+    process.kill = function supercovKill(pid, signal) {
+      const name = signal === void 0 ? "SIGTERM" : typeof signal === "number" ? numbered[signal] : signal;
+      if (Number(pid) === process.pid && signals.indexOf(name) >= 0 && process.listenerCount(name) <= 1) {
+        drain();
+        process.removeAllListeners(name);
+      }
+      return kill.apply(this, arguments);
+    };
+  } catch (e) {
+  }
 }
 // Rust compiled to wasm and measured by the Rust frontend keeps what it ran
 // in the module's memory, behind `__supercov_region_<crate>`. When the run
@@ -1024,8 +1200,9 @@ function appendServer(record) {
   if (!runId)
     return;
   try {
-    const directory = scope ? serverEvidenceDirectory(scope) : void 0;
-    const path = scope ? serverEvidencePath(scope) : void 0;
+    const location = scope ? scopedEvidenceLocation(scope) : void 0;
+    const directory = location == null ? void 0 : location.directory;
+    const path = location == null ? void 0 : location.path;
     // Work done while handling a request that named no test -- a webhook a
     // mock server sends -- says so, with the request's number.
     const stored = serverPhaseStorage == null ? void 0 : serverPhaseStorage.getStore();
@@ -1050,7 +1227,7 @@ function appendServer(record) {
       appendDurableBackgroundRecord(fs, runId, serialized);
       return;
     }
-    enqueueServerAppend(directory, path, JSON.stringify(serialized) + "\n", runId);
+    enqueueServerAppend(directory, path, serverLine(serialized, path) + "\n", runId);
     if (deduplicationKey)
       state.persistedServerRecords.add(deduplicationKey);
   } catch (cause) {
@@ -1639,13 +1816,24 @@ function noteSupport(scope) {
     const moduleBuiltin = typeof process.getBuiltinModule === "function" ? process.getBuiltinModule("node:module") : void 0;
     const cache = moduleBuiltin && moduleBuiltin._cache;
     const root = process.env.SUPERCOV_PROJECT_ROOT;
-    if (cache && root) {
+    // The in-thread module hooks count every load (resolve-loader.mjs): a
+    // cache nothing was loaded into since the last request holds nothing
+    // new. Listing a Next server's thousands of keys on every request was
+    // the most of its time any of Supercov's code took. Without the count
+    // (off-thread hooks), every request looks.
+    const loads = runtimeGlobal.__SUPERCOV_MODULE_LOADS__;
+    const unchanged = typeof loads === "number" && loads === supportNoted.loads;
+    supportNoted.loads = loads;
+    if (cache && root && !unchanged) {
       for (const name of Object.keys(cache)) {
+        // Each is looked at once, whether it is noted or not.
+        if (supportNoted.modules.has(name))
+          continue;
+        supportNoted.modules.add(name);
         // The copy lives under `.supercov/`: the project root decides.
         const inside = name.indexOf(root) === 0 ? name.slice(root.length).replace(/^[\\/]/, "") : "";
-        if (supportNoted.modules.has(name) || inside === "" || /^\.supercov[\\/]/.test(inside) || /(?:^|[\\/])node_modules[\\/]/.test(inside))
+        if (inside === "" || /^\.supercov[\\/]/.test(inside) || /(?:^|[\\/])node_modules[\\/]/.test(inside))
           continue;
-        supportNoted.modules.add(name);
         lines.push({ loaded: name });
       }
     }
@@ -1789,6 +1977,8 @@ function recordCoverageHit(id) {
     activateProbeV2Context(currentRequestContext());
     epoch = clock.epoch;
     clock.epoch = previousEpoch;
+  } else if (epoch !== epoch) {
+    epoch = resolveProbeV2Epoch();
   }
   if (!state.hitEpochs)
     state.hitEpochs = /* @__PURE__ */ new Map();
@@ -1814,24 +2004,31 @@ function recordCoverageHit(id) {
     }, phaseId ? { phaseId } : {}));
   }
 }
+// A file's ids, as the instrumenter writes them: one string of ids separated
+// by spaces, or a list where an id holds one.
+function listedIds(ids) {
+  return typeof ids === "string" ? ids === "" ? [] : ids.split(" ") : ids;
+}
 function registerProbeV2(definition) {
   var _a8, _b;
+  const decisions = listedIds(definition.decisions);
+  const pointIds = listedIds(definition.pointIds);
   const file = {
     // Each decision's id and its number of conditions: the module carries
     // no source text, which the manifest holds.
-    decisions: definition.decisions,
+    decisions,
     decisionWidths: definition.decisionWidths,
-    pointIds: definition.pointIds,
+    pointIds,
     clock: state.probeV2Clock,
-    hitEpochs: new Uint32Array(definition.pointIds.length),
+    hitEpochs: new Uint32Array(pointIds.length),
     decisionEpochs: definition.decisionWidths.map((width) => width <= 6 ? new Uint32Array(2 * 3 ** width) : /* @__PURE__ */ new Map()),
-    decisionVectorCounts: definition.decisions.map((_, index) => {
+    decisionVectorCounts: decisions.map((_, index) => {
       var _a9, _b2;
       return (_b2 = (_a9 = definition.decisionVectorCounts) == null ? void 0 : _a9[index]) != null ? _b2 : 0;
     }),
-    decisionObservationEpochs: new Uint32Array(definition.decisions.length),
-    decisionObservationCounts: new Uint16Array(definition.decisions.length),
-    decisionCompleteEpochs: new Uint32Array(definition.decisions.length),
+    decisionObservationEpochs: new Uint32Array(decisions.length),
+    decisionObservationCounts: new Uint16Array(decisions.length),
+    decisionCompleteEpochs: new Uint32Array(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.
@@ -1876,6 +2073,8 @@ function recordCoverageHitV2(file, index) {
   const previousEpoch = file.clock.epoch;
   if (fallbackEpoch)
     activateProbeV2Context(currentRequestContext());
+  else if (previousEpoch !== previousEpoch)
+    resolveProbeV2Epoch();
   try {
     const epoch = file.clock.epoch;
     if (file.hitEpochs[index] === epoch)
@@ -1928,6 +2127,8 @@ function recordMcdcEndV2(file, decisionIndex, encoded, value) {
   const previousEpoch = file.clock.epoch;
   if (fallbackEpoch)
     activateProbeV2Context(currentRequestContext());
+  else if (previousEpoch !== previousEpoch)
+    resolveProbeV2Epoch();
   try {
     const epoch = file.clock.epoch;
     const seen = file.decisionEpochs[decisionIndex];

package/runtime/javascript/snapshots.mjs

@@ -0,0 +1,108 @@
+/**
+ * Two events JSON.stringify would write alike: the same keys in the same
+ * order, with the same values. Comparing is several times cheaper than
+ * writing both, and a test's pages hand over thousands of events each time
+ * one of them leaves.
+ */
+function sameEvent(left, right) {
+    if (left === right)
+        return true;
+    if (left === null || right === null || typeof left !== "object" || typeof right !== "object")
+        return false;
+    const leftKeys = Object.keys(left);
+    const rightKeys = Object.keys(right);
+    if (leftKeys.length !== rightKeys.length)
+        return false;
+    for (let index = 0; index < leftKeys.length; index += 1) {
+        const key = leftKeys[index];
+        if (key !== rightKeys[index])
+            return false;
+        const leftValue = left[key];
+        const rightValue = right[key];
+        if (leftValue === rightValue)
+            continue;
+        if (leftValue === null || rightValue === null || typeof leftValue !== "object" || typeof rightValue !== "object" ||
+            JSON.stringify(leftValue) !== JSON.stringify(rightValue))
+            return false;
+    }
+    return true;
+}
+/**
+ * One snapshot holding everything in `snapshots`, each observation once: a
+ * document that left gave its evidence, and the next one on its origin
+ * restored the same evidence and added to it.
+ */
+export function mergeSnapshots(snapshots) {
+    const hits = new Set();
+    const events = new Map();
+    const decisions = new Map();
+    const logicals = new Map();
+    const vectorsOf = (map, key, initial) => {
+        let entry = map.get(key);
+        if (!entry) {
+            entry = { ...initial, seen: new Map() };
+            map.set(key, entry);
+        }
+        return entry;
+    };
+    let previousEvents;
+    for (const snapshot of snapshots) {
+        for (const id of snapshot?.hits ?? [])
+            hits.add(id);
+        // A document restores the evidence the one before it on its origin
+        // left, in order, before adding its own: the events it repeats from
+        // the snapshot before are in `events` already, and are compared
+        // instead of serialized.
+        const list = snapshot?.events ?? [];
+        let start = 0;
+        if (previousEvents !== undefined) {
+            const shared = Math.min(previousEvents.length, list.length);
+            while (start < shared && sameEvent(previousEvents[start], list[start]))
+                start += 1;
+        }
+        for (let index = start; index < list.length; index += 1)
+            events.set(JSON.stringify(list[index]), list[index]);
+        previousEvents = list;
+        for (const decision of snapshot?.decisions ?? []) {
+            const entry = vectorsOf(decisions, decision.id, { id: decision.id });
+            for (const vector of decision.vectors ?? [])
+                entry.seen.set(JSON.stringify(vector), vector);
+        }
+        for (const logical of snapshot?.logicals ?? []) {
+            const entry = vectorsOf(logicals, logical.id, { id: logical.id });
+            for (const vector of logical.vectors ?? [])
+                entry.seen.set(JSON.stringify(vector), vector);
+        }
+    }
+    return {
+        decisions: [...decisions.values()].map(({ seen, id }) => ({ id, vectors: [...seen.values()] })),
+        hits: [...hits],
+        events: [...events.values()],
+        logicals: [...logicals.values()].map(({ seen, id }) => ({ id, vectors: [...seen.values()] })),
+    };
+}
+/**
+ * A snapshot as JSON.parse would give it from the text a page's runtime
+ * wrote compactly (runtime.mjs, compactSnapshotText): each event in its own
+ * key order, its strings from the shared table. Anything else is returned
+ * as it is.
+ */
+export function expandSnapshot(value) {
+    if (!value || typeof value !== "object" || value.supercovCompactSnapshot !== 1)
+        return value;
+    const { order, rest, strings, shapes, rows, hits } = value;
+    const events = [];
+    for (let position = 0; position < rows.length;) {
+        const fields = shapes[rows[position++]];
+        const event = {};
+        for (const field of fields) {
+            const raw = rows[position++];
+            event[field.slice(1)] = field[0] === "s" ? strings[raw] : raw;
+        }
+        events.push(event);
+    }
+    const snapshot = {};
+    for (const key of order)
+        snapshot[key] = key === "events" ? events : key === "hits" ? hits.map((index) => strings[index]) : rest[key];
+    return snapshot;
+}

package/runtime/javascript/transport.mjs

@@ -7,6 +7,42 @@ export const COVERAGE_PHASE_COOKIE = "__supercov_phase";
 // so the two cannot be one.
 export const COVERAGE_SCOPE_SITE_COOKIE = "__supercov_scope_site";
 export const COVERAGE_PHASE_SITE_COOKIE = "__supercov_phase_site";
+// The phase a new document starts in: the last action's, since a document
+// loads because of one (a navigation, a click that navigates). An assertion
+// that starts while it loads does not change it.
+export const COVERAGE_DOCUMENT_PHASE_COOKIE = "__supercov_document_phase";
+export const COVERAGE_DOCUMENT_PHASE_SITE_COOKIE = "__supercov_document_phase_site";
+/**
+ * Runs at the start of every document of a context, as an init script, so it
+ * reads nothing from this module. A document starts in the phase its cookie
+ * names. Only this attempt's phase is taken: a copy of the script that a
+ * context kept from an earlier test leaves a later test's phase alone.
+ */
+export function startDocumentInPhase({ attemptId, phaseCookie, phaseSiteCookie }) {
+    try {
+        let phase;
+        for (const part of document.cookie.split(";")) {
+            const at = part.indexOf("=");
+            const name = part.slice(0, at).trim();
+            if (name !== phaseCookie && name !== phaseSiteCookie)
+                continue;
+            const value = decodeURIComponent(part.slice(at + 1));
+            if (!value.startsWith(`${attemptId}:`))
+                continue;
+            phase = value;
+            if (name === phaseCookie)
+                break;
+        }
+        if (!phase)
+            return;
+        const coverageGlobal = globalThis;
+        coverageGlobal.__SUPERCOV_PHASE_ID__ = phase;
+        coverageGlobal.__SUPERCOV_ACTIVATE_PROBE_CONTEXT__?.(coverageGlobal.__SUPERCOV_MCDC_TEST_ID__ ?? "unscoped", phase);
+    }
+    catch {
+        // A document that cannot read cookies keeps its stored phase.
+    }
+}
 export const COVERAGE_CARRIER_ENV = "SUPERCOV_CONTEXT";
 export const DEFAULT_SERVER_EVIDENCE_ROOT = "/tmp/supercov-server-evidence";
 // Buffer as it was when Supercov loaded. Tests replace globals -- axios's set