supercov 0.0.7 → 0.0.9

package/dist/runtime.js

@@ -1,591 +1,778 @@
-import { backgroundEvidenceDirectory, backgroundEvidencePath, COVERAGE_CARRIER_ENV, COVERAGE_PHASE_HEADER, COVERAGE_PHASE_COOKIE, COVERAGE_SCOPE_COOKIE, COVERAGE_SCOPE_HEADER, decodeCoverageCarrier, decodeCoverageScope, encodeCoverageCarrier, encodeCoverageScope, serverEvidenceDirectory, serverEvidencePath, } from "./transport.js";
-const runtimeGlobal = globalThis;
-const runtimeInstanceToken = "__SUPERCOV_RUNTIME_INSTANCE__";
-const runtimeInstance = runtimeInstanceToken === "__SUPERCOV_" + "RUNTIME_INSTANCE__"
-    ? "application"
-    : runtimeInstanceToken;
-const isBrowser = !(typeof process !== "undefined" &&
-    typeof process.versions?.node === "string");
-const testId = runtimeGlobal.__SUPERCOV_MCDC_TEST_ID__ ?? "unscoped";
-const storageKey = "__supercov_coverage_" + testId;
-const phaseStorageKey = "__supercov_phase";
-const pendingDefaults = new Map();
+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;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+
+// dist/transport.js
+var COVERAGE_SCOPE_HEADER = "x-supercov-scope";
+var COVERAGE_PHASE_HEADER = "x-supercov-phase";
+var COVERAGE_SCOPE_COOKIE = "__supercov_scope";
+var COVERAGE_PHASE_COOKIE = "__supercov_phase";
+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;
+}
+function nonEmpty(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function safeKey(value) {
+  return /^[a-zA-Z0-9_-]+$/.test(value);
+}
+function pathComponent(value) {
+  const safe = value.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return safe || "unscoped";
+}
+function encodeCoverageScope(scope) {
+  return new URLSearchParams({
+    v: String(scope.version),
+    r: scope.runId,
+    w: scope.workerId,
+    t: scope.testId,
+    k: scope.testKey,
+    a: String(scope.retry),
+    i: scope.attemptId
+  }).toString();
+}
+function decodeCoverageScope(encoded) {
+  if (!encoded)
+    return void 0;
+  try {
+    const values = new URLSearchParams(encoded);
+    const runId = values.get("r");
+    const workerId = values.get("w");
+    const testId2 = values.get("t");
+    const testKey = values.get("k");
+    const attemptId = values.get("i");
+    const retry = Number(values.get("a"));
+    if (values.get("v") !== "1" || !nonEmpty(runId) || !nonEmpty(workerId) || !nonEmpty(testId2) || !nonEmpty(testKey) || !safeKey(testKey) || !nonEmpty(attemptId) || !safeKey(attemptId) || !Number.isSafeInteger(retry) || retry < 0)
+      return void 0;
+    return {
+      version: 1,
+      runId,
+      workerId,
+      testId: testId2,
+      testKey,
+      retry,
+      attemptId
+    };
+  } catch (e) {
+    return void 0;
+  }
+}
+function encodeCoverageCarrier(carrier) {
+  return Buffer.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"));
+    if (value.version !== 1)
+      return void 0;
+    if (value.scope) {
+      const roundTrip = decodeCoverageScope(encodeCoverageScope(value.scope));
+      if (!roundTrip)
+        return void 0;
+    }
+    if (value.phaseId !== void 0 && value.phaseId.length === 0)
+      return void 0;
+    return value;
+  } catch (e) {
+    return void 0;
+  }
+}
+function serverRunEvidenceDirectory(runId, root = configuredServerEvidenceRoot()) {
+  return `${root.replace(/\/+$/, "")}/${pathComponent(runId)}`;
+}
+function serverEvidenceDirectory(scope, root = configuredServerEvidenceRoot()) {
+  return `${serverRunEvidenceDirectory(scope.runId, root)}/${pathComponent(scope.workerId)}/${scope.testKey}/${scope.retry}`;
+}
+function serverEvidencePath(scope, root = configuredServerEvidenceRoot()) {
+  return `${serverEvidenceDirectory(scope, root)}/server.jsonl`;
+}
+function backgroundEvidenceDirectory(runId, root = configuredServerEvidenceRoot()) {
+  return `${serverRunEvidenceDirectory(runId, root)}/background`;
+}
+function backgroundEvidencePath(runId, processId = typeof process === "undefined" ? "unknown" : String(process.pid), root = configuredServerEvidenceRoot()) {
+  return `${backgroundEvidenceDirectory(runId, root)}/${pathComponent(processId)}.jsonl`;
+}
+
+// dist/runtime.js
+var runtimeGlobal = globalThis;
+var runtimeInstanceToken = "__SUPERCOV_RUNTIME_INSTANCE__";
+var runtimeInstance = runtimeInstanceToken === "__SUPERCOV_RUNTIME_INSTANCE__" ? "application" : runtimeInstanceToken;
+var _a;
+var isBrowser = !(typeof process !== "undefined" && typeof ((_a = process.versions) == null ? void 0 : _a.node) === "string");
+var _a2;
+var testId = (_a2 = runtimeGlobal.__SUPERCOV_MCDC_TEST_ID__) != null ? _a2 : "unscoped";
+var storageKey = "__supercov_coverage_" + testId;
+var phaseStorageKey = "__supercov_phase";
+var pendingDefaults = /* @__PURE__ */ new Map();
 function vectorKey(vector) {
-    return (vector.values
-        .map((value) => (value === null ? "-" : value ? "T" : "F"))
-        .join("") +
-        ":" +
-        (vector.outcome ? "T" : "F"));
+  return vector.values.map((value) => value === null ? "-" : value ? "T" : "F").join("") + ":" + (vector.outcome ? "T" : "F");
 }
 function getFs() {
-    if (isBrowser || typeof process === "undefined")
-        return undefined;
-    try {
-        const getBuiltinModule = process.getBuiltinModule;
-        return getBuiltinModule?.("node:fs");
-    }
-    catch {
-        return undefined;
-    }
+  if (isBrowser || typeof process === "undefined")
+    return void 0;
+  try {
+    const getBuiltinModule = process.getBuiltinModule;
+    return getBuiltinModule == null ? void 0 : getBuiltinModule("node:fs");
+  } catch (e) {
+    return void 0;
+  }
 }
 function createState() {
-    const state = {
-        decisions: new Map(),
-        hits: new Set(),
-        events: [],
-        eventKeys: new Set(),
-        bufferedAttempts: new Set(),
-        serverBuffers: new Map(),
-        runtimeSnapshots: false,
-    };
-    if (!isBrowser)
-        return state;
-    try {
-        const stored = JSON.parse(localStorage.getItem(storageKey) ?? "{}");
-        for (const snapshot of stored.decisions ?? []) {
-            state.decisions.set(snapshot.meta.id, {
-                meta: snapshot.meta,
-                vectors: new Map(snapshot.vectors.map((vector) => [vectorKey(vector), vector])),
-            });
-        }
-        for (const id of stored.hits ?? [])
-            state.hits.add(id);
-        for (const event of stored.events ?? []) {
-            state.events.push(event);
-            state.eventKeys.add(eventKey(event));
-        }
+  var _a8, _b, _c, _d;
+  const state2 = {
+    decisions: /* @__PURE__ */ new Map(),
+    hits: /* @__PURE__ */ new Set(),
+    events: [],
+    eventKeys: /* @__PURE__ */ new Set(),
+    bufferedAttempts: /* @__PURE__ */ new Set(),
+    serverBuffers: /* @__PURE__ */ new Map(),
+    persistedServerRecords: /* @__PURE__ */ new Set(),
+    backgroundSequence: 0,
+    runtimeSnapshots: false,
+    assertionPhases: /* @__PURE__ */ new Map()
+  };
+  if (!isBrowser)
+    return state2;
+  try {
+    const stored = JSON.parse((_a8 = localStorage.getItem(storageKey)) != null ? _a8 : "{}");
+    for (const snapshot of (_b = stored.decisions) != null ? _b : []) {
+      state2.decisions.set(snapshot.meta.id, {
+        meta: snapshot.meta,
+        vectors: new Map(snapshot.vectors.map((vector) => [vectorKey(vector), vector]))
+      });
     }
-    catch {
-        // Corrupt or unavailable storage must not affect application execution.
+    for (const id of (_c = stored.hits) != null ? _c : [])
+      state2.hits.add(id);
+    for (const event of (_d = stored.events) != null ? _d : []) {
+      state2.events.push(event);
+      state2.eventKeys.add(eventKey(event));
     }
-    return state;
+  } catch (e) {
+  }
+  return state2;
 }
-const runtimeStates = runtimeGlobal.__SUPERCOV_MCDC_STATES__ ?? new Map();
+var _a3;
+var runtimeStates = (_a3 = runtimeGlobal.__SUPERCOV_MCDC_STATES__) != null ? _a3 : /* @__PURE__ */ new Map();
 runtimeGlobal.__SUPERCOV_MCDC_STATES__ = runtimeStates;
-const state = runtimeStates.get(runtimeInstance) ?? createState();
+var _a4;
+var state = (_a4 = runtimeStates.get(runtimeInstance)) != null ? _a4 : createState();
 runtimeStates.set(runtimeInstance, state);
 function createServerPhaseStorage() {
-    if (isBrowser || typeof process === "undefined")
-        return undefined;
-    try {
-        const getBuiltinModule = process.getBuiltinModule;
-        const AsyncLocalStorage = getBuiltinModule?.("node:async_hooks")?.AsyncLocalStorage;
-        return AsyncLocalStorage ? new AsyncLocalStorage() : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-const serverPhaseStorages = runtimeGlobal.__SUPERCOV_SERVER_PHASE_STORAGES__ ?? new Map();
+  var _a8;
+  if (isBrowser || typeof process === "undefined")
+    return void 0;
+  try {
+    const getBuiltinModule = process.getBuiltinModule;
+    const AsyncLocalStorage = (_a8 = getBuiltinModule == null ? void 0 : getBuiltinModule("node:async_hooks")) == null ? void 0 : _a8.AsyncLocalStorage;
+    return AsyncLocalStorage ? new AsyncLocalStorage() : void 0;
+  } catch (e) {
+    return void 0;
+  }
+}
+var _a5;
+var serverPhaseStorages = (_a5 = runtimeGlobal.__SUPERCOV_SERVER_PHASE_STORAGES__) != null ? _a5 : /* @__PURE__ */ new Map();
 runtimeGlobal.__SUPERCOV_SERVER_PHASE_STORAGES__ = serverPhaseStorages;
-const serverPhaseStorage = serverPhaseStorages.get(runtimeInstance) ?? createServerPhaseStorage();
+var _a6;
+var serverPhaseStorage = (_a6 = serverPhaseStorages.get(runtimeInstance)) != null ? _a6 : createServerPhaseStorage();
 if (serverPhaseStorage)
-    serverPhaseStorages.set(runtimeInstance, serverPhaseStorage);
+  serverPhaseStorages.set(runtimeInstance, serverPhaseStorage);
 function decisionSnapshot() {
-    return [...state.decisions.values()].map((decision) => ({
-        meta: decision.meta,
-        vectors: [...decision.vectors.values()],
-    }));
-}
-export function coverageSnapshot() {
-    return {
-        decisions: decisionSnapshot(),
-        hits: [...state.hits],
-        events: state.events,
-    };
-}
-export function resetCoverage(testId) {
-    state.decisions.clear();
-    state.hits.clear();
-    state.events.length = 0;
-    state.eventKeys.clear();
-    if (testId)
-        runtimeGlobal.__SUPERCOV_MCDC_TEST_ID__ = testId;
-    if (isBrowser) {
-        try {
-            localStorage.removeItem(storageKey);
-        }
-        catch {
-            // Storage is optional in test environments.
-        }
+  return [...state.decisions.values()].map((decision) => ({
+    meta: decision.meta,
+    vectors: [...decision.vectors.values()]
+  }));
+}
+function coverageSnapshot() {
+  return {
+    decisions: decisionSnapshot(),
+    hits: [...state.hits],
+    events: state.events
+  };
+}
+function resetCoverage(testId2) {
+  state.decisions.clear();
+  state.hits.clear();
+  state.events.length = 0;
+  state.eventKeys.clear();
+  if (testId2)
+    runtimeGlobal.__SUPERCOV_MCDC_TEST_ID__ = testId2;
+  if (isBrowser) {
+    try {
+      localStorage.removeItem(storageKey);
+    } catch (e) {
     }
+  }
 }
 runtimeGlobal.__SUPERCOV_MCDC_SNAPSHOT__ = decisionSnapshot;
 runtimeGlobal.__SUPERCOV_COVERAGE_SNAPSHOT__ = coverageSnapshot;
 runtimeGlobal.__SUPERCOV_RESET__ = resetCoverage;
 function persistBrowser() {
-    if (!isBrowser)
-        return;
-    try {
-        localStorage.setItem(storageKey, JSON.stringify(coverageSnapshot()));
-    }
-    catch {
-        // Coverage persistence is best-effort and must never change app behavior.
-    }
+  if (!isBrowser)
+    return;
+  try {
+    localStorage.setItem(storageKey, JSON.stringify(coverageSnapshot()));
+  } catch (e) {
+  }
 }
 function attemptKey(scope) {
-    return `${scope.runId}\0${scope.workerId}\0${scope.attemptId}`;
+  return `${scope.runId}\0${scope.workerId}\0${scope.attemptId}`;
 }
 function serverRecordKey(record) {
-    const suffix = record.type === "decision"
-        ? `${record.meta.id}:${vectorKey(record.vector)}`
-        : record.id;
-    return `${record.phaseId ?? "unscoped"}:${record.type}:${suffix}`;
-}
-/** Buffer and de-duplicate local Node evidence until its test attempt ends. */
-export function beginBufferedServerEvidence(scope) {
-    if (isBrowser)
-        return;
-    state.bufferedAttempts.add(attemptKey(scope));
-}
-/** Publish one local test attempt with one filesystem append. */
-export function flushBufferedServerEvidence(scope) {
-    if (isBrowser)
-        return;
-    const key = attemptKey(scope);
-    state.bufferedAttempts.delete(key);
-    const buffered = state.serverBuffers.get(key);
-    if (!buffered)
-        return;
-    state.serverBuffers.delete(key);
-    const fs = getFs();
-    if (!fs || buffered.records.size === 0)
-        return;
-    try {
-        fs.mkdirSync(buffered.directory, { recursive: true });
-        fs.appendFileSync(buffered.path, [...buffered.records.values()]
-            .map((record) => JSON.stringify(record))
-            .join("\n") + "\n");
-    }
-    catch {
-        // Collection is best-effort and must never change test behavior.
-    }
-}
-/** A local runner will persist coverageSnapshot(), so avoid duplicate files. */
-export function enableRuntimeSnapshotEvidence() {
-    state.runtimeSnapshots = true;
+  var _a8;
+  const suffix = record.type === "decision" ? `${record.meta.id}:${vectorKey(record.vector)}` : record.id;
+  return `${(_a8 = record.phaseId) != null ? _a8 : "unscoped"}:${record.type}:${suffix}`;
+}
+function beginBufferedServerEvidence(scope) {
+  if (isBrowser)
+    return;
+  state.bufferedAttempts.add(attemptKey(scope));
+}
+function flushBufferedServerEvidence(scope) {
+  if (isBrowser)
+    return;
+  const key = attemptKey(scope);
+  state.bufferedAttempts.delete(key);
+  const buffered = state.serverBuffers.get(key);
+  if (!buffered)
+    return;
+  state.serverBuffers.delete(key);
+  const fs = getFs();
+  if (!fs || buffered.records.size === 0)
+    return;
+  try {
+    fs.mkdirSync(buffered.directory, { recursive: true });
+    fs.appendFileSync(buffered.path, [...buffered.records.values()].map((record) => JSON.stringify(record)).join("\n") + "\n");
+  } catch (e) {
+  }
+}
+function enableRuntimeSnapshotEvidence() {
+  state.runtimeSnapshots = true;
 }
 function flushAllBufferedServerEvidence() {
-    for (const buffered of [...state.serverBuffers.values()])
-        flushBufferedServerEvidence(buffered.scope);
+  for (const buffered of [...state.serverBuffers.values()])
+    flushBufferedServerEvidence(buffered.scope);
 }
-if (!isBrowser) {
-    const flushers = runtimeGlobal.__SUPERCOV_BUFFER_FLUSHERS__ ?? new Set();
-    runtimeGlobal.__SUPERCOV_BUFFER_FLUSHERS__ = flushers;
-    flushers.add(flushAllBufferedServerEvidence);
-    if (!runtimeGlobal.__SUPERCOV_BUFFER_EXIT_INSTALLED__) {
-        process.once("exit", () => {
-            for (const flush of runtimeGlobal.__SUPERCOV_BUFFER_FLUSHERS__ ?? [])
-                flush();
-        });
-        runtimeGlobal.__SUPERCOV_BUFFER_EXIT_INSTALLED__ = true;
+function writeExclusiveBackgroundRecord(fs, runId, writer, initialSequence, payload) {
+  let sequence = initialSequence;
+  for (let attempt = 0; attempt < 1e4; attempt += 1) {
+    const candidate = backgroundEvidencePath(runId, `${writer}-${sequence++}`);
+    try {
+      fs.writeFileSync(candidate, payload, { flag: "wx" });
+      return sequence;
+    } catch (error) {
+      if (error.code === "EEXIST")
+        continue;
+      throw error;
     }
+  }
+  throw Object.assign(new Error("Could not allocate a collision-free Supercov background evidence record"), { code: "SUPERCOV_BACKGROUND_COLLISION_LIMIT" });
+}
+var _a7;
+if (!isBrowser) {
+  const flushers = (_a7 = runtimeGlobal.__SUPERCOV_BUFFER_FLUSHERS__) != null ? _a7 : /* @__PURE__ */ new Set();
+  runtimeGlobal.__SUPERCOV_BUFFER_FLUSHERS__ = flushers;
+  flushers.add(flushAllBufferedServerEvidence);
+  if (!runtimeGlobal.__SUPERCOV_BUFFER_EXIT_INSTALLED__) {
+    process.once("exit", () => {
+      var _a8;
+      for (const flush of (_a8 = runtimeGlobal.__SUPERCOV_BUFFER_FLUSHERS__) != null ? _a8 : [])
+        flush();
+    });
+    runtimeGlobal.__SUPERCOV_BUFFER_EXIT_INSTALLED__ = true;
+  }
 }
 function appendServer(record) {
-    if (state.runtimeSnapshots)
-        return;
-    const fs = getFs();
-    if (!fs)
-        return;
-    const context = currentRequestContext();
-    const scope = context.scope;
-    const runId = scope?.runId ??
-        (typeof process !== "undefined"
-            ? process.env["SUPERCOV_RUN_ID"]
-            : undefined);
-    if (!runId)
-        return;
-    try {
-        const directory = scope
-            ? serverEvidenceDirectory(scope)
-            : backgroundEvidenceDirectory(runId);
-        const path = scope
-            ? serverEvidencePath(scope)
-            : backgroundEvidencePath(runId);
-        const serialized = { ...record, ...(scope ? { scope } : {}) };
-        if (scope && state.bufferedAttempts.has(attemptKey(scope))) {
-            const key = attemptKey(scope);
-            const buffered = state.serverBuffers.get(key) ?? {
-                scope,
-                directory,
-                path,
-                records: new Map(),
-            };
-            buffered.records.set(serverRecordKey(serialized), serialized);
-            state.serverBuffers.set(key, buffered);
-            return;
-        }
-        fs.mkdirSync(directory, { recursive: true });
-        fs.appendFileSync(path, JSON.stringify(serialized) + "\n");
+  var _a8, _b, _c;
+  if (state.runtimeSnapshots)
+    return;
+  const fs = getFs();
+  if (!fs)
+    return;
+  const context = currentRequestContext();
+  const scope = context.scope;
+  const runId = (_a8 = scope == null ? void 0 : scope.runId) != null ? _a8 : typeof process !== "undefined" ? process.env["SUPERCOV_RUN_ID"] : void 0;
+  if (!runId)
+    return;
+  try {
+    const directory = scope ? serverEvidenceDirectory(scope) : backgroundEvidenceDirectory(runId);
+    const path = scope ? serverEvidencePath(scope) : void 0;
+    const serialized = __spreadValues(__spreadValues({}, record), scope ? { scope } : {});
+    if (scope && state.bufferedAttempts.has(attemptKey(scope))) {
+      const key = attemptKey(scope);
+      const buffered = (_b = state.serverBuffers.get(key)) != null ? _b : {
+        scope,
+        directory,
+        path,
+        records: /* @__PURE__ */ new Map()
+      };
+      buffered.records.set(serverRecordKey(serialized), serialized);
+      state.serverBuffers.set(key, buffered);
+      return;
     }
-    catch {
-        // The instrumented build must remain behaviorally identical if collection fails.
+    const deduplicationKey = scope && serialized.phaseId ? `${attemptKey(scope)}:${serverRecordKey(serialized)}` : void 0;
+    if (deduplicationKey && state.persistedServerRecords.has(deduplicationKey))
+      return;
+    fs.mkdirSync(directory, { recursive: true });
+    if (!path) {
+      const shard = (_c = process.env["SUPERCOV_EXECUTION_LOG_SHARD"]) != null ? _c : "process";
+      const writer = `${shard}-${process.pid}`;
+      const payload = JSON.stringify(serialized) + "\n";
+      state.backgroundSequence = writeExclusiveBackgroundRecord(fs, runId, writer, state.backgroundSequence, payload);
+      return;
     }
+    fs.appendFileSync(path, JSON.stringify(serialized) + "\n");
+    if (deduplicationKey)
+      state.persistedServerRecords.add(deduplicationKey);
+  } catch (e) {
+  }
 }
 function environmentRequestContext() {
-    if (isBrowser || typeof process === "undefined")
-        return undefined;
-    const carrier = decodeCoverageCarrier(process.env[COVERAGE_CARRIER_ENV]);
-    return carrier
-        ? {
-            ...(carrier.scope ? { scope: carrier.scope } : {}),
-            ...(carrier.phaseId ? { phaseId: carrier.phaseId } : {}),
-        }
-        : undefined;
+  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;
 }
 function currentRequestContext() {
-    return serverPhaseStorage?.getStore() ?? environmentRequestContext() ?? {};
-}
-export function coverageCarrier() {
-    const context = currentRequestContext();
-    return {
-        version: 1,
-        ...(context.scope ? { scope: context.scope } : {}),
-        ...(context.phaseId ? { phaseId: context.phaseId } : {}),
-    };
-}
-export function withCoverageCarrier(carrier, callback) {
-    const decoded = typeof carrier === "string" ? decodeCoverageCarrier(carrier) : carrier;
-    if (!serverPhaseStorage || !decoded)
-        return callback();
-    return serverPhaseStorage.run({
-        ...(decoded.scope ? { scope: decoded.scope } : {}),
-        ...(decoded.phaseId ? { phaseId: decoded.phaseId } : {}),
-    }, callback);
-}
-export function bindCoverageContext(callback, carrier = coverageCarrier()) {
-    return function boundCoverageContext(...args) {
-        return withCoverageCarrier(carrier, () => Reflect.apply(callback, this, args));
-    };
-}
-export function coverageContextHeaders() {
-    const context = currentRequestContext();
-    if (!context.scope)
-        return {};
-    return {
-        [COVERAGE_SCOPE_HEADER]: encodeCoverageScope(context.scope),
-        ...(context.phaseId
-            ? { [COVERAGE_PHASE_HEADER]: context.phaseId }
-            : {}),
-    };
-}
-export function coverageContextEnvironment() {
-    return { [COVERAGE_CARRIER_ENV]: encodeCoverageCarrier(coverageCarrier()) };
+  var _a8, _b;
+  return (_b = (_a8 = serverPhaseStorage == null ? void 0 : serverPhaseStorage.getStore()) != null ? _a8 : environmentRequestContext()) != null ? _b : {};
+}
+function coverageCarrier() {
+  const context = currentRequestContext();
+  return __spreadValues(__spreadValues({
+    version: 1
+  }, context.scope ? { scope: context.scope } : {}), context.phaseId ? { phaseId: context.phaseId } : {});
+}
+function withCoverageCarrier(carrier, callback) {
+  const decoded = typeof carrier === "string" ? decodeCoverageCarrier(carrier) : carrier;
+  if (!serverPhaseStorage || !decoded)
+    return callback();
+  return serverPhaseStorage.run(__spreadValues(__spreadValues({}, decoded.scope ? { scope: decoded.scope } : {}), decoded.phaseId ? { phaseId: decoded.phaseId } : {}), callback);
+}
+function assertionPhaseState(scope) {
+  const key = attemptKey(scope);
+  const existing = state.assertionPhases.get(key);
+  if (existing)
+    return existing;
+  const created = { counter: 0, phases: [] };
+  state.assertionPhases.set(key, created);
+  return created;
+}
+function finishAssertionPhase(phase, error) {
+  phase.endedAtMs = Date.now();
+  phase.status = error === void 0 ? "passed" : "failed";
+  if (error !== void 0)
+    phase.error = error instanceof Error ? error.message : String(error);
+}
+function withNodeAssertionPhase(operation, source, callback) {
+  const context = currentRequestContext();
+  const scope = context.scope;
+  if (!scope)
+    return callback();
+  const existing = context.phaseId ? assertionPhaseState(scope).phases.find((phase2) => phase2.id === context.phaseId && phase2.kind === "assertion") : void 0;
+  if (existing)
+    return callback();
+  const attempt = assertionPhaseState(scope);
+  const phase = __spreadProps(__spreadValues({
+    id: `${scope.attemptId}:phase:${++attempt.counter}`,
+    kind: "assertion",
+    operation
+  }, source ? { source } : {}), {
+    startedAtMs: Date.now()
+  });
+  attempt.phases.push(phase);
+  try {
+    const result = withCoverageCarrier({ version: 1, scope, phaseId: phase.id }, callback);
+    if (result && typeof result.then === "function")
+      return Promise.resolve(result).then((value) => {
+        finishAssertionPhase(phase);
+        return value;
+      }, (error) => {
+        finishAssertionPhase(phase, error);
+        throw error;
+      });
+    finishAssertionPhase(phase);
+    return result;
+  } catch (error) {
+    finishAssertionPhase(phase, error);
+    throw error;
+  }
+}
+function takeNodeAssertionPhases(scope) {
+  var _a8, _b;
+  const key = attemptKey(scope);
+  const phases = (_b = (_a8 = state.assertionPhases.get(key)) == null ? void 0 : _a8.phases) != null ? _b : [];
+  state.assertionPhases.delete(key);
+  return phases;
+}
+function bindCoverageContext(callback, carrier = coverageCarrier()) {
+  return function boundCoverageContext(...args) {
+    return withCoverageCarrier(carrier, () => Reflect.apply(callback, this, args));
+  };
+}
+function coverageContextHeaders() {
+  const context = currentRequestContext();
+  if (!context.scope)
+    return {};
+  return __spreadValues({
+    [COVERAGE_SCOPE_HEADER]: encodeCoverageScope(context.scope)
+  }, context.phaseId ? { [COVERAGE_PHASE_HEADER]: context.phaseId } : {});
+}
+function coverageContextEnvironment() {
+  return { [COVERAGE_CARRIER_ENV]: encodeCoverageCarrier(coverageCarrier()) };
 }
 function installServerFetchPropagation() {
-    if (isBrowser ||
-        runtimeGlobal.__SUPERCOV_FETCH_PATCHED__ ||
-        typeof globalThis.fetch !== "function")
-        return;
-    const originalFetch = globalThis.fetch.bind(globalThis);
-    globalThis.fetch = ((input, init) => {
-        const coverage = coverageContextHeaders();
-        if (Object.keys(coverage).length === 0)
-            return originalFetch(input, init);
-        const headers = new Headers(init?.headers ?? (input instanceof Request ? input.headers : undefined));
-        for (const [name, value] of Object.entries(coverage))
-            headers.set(name, value);
-        return originalFetch(input, { ...init, headers });
-    });
-    runtimeGlobal.__SUPERCOV_FETCH_PATCHED__ = true;
+  if (isBrowser || runtimeGlobal.__SUPERCOV_FETCH_PATCHED__ || typeof globalThis.fetch !== "function")
+    return;
+  const originalFetch = globalThis.fetch.bind(globalThis);
+  globalThis.fetch = ((input, init) => {
+    var _a8;
+    const coverage = coverageContextHeaders();
+    if (Object.keys(coverage).length === 0)
+      return originalFetch(input, init);
+    const headers = new Headers((_a8 = init == null ? void 0 : init.headers) != null ? _a8 : input instanceof Request ? input.headers : void 0);
+    for (const [name, value] of Object.entries(coverage))
+      headers.set(name, value);
+    return originalFetch(input, __spreadProps(__spreadValues({}, init), { headers }));
+  });
+  runtimeGlobal.__SUPERCOV_FETCH_PATCHED__ = true;
 }
 installServerFetchPropagation();
 function installServerChildPropagation() {
-    if (isBrowser ||
-        runtimeGlobal.__SUPERCOV_CHILD_PATCHED__ ||
-        typeof process === "undefined")
-        return;
-    const getBuiltinModule = process.getBuiltinModule;
-    const child = getBuiltinModule?.("node:child_process");
-    if (!child)
-        return;
-    const mutableChild = child;
-    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] !== undefined)
-                ? 2
-                : 1;
-        return 1;
+  var _a8;
+  if (isBrowser || runtimeGlobal.__SUPERCOV_CHILD_PATCHED__ || typeof process === "undefined")
+    return;
+  const getBuiltinModule = process.getBuiltinModule;
+  const child = getBuiltinModule == null ? void 0 : getBuiltinModule("node:child_process");
+  if (!child)
+    return;
+  const mutableChild = child;
+  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 1;
+  };
+  for (const method of [
+    "exec",
+    "execFile",
+    "execFileSync",
+    "execSync",
+    "fork",
+    "spawn",
+    "spawnSync"
+  ]) {
+    const original = mutableChild[method];
+    if (typeof original !== "function")
+      continue;
+    mutableChild[method] = function(...args) {
+      var _a9;
+      const index = optionIndex(method, args);
+      const existing = args[index] && typeof args[index] === "object" ? args[index] : {};
+      const options = __spreadProps(__spreadValues({}, existing), {
+        env: __spreadValues(__spreadValues(__spreadValues({}, process.env), (_a9 = existing.env) != null ? _a9 : {}), coverageContextEnvironment())
+      });
+      const scoped = [...args];
+      if (typeof scoped[index] === "function")
+        scoped.splice(index, 0, options);
+      else
+        scoped[index] = options;
+      return Reflect.apply(original, child, scoped);
     };
-    for (const method of [
-        "exec",
-        "execFile",
-        "execFileSync",
-        "execSync",
-        "fork",
-        "spawn",
-        "spawnSync",
-    ]) {
-        const original = mutableChild[method];
-        if (typeof original !== "function")
-            continue;
-        mutableChild[method] = function (...args) {
-            const index = optionIndex(method, args);
-            const existing = args[index] && typeof args[index] === "object"
-                ? args[index]
-                : {};
-            const options = {
-                ...existing,
-                env: {
-                    ...process.env,
-                    ...(existing.env ?? {}),
-                    ...coverageContextEnvironment(),
-                },
-            };
-            const scoped = [...args];
-            if (typeof scoped[index] === "function")
-                scoped.splice(index, 0, options);
-            else
-                scoped[index] = options;
-            return Reflect.apply(original, child, scoped);
-        };
-    }
-    const moduleBuiltin = getBuiltinModule?.("node:module");
-    moduleBuiltin?.syncBuiltinESMExports?.();
-    runtimeGlobal.__SUPERCOV_CHILD_PATCHED__ = true;
+  }
+  const moduleBuiltin = getBuiltinModule == null ? void 0 : getBuiltinModule("node:module");
+  (_a8 = moduleBuiltin == null ? void 0 : moduleBuiltin.syncBuiltinESMExports) == null ? void 0 : _a8.call(moduleBuiltin);
+  runtimeGlobal.__SUPERCOV_CHILD_PATCHED__ = true;
 }
 installServerChildPropagation();
 function currentPhaseId() {
-    if (runtimeGlobal.__SUPERCOV_PHASE_ID__)
-        return runtimeGlobal.__SUPERCOV_PHASE_ID__;
-    if (!isBrowser)
-        return currentRequestContext().phaseId;
-    try {
-        const local = localStorage.getItem(phaseStorageKey);
-        if (local)
-            return local;
-        return undefined;
-    }
-    catch {
-        return undefined;
-    }
+  if (runtimeGlobal.__SUPERCOV_PHASE_ID__)
+    return runtimeGlobal.__SUPERCOV_PHASE_ID__;
+  if (!isBrowser)
+    return currentRequestContext().phaseId;
+  try {
+    const local = localStorage.getItem(phaseStorageKey);
+    if (local)
+      return local;
+    return void 0;
+  } catch (e) {
+    return void 0;
+  }
 }
 function requestHeaders(value) {
-    if (!value || typeof value !== "object")
-        return undefined;
-    const directHeaders = value.headers;
-    const request = directHeaders && typeof directHeaders === "object"
-        ? value
-        : value.request;
-    if (!request || typeof request !== "object")
-        return undefined;
-    const headers = request.headers;
-    if (!headers || typeof headers !== "object")
-        return undefined;
-    const get = headers.get;
-    if (typeof get === "function")
-        return {
-            get(name) {
-                return Reflect.apply(get, headers, [name]);
-            },
-        };
-    const values = headers;
-    return Object.keys(values).length > 0
-        ? {
-            get(name) {
-                return values[name] ?? values[name.toLowerCase()];
-            },
-        }
-        : undefined;
-}
-function requestCoverageContext(value) {
-    const headers = requestHeaders(value);
-    if (!headers)
-        return {};
-    const rawCookie = headers.get("cookie");
-    const cookies = new Map();
-    if (typeof rawCookie === "string") {
-        for (const part of rawCookie.split(";")) {
-            const separator = part.indexOf("=");
-            if (separator < 0)
-                continue;
-            const name = part.slice(0, separator).trim();
-            const encoded = part.slice(separator + 1).trim();
-            try {
-                cookies.set(name, decodeURIComponent(encoded));
-            }
-            catch {
-                // Ignore a malformed unrelated cookie.
-            }
-        }
-    }
-    const encodedScope = headers.get(COVERAGE_SCOPE_HEADER) ?? cookies.get(COVERAGE_SCOPE_COOKIE);
-    const rawPhaseId = headers.get(COVERAGE_PHASE_HEADER) ?? cookies.get(COVERAGE_PHASE_COOKIE);
-    const scope = decodeCoverageScope(typeof encodedScope === "string" ? encodedScope : undefined);
-    const phaseId = typeof rawPhaseId === "string" && rawPhaseId.length > 0
-        ? rawPhaseId
-        : undefined;
+  if (!value || typeof value !== "object")
+    return void 0;
+  const directHeaders = value.headers;
+  const request = directHeaders && typeof directHeaders === "object" ? value : value.request;
+  if (!request || typeof request !== "object")
+    return void 0;
+  const headers = request.headers;
+  if (!headers || typeof headers !== "object")
+    return void 0;
+  const get = headers.get;
+  if (typeof get === "function")
     return {
-        ...(scope ? { scope } : {}),
-        ...(phaseId ? { phaseId } : {}),
+      get(name) {
+        return Reflect.apply(get, headers, [name]);
+      }
     };
+  const values = headers;
+  return Object.keys(values).length > 0 ? {
+    get(name) {
+      var _a8;
+      return (_a8 = values[name]) != null ? _a8 : values[name.toLowerCase()];
+    }
+  } : void 0;
 }
-export function withRequestPhase(handler) {
-    if (!serverPhaseStorage)
-        return handler;
-    return function coverageRequestPhase(...args) {
-        const requestContext = args
-            .map((argument) => requestCoverageContext(argument))
-            .find((context) => context.scope || context.phaseId) ?? {};
-        const inheritedContext = currentRequestContext();
-        const context = {
-            ...(requestContext.scope ?? inheritedContext.scope
-                ? { scope: requestContext.scope ?? inheritedContext.scope }
-                : {}),
-            ...(requestContext.phaseId ?? inheritedContext.phaseId
-                ? { phaseId: requestContext.phaseId ?? inheritedContext.phaseId }
-                : {}),
-        };
-        const invoke = () => Reflect.apply(handler, this, args);
-        return context.scope || context.phaseId
-            ? serverPhaseStorage.run(context, invoke)
-            : invoke();
-    };
+function requestCoverageContext(value) {
+  var _a8, _b;
+  const headers = requestHeaders(value);
+  if (!headers)
+    return {};
+  const rawCookie = headers.get("cookie");
+  const cookies = /* @__PURE__ */ new Map();
+  if (typeof rawCookie === "string") {
+    for (const part of rawCookie.split(";")) {
+      const separator = part.indexOf("=");
+      if (separator < 0)
+        continue;
+      const name = part.slice(0, separator).trim();
+      const encoded = part.slice(separator + 1).trim();
+      try {
+        cookies.set(name, decodeURIComponent(encoded));
+      } catch (e) {
+      }
+    }
+  }
+  const encodedScope = (_a8 = headers.get(COVERAGE_SCOPE_HEADER)) != null ? _a8 : cookies.get(COVERAGE_SCOPE_COOKIE);
+  const rawPhaseId = (_b = headers.get(COVERAGE_PHASE_HEADER)) != null ? _b : cookies.get(COVERAGE_PHASE_COOKIE);
+  const scope = decodeCoverageScope(typeof encodedScope === "string" ? encodedScope : void 0);
+  const phaseId = typeof rawPhaseId === "string" && rawPhaseId.length > 0 ? rawPhaseId : void 0;
+  return __spreadValues(__spreadValues({}, scope ? { scope } : {}), phaseId ? { phaseId } : {});
+}
+function withRequestPhase(handler) {
+  if (!serverPhaseStorage)
+    return handler;
+  return function coverageRequestPhase(...args) {
+    var _a8, _b, _c, _d, _e;
+    const requestContext = (_a8 = args.map((argument) => requestCoverageContext(argument)).find((context2) => context2.scope || context2.phaseId)) != null ? _a8 : {};
+    const inheritedContext = currentRequestContext();
+    const context = __spreadValues(__spreadValues({}, ((_b = requestContext.scope) != null ? _b : inheritedContext.scope) ? { scope: (_c = requestContext.scope) != null ? _c : inheritedContext.scope } : {}), ((_d = requestContext.phaseId) != null ? _d : inheritedContext.phaseId) ? { phaseId: (_e = requestContext.phaseId) != null ? _e : inheritedContext.phaseId } : {});
+    const invoke = () => Reflect.apply(handler, this, args);
+    return context.scope || context.phaseId ? serverPhaseStorage.run(context, invoke) : invoke();
+  };
 }
 function eventKey(event) {
-    const suffix = event.type === "decision"
-        ? `${event.id}:${vectorKey(event.vector)}`
-        : event.id;
-    return `${event.phaseId ?? "unscoped"}:${event.type}:${suffix}`;
+  var _a8;
+  const suffix = event.type === "decision" ? `${event.id}:${vectorKey(event.vector)}` : event.id;
+  return `${(_a8 = event.phaseId) != null ? _a8 : "unscoped"}:${event.type}:${suffix}`;
 }
 function recordBrowserEvent(event) {
-    const key = eventKey(event);
-    if (state.eventKeys.has(key))
-        return false;
-    state.eventKeys.add(key);
-    state.events.push(event);
-    return true;
-}
-export function coverageHit(id) {
-    state.hits.add(id);
-    const timestampMs = Date.now();
-    const phaseId = currentPhaseId();
-    if (isBrowser) {
-        if (recordBrowserEvent({
-            type: "hit",
-            id,
-            timestampMs,
-            ...(phaseId ? { phaseId } : {}),
-            environment: "browser",
-        }))
-            persistBrowser();
-    }
-    else {
-        // Request servers retain repeated executions for phase-window correlation.
-        // Local runner adapters explicitly buffer and de-duplicate per test/phase.
-        appendServer({
-            type: "hit",
-            id,
-            timestampMs,
-            ...(phaseId ? { phaseId } : {}),
-        });
-    }
-}
-export function selectionBegin(shortId, rightId) {
-    return { shortId, rightId, rightEvaluated: false };
+  const key = eventKey(event);
+  if (state.eventKeys.has(key))
+    return false;
+  state.eventKeys.add(key);
+  state.events.push(event);
+  return true;
+}
+function coverageHit(id) {
+  state.hits.add(id);
+  const timestampMs = Date.now();
+  const phaseId = currentPhaseId();
+  if (isBrowser) {
+    if (recordBrowserEvent(__spreadProps(__spreadValues({
+      type: "hit",
+      id,
+      timestampMs
+    }, phaseId ? { phaseId } : {}), {
+      environment: "browser"
+    })))
+      persistBrowser();
+  } else {
+    appendServer(__spreadValues({
+      type: "hit",
+      id,
+      timestampMs
+    }, phaseId ? { phaseId } : {}));
+  }
+}
+function selectionBegin(shortId, rightId) {
+  return { shortId, rightId, rightEvaluated: false };
 }
 function applyInferredName(value, inferredName) {
-    if (inferredName &&
-        typeof value === "function" &&
-        value.name === "") {
-        Object.defineProperty(value, "name", {
-            value: inferredName,
-            configurable: true,
-        });
-    }
-    return value;
-}
-export function selectionRight(frame, value, inferredName) {
-    frame.rightEvaluated = true;
-    return applyInferredName(value, inferredName);
-}
-export function selectionEnd(frame, value) {
-    coverageHit(frame.rightEvaluated ? frame.rightId : frame.shortId);
-    return value;
-}
-export function optionalSelect(shortId, continuedId, value) {
-    coverageHit(value === null || value === undefined ? shortId : continuedId);
-    return value;
-}
-export function defaultSelected(defaultId, value, inferredName) {
-    pendingDefaults.set(defaultId, (pendingDefaults.get(defaultId) ?? 0) + 1);
-    return applyInferredName(value, inferredName);
-}
-export function defaultEntered(defaultId, providedId) {
-    const pending = pendingDefaults.get(defaultId) ?? 0;
-    if (pending > 0) {
-        pendingDefaults.set(defaultId, pending - 1);
-        coverageHit(defaultId);
-    }
-    else {
-        coverageHit(providedId);
-    }
-}
-export function tryBegin(successId, catchId) {
-    return { successId, catchId, caught: false };
+  if (inferredName && typeof value === "function" && value.name === "") {
+    Object.defineProperty(value, "name", {
+      value: inferredName,
+      configurable: true
+    });
+  }
+  return value;
 }
-export function tryCatch(frame, value) {
-    frame.caught = true;
-    return value;
+function selectionRight(frame, value, inferredName) {
+  frame.rightEvaluated = true;
+  return applyInferredName(value, inferredName);
 }
-export function tryEnd(frame) {
-    coverageHit(frame.caught ? frame.catchId : frame.successId);
+function selectionEnd(frame, value) {
+  coverageHit(frame.rightEvaluated ? frame.rightId : frame.shortId);
+  return value;
 }
-export function loopBegin(zeroId, enteredId) {
-    return { zeroId, enteredId, entered: false };
+function optionalSelect(shortId, continuedId, value) {
+  coverageHit(value === null || value === void 0 ? shortId : continuedId);
+  return value;
 }
-export function loopEntered(frame) {
-    frame.entered = true;
+function optionalCallBegin(shortId, continuedId) {
+  return { shortId, continuedId, reached: false, continued: false };
 }
-export function loopEnd(frame) {
-    coverageHit(frame.entered ? frame.enteredId : frame.zeroId);
+function optionalCallReached(frame, value) {
+  frame.reached = true;
+  return value;
 }
-export function mcdcBegin(id, meta) {
-    if (!state.decisions.has(id)) {
-        state.decisions.set(id, { meta, vectors: new Map() });
-    }
+var optionalCallEmptySpread = {
+  [Symbol.iterator]() {
     return {
-        meta,
-        values: Array.from({ length: meta.conditions.length }, () => null),
+      next() {
+        return { done: true, value: void 0 };
+      }
     };
-}
-export function mcdcCondition(frame, index, value) {
-    frame.values[index] = Boolean(value);
-    return value;
-}
-export function mcdcEnd(frame, value) {
-    const decision = state.decisions.get(frame.meta.id);
-    if (!decision)
-        return value;
-    const vector = { values: frame.values, outcome: Boolean(value) };
-    const key = vectorKey(vector);
-    decision.vectors.set(key, vector);
-    const timestampMs = Date.now();
-    const phaseId = currentPhaseId();
-    if (isBrowser) {
-        if (recordBrowserEvent({
-            type: "decision",
-            id: decision.meta.id,
-            vector,
-            timestampMs,
-            ...(phaseId ? { phaseId } : {}),
-            environment: "browser",
-        }))
-            persistBrowser();
-    }
-    else {
-        appendServer({
-            type: "decision",
-            meta: decision.meta,
-            vector,
-            timestampMs,
-            ...(phaseId ? { phaseId } : {}),
-        });
-    }
+  }
+};
+function optionalCallContinued(frame) {
+  frame.continued = true;
+  return optionalCallEmptySpread;
+}
+function optionalCallEnd(frame, value) {
+  if (frame.reached)
+    coverageHit(frame.continued ? frame.continuedId : frame.shortId);
+  return value;
+}
+function defaultSelected(defaultId, value, inferredName) {
+  var _a8;
+  pendingDefaults.set(defaultId, ((_a8 = pendingDefaults.get(defaultId)) != null ? _a8 : 0) + 1);
+  return applyInferredName(value, inferredName);
+}
+function defaultEntered(defaultId, providedId) {
+  var _a8;
+  const pending = (_a8 = pendingDefaults.get(defaultId)) != null ? _a8 : 0;
+  if (pending > 0) {
+    pendingDefaults.set(defaultId, pending - 1);
+    coverageHit(defaultId);
+  } else {
+    coverageHit(providedId);
+  }
+}
+function tryBegin(successId, catchId) {
+  return { successId, catchId, caught: false };
+}
+function tryCatch(frame, value) {
+  frame.caught = true;
+  return value;
+}
+function tryEnd(frame) {
+  coverageHit(frame.caught ? frame.catchId : frame.successId);
+}
+function loopBegin(zeroId, enteredId) {
+  return { zeroId, enteredId, entered: false };
+}
+function loopEntered(frame) {
+  frame.entered = true;
+}
+function loopEnd(frame) {
+  coverageHit(frame.entered ? frame.enteredId : frame.zeroId);
+}
+function mcdcBegin(id, meta) {
+  if (!state.decisions.has(id)) {
+    state.decisions.set(id, { meta, vectors: /* @__PURE__ */ new Map() });
+  }
+  return {
+    meta,
+    values: Array.from({ length: meta.conditions.length }, () => null)
+  };
+}
+function mcdcCondition(frame, index, value) {
+  frame.values[index] = Boolean(value);
+  return value;
+}
+function mcdcEnd(frame, value) {
+  const decision = state.decisions.get(frame.meta.id);
+  if (!decision)
     return value;
-}
-//# sourceMappingURL=runtime.js.map
+  const vector = { values: frame.values, outcome: Boolean(value) };
+  const key = vectorKey(vector);
+  decision.vectors.set(key, vector);
+  const timestampMs = Date.now();
+  const phaseId = currentPhaseId();
+  if (isBrowser) {
+    if (recordBrowserEvent(__spreadProps(__spreadValues({
+      type: "decision",
+      id: decision.meta.id,
+      vector,
+      timestampMs
+    }, phaseId ? { phaseId } : {}), {
+      environment: "browser"
+    })))
+      persistBrowser();
+  } else {
+    appendServer(__spreadValues({
+      type: "decision",
+      meta: decision.meta,
+      vector,
+      timestampMs
+    }, phaseId ? { phaseId } : {}));
+  }
+  return value;
+}
+export {
+  beginBufferedServerEvidence,
+  bindCoverageContext,
+  coverageCarrier,
+  coverageContextEnvironment,
+  coverageContextHeaders,
+  coverageHit,
+  coverageSnapshot,
+  defaultEntered,
+  defaultSelected,
+  enableRuntimeSnapshotEvidence,
+  flushBufferedServerEvidence,
+  loopBegin,
+  loopEnd,
+  loopEntered,
+  mcdcBegin,
+  mcdcCondition,
+  mcdcEnd,
+  optionalCallBegin,
+  optionalCallContinued,
+  optionalCallEnd,
+  optionalCallReached,
+  optionalSelect,
+  resetCoverage,
+  selectionBegin,
+  selectionEnd,
+  selectionRight,
+  takeNodeAssertionPhases,
+  tryBegin,
+  tryCatch,
+  tryEnd,
+  withCoverageCarrier,
+  withNodeAssertionPhase,
+  withRequestPhase,
+  writeExclusiveBackgroundRecord
+};