supercov 0.0.8 → 0.0.11

package/dist/runtime.js

@@ -102,10 +102,10 @@ 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}`;
+  return `${serverRunEvidenceDirectory(scope.runId, root)}/attempts`;
 }
 function serverEvidencePath(scope, root = configuredServerEvidenceRoot()) {
-  return `${serverEvidenceDirectory(scope, root)}/server.jsonl`;
+  return `${serverEvidenceDirectory(scope, root)}/${pathComponent(scope.attemptId)}.jsonl`;
 }
 function backgroundEvidenceDirectory(runId, root = configuredServerEvidenceRoot()) {
   return `${serverRunEvidenceDirectory(runId, root)}/background`;
@@ -148,8 +148,15 @@ function createState() {
     bufferedAttempts: /* @__PURE__ */ new Set(),
     serverBuffers: /* @__PURE__ */ new Map(),
     persistedServerRecords: /* @__PURE__ */ new Set(),
+    backgroundBuffers: /* @__PURE__ */ new Map(),
     backgroundSequence: 0,
-    runtimeSnapshots: false
+    runtimeSnapshots: false,
+    assertionPhases: /* @__PURE__ */ new Map(),
+    probeV2Files: /* @__PURE__ */ new Set(),
+    probeV2Clock: { epoch: Number.NaN, fast: false },
+    probeV2ContextEpochs: /* @__PURE__ */ new Map(),
+    probeV2NextEpoch: 1,
+    probeV2HookInstalled: false
   };
   if (!isBrowser)
     return state2;
@@ -196,6 +203,83 @@ var _a6;
 var serverPhaseStorage = (_a6 = serverPhaseStorages.get(runtimeInstance)) != null ? _a6 : createServerPhaseStorage();
 if (serverPhaseStorage)
   serverPhaseStorages.set(runtimeInstance, serverPhaseStorage);
+function probeV2ContextKey(context) {
+  var _a8, _b;
+  const phase = (_a8 = context.phaseId) != null ? _a8 : "unscoped";
+  if (!context.scope) {
+    const runId = typeof process !== "undefined" ? process.env["SUPERCOV_RUN_ID"] : void 0;
+    return `background\0${(_b = runId != null ? runId : runtimeGlobal.__SUPERCOV_MCDC_TEST_ID__) != null ? _b : testId}\0${phase}`;
+  }
+  return `scope\0${attemptKey(context.scope)}\0${phase}`;
+}
+function activateProbeV2Key(key, force = false) {
+  let epoch = force ? void 0 : state.probeV2ContextEpochs.get(key);
+  if (epoch === void 0) {
+    state.probeV2NextEpoch += 1;
+    if (state.probeV2NextEpoch >= 4294967295) {
+      state.probeV2NextEpoch = 1;
+      state.probeV2ContextEpochs.clear();
+      for (const file of state.probeV2Files) {
+        file.hitEpochs.fill(0);
+        file.decisionObservationEpochs.fill(0);
+        file.decisionObservationCounts.fill(0);
+        file.decisionCompleteEpochs.fill(0);
+        for (const vectors of file.decisionEpochs) {
+          if (vectors instanceof Uint32Array)
+            vectors.fill(0);
+          else
+            vectors.clear();
+        }
+      }
+    }
+    epoch = state.probeV2NextEpoch;
+    state.probeV2ContextEpochs.set(key, epoch);
+  }
+  state.probeV2Clock.epoch = epoch;
+  return epoch;
+}
+function activateProbeV2Context(context) {
+  return activateProbeV2Key(probeV2ContextKey(context));
+}
+function withProbeV2Context(context, callback) {
+  const previous = state.probeV2Clock.epoch;
+  activateProbeV2Context(context);
+  try {
+    return callback();
+  } finally {
+    state.probeV2Clock.epoch = previous;
+  }
+}
+function installProbeV2AsyncHook() {
+  var _a8;
+  if (isBrowser || state.probeV2HookInstalled || typeof process === "undefined")
+    return;
+  try {
+    const getBuiltinModule = process.getBuiltinModule;
+    const createHook = (_a8 = getBuiltinModule == null ? void 0 : getBuiltinModule("node:async_hooks")) == null ? void 0 : _a8.createHook;
+    if (!createHook)
+      return;
+    const epochs = [];
+    createHook({
+      before() {
+        var _a9, _b;
+        epochs.push(state.probeV2Clock.epoch);
+        activateProbeV2Context((_b = (_a9 = serverPhaseStorage == null ? void 0 : serverPhaseStorage.getStore()) != null ? _a9 : environmentRequestContext()) != null ? _b : {});
+      },
+      after() {
+        var _a9;
+        state.probeV2Clock.epoch = (_a9 = epochs.pop()) != null ? _a9 : state.probeV2Clock.epoch;
+      }
+    }).enable();
+    state.probeV2HookInstalled = true;
+    state.probeV2Clock.fast = true;
+  } catch (e) {
+  }
+}
+runtimeGlobal.__SUPERCOV_ACTIVATE_PROBE_CONTEXT__ = (browserTestId, browserPhaseId) => {
+  state.probeV2Clock.fast = true;
+  activateProbeV2Key(`browser\0${browserTestId}\0${browserPhaseId != null ? browserPhaseId : "unscoped"}`);
+};
 function decisionSnapshot() {
   return [...state.decisions.values()].map((decision) => ({
     meta: decision.meta,
@@ -214,6 +298,8 @@ function resetCoverage(testId2) {
   state.hits.clear();
   state.events.length = 0;
   state.eventKeys.clear();
+  state.probeV2ContextEpochs.clear();
+  activateProbeV2Key(`reset\0${state.probeV2NextEpoch}`, true);
   if (testId2)
     runtimeGlobal.__SUPERCOV_MCDC_TEST_ID__ = testId2;
   if (isBrowser) {
@@ -245,24 +331,34 @@ function serverRecordKey(record) {
 function beginBufferedServerEvidence(scope) {
   if (isBrowser)
     return;
-  state.bufferedAttempts.add(attemptKey(scope));
+  const key = attemptKey(scope);
+  state.bufferedAttempts.add(key);
+  if (!state.serverBuffers.has(key))
+    state.serverBuffers.set(key, {
+      scope,
+      directory: serverEvidenceDirectory(scope),
+      path: serverEvidencePath(scope),
+      records: /* @__PURE__ */ new Map()
+    });
 }
 function flushBufferedServerEvidence(scope) {
   if (isBrowser)
-    return;
+    return void 0;
   const key = attemptKey(scope);
   state.bufferedAttempts.delete(key);
   const buffered = state.serverBuffers.get(key);
   if (!buffered)
-    return;
+    return void 0;
   state.serverBuffers.delete(key);
   const fs = getFs();
   if (!fs || buffered.records.size === 0)
-    return;
+    return void 0;
   try {
     fs.mkdirSync(buffered.directory, { recursive: true });
     fs.appendFileSync(buffered.path, [...buffered.records.values()].map((record) => JSON.stringify(record)).join("\n") + "\n");
+    return buffered.path;
   } catch (e) {
+    return void 0;
   }
 }
 function enableRuntimeSnapshotEvidence() {
@@ -271,6 +367,32 @@ function enableRuntimeSnapshotEvidence() {
 function flushAllBufferedServerEvidence() {
   for (const buffered of [...state.serverBuffers.values()])
     flushBufferedServerEvidence(buffered.scope);
+  for (const runId of [...state.backgroundBuffers.keys()])
+    flushBufferedBackgroundEvidence(runId);
+}
+function flushBufferedBackgroundEvidence(runId) {
+  var _a8;
+  if (isBrowser)
+    return void 0;
+  const records = state.backgroundBuffers.get(runId);
+  if (!records || records.size === 0)
+    return void 0;
+  const fs = getFs();
+  if (!fs)
+    return void 0;
+  const directory = backgroundEvidenceDirectory(runId);
+  const shard = (_a8 = process.env["SUPERCOV_EXECUTION_LOG_SHARD"]) != null ? _a8 : "process";
+  const writer = `${shard}-${process.pid}`;
+  const payload = [...records.values()].map((record) => JSON.stringify(record)).join("\n") + "\n";
+  try {
+    fs.mkdirSync(directory, { recursive: true });
+    const nextSequence = writeExclusiveBackgroundRecord(fs, runId, writer, state.backgroundSequence, payload);
+    state.backgroundSequence = nextSequence;
+    state.backgroundBuffers.delete(runId);
+    return backgroundEvidencePath(runId, `${writer}-${nextSequence - 1}`);
+  } catch (e) {
+    return void 0;
+  }
 }
 function writeExclusiveBackgroundRecord(fs, runId, writer, initialSequence, payload) {
   let sequence = initialSequence;
@@ -302,24 +424,44 @@ if (!isBrowser) {
   }
 }
 function appendServer(record) {
-  var _a8, _b, _c;
-  if (state.runtimeSnapshots)
+  var _a8, _b, _c, _d;
+  if (state.runtimeSnapshots) {
+    const timestampMs = (_a8 = record.timestampMs) != null ? _a8 : Date.now();
+    if (record.type === "decision") {
+      recordBrowserEvent(__spreadProps(__spreadValues({
+        type: "decision",
+        id: record.meta.id,
+        vector: record.vector,
+        timestampMs
+      }, record.phaseId ? { phaseId: record.phaseId } : {}), {
+        environment: "server"
+      }));
+    } else {
+      recordBrowserEvent(__spreadProps(__spreadValues({
+        type: "hit",
+        id: record.id,
+        timestampMs
+      }, record.phaseId ? { phaseId: record.phaseId } : {}), {
+        environment: "server"
+      }));
+    }
     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;
+  const runId = (_b = scope == null ? void 0 : scope.runId) != null ? _b : typeof process !== "undefined" ? process.env["SUPERCOV_RUN_ID"] : void 0;
   if (!runId)
     return;
   try {
-    const directory = scope ? serverEvidenceDirectory(scope) : backgroundEvidenceDirectory(runId);
+    const directory = scope ? serverEvidenceDirectory(scope) : void 0;
     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 : {
+      const buffered = (_c = state.serverBuffers.get(key)) != null ? _c : {
         scope,
         directory,
         path,
@@ -332,14 +474,15 @@ function appendServer(record) {
     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);
+      const buffered = (_d = state.backgroundBuffers.get(runId)) != null ? _d : /* @__PURE__ */ new Map();
+      buffered.set(serverRecordKey(serialized), serialized);
+      state.backgroundBuffers.set(runId, buffered);
+      if (buffered.size >= 4096)
+        flushBufferedBackgroundEvidence(runId);
       return;
     }
+    fs.mkdirSync(directory, { recursive: true });
     fs.appendFileSync(path, JSON.stringify(serialized) + "\n");
     if (deduplicationKey)
       state.persistedServerRecords.add(deduplicationKey);
@@ -353,8 +496,23 @@ function environmentRequestContext() {
   return carrier ? __spreadValues(__spreadValues({}, carrier.scope ? { scope: carrier.scope } : {}), carrier.phaseId ? { phaseId: carrier.phaseId } : {}) : void 0;
 }
 function currentRequestContext() {
-  var _a8, _b;
-  return (_b = (_a8 = serverPhaseStorage == null ? void 0 : serverPhaseStorage.getStore()) != null ? _a8 : environmentRequestContext()) != null ? _b : {};
+  const stored = serverPhaseStorage == null ? void 0 : serverPhaseStorage.getStore();
+  if (stored !== void 0) {
+    if (stored.scope || stored.phaseId)
+      return stored;
+    return runtimeGlobal.__SUPERCOV_ACTIVE_SCOPE__ ? { scope: runtimeGlobal.__SUPERCOV_ACTIVE_SCOPE__ } : {};
+  }
+  const environment = environmentRequestContext();
+  if ((environment == null ? void 0 : environment.scope) || (environment == null ? void 0 : environment.phaseId))
+    return environment;
+  return runtimeGlobal.__SUPERCOV_ACTIVE_SCOPE__ ? { scope: runtimeGlobal.__SUPERCOV_ACTIVE_SCOPE__ } : {};
+}
+function activateCoverageScope(scope) {
+  if (scope)
+    runtimeGlobal.__SUPERCOV_ACTIVE_SCOPE__ = scope;
+  else
+    delete runtimeGlobal.__SUPERCOV_ACTIVE_SCOPE__;
+  activateProbeV2Context(scope ? { scope } : {});
 }
 function coverageCarrier() {
   const context = currentRequestContext();
@@ -366,7 +524,68 @@ 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);
+  const context = __spreadValues(__spreadValues({}, decoded.scope ? { scope: decoded.scope } : {}), decoded.phaseId ? { phaseId: decoded.phaseId } : {});
+  return serverPhaseStorage.run(context, () => withProbeV2Context(context, 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) {
+  var _a8;
+  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 bridged = (_a8 = runtimeGlobal.__SUPERCOV_ASSERTION_PHASE_BRIDGE__) == null ? void 0 : _a8.call(runtimeGlobal, operation, source, callback);
+  if (bridged == null ? void 0 : bridged.handled)
+    return bridged.value;
+  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);
+  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) {
@@ -490,7 +709,7 @@ function requestCoverageContext(value) {
   var _a8, _b;
   const headers = requestHeaders(value);
   if (!headers)
-    return {};
+    return void 0;
   const rawCookie = headers.get("cookie");
   const cookies = /* @__PURE__ */ new Map();
   if (typeof rawCookie === "string") {
@@ -516,12 +735,12 @@ 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 } : {});
+    var _a8, _b, _c, _d;
+    const requestContext = args.map((argument) => requestCoverageContext(argument)).find((context2) => context2 !== void 0);
+    const inheritedContext = 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 = () => Reflect.apply(handler, this, args);
-    return context.scope || context.phaseId ? serverPhaseStorage.run(context, invoke) : invoke();
+    return requestContext !== void 0 || context.scope || context.phaseId ? serverPhaseStorage.run(context, () => withProbeV2Context(context, invoke)) : invoke();
   };
 }
 function eventKey(event) {
@@ -558,6 +777,109 @@ function coverageHit(id) {
     }, phaseId ? { phaseId } : {}));
   }
 }
+function registerProbeV2(definition) {
+  var _a8, _b;
+  const file = {
+    decisions: definition.decisions,
+    pointIds: definition.pointIds,
+    clock: state.probeV2Clock,
+    hitEpochs: new Uint32Array(definition.pointIds.length),
+    decisionEpochs: definition.decisions.map((meta) => meta.conditions.length <= 6 ? new Uint32Array(2 * 3 ** meta.conditions.length) : /* @__PURE__ */ new Map()),
+    decisionVectorCounts: definition.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)
+  };
+  state.probeV2Files.add(file);
+  if (isBrowser) {
+    state.probeV2Clock.fast = true;
+    activateProbeV2Key(`browser\0${(_a8 = runtimeGlobal.__SUPERCOV_MCDC_TEST_ID__) != null ? _a8 : testId}\0${(_b = runtimeGlobal.__SUPERCOV_PHASE_ID__) != null ? _b : "unscoped"}`);
+  } else {
+    installProbeV2AsyncHook();
+  }
+  return file;
+}
+function coverageHitV2(file, index) {
+  const id = file.pointIds[index];
+  if (!id)
+    return;
+  const fallbackEpoch = !file.clock.fast;
+  const previousEpoch = file.clock.epoch;
+  if (fallbackEpoch)
+    activateProbeV2Context(currentRequestContext());
+  try {
+    const epoch = file.clock.epoch;
+    if (file.hitEpochs[index] === epoch)
+      return;
+    file.hitEpochs[index] = epoch;
+    coverageHit(id);
+  } finally {
+    if (fallbackEpoch)
+      file.clock.epoch = previousEpoch;
+  }
+}
+function decodeProbeV2Vector(conditionCount, encoded, outcome) {
+  if (!Number.isSafeInteger(conditionCount) || conditionCount < 0 || conditionCount > 32 || !Number.isSafeInteger(encoded) || encoded < 0)
+    return void 0;
+  const values = [];
+  let remaining = encoded;
+  for (let index = 0; index < conditionCount; index += 1) {
+    const digit = remaining % 3;
+    values.push(digit === 0 ? null : digit === 2);
+    remaining = Math.floor(remaining / 3);
+  }
+  return remaining === 0 ? { values, outcome } : void 0;
+}
+function mcdcEndV2(file, decisionIndex, encoded, value) {
+  var _a8, _b;
+  const meta = file.decisions[decisionIndex];
+  if (!meta || !Number.isSafeInteger(encoded) || encoded < 0)
+    return value;
+  const outcome = Boolean(value);
+  const vectorIndex = encoded * 2 + (outcome ? 1 : 0);
+  if (!Number.isSafeInteger(vectorIndex))
+    return value;
+  const fallbackEpoch = !file.clock.fast;
+  const previousEpoch = file.clock.epoch;
+  if (fallbackEpoch)
+    activateProbeV2Context(currentRequestContext());
+  try {
+    const epoch = file.clock.epoch;
+    const seen = file.decisionEpochs[decisionIndex];
+    if (!seen)
+      return value;
+    if (seen instanceof Uint32Array) {
+      if (seen[vectorIndex] === epoch)
+        return value;
+      seen[vectorIndex] = epoch;
+    } else {
+      if (seen.get(vectorIndex) === epoch)
+        return value;
+      seen.set(vectorIndex, epoch);
+    }
+    const expectedCount = (_a8 = file.decisionVectorCounts[decisionIndex]) != null ? _a8 : 0;
+    if (expectedCount > 0) {
+      if (file.decisionObservationEpochs[decisionIndex] !== epoch) {
+        file.decisionObservationEpochs[decisionIndex] = epoch;
+        file.decisionObservationCounts[decisionIndex] = 0;
+      }
+      const observedCount = ((_b = file.decisionObservationCounts[decisionIndex]) != null ? _b : 0) + 1;
+      file.decisionObservationCounts[decisionIndex] = observedCount;
+      if (observedCount >= expectedCount)
+        file.decisionCompleteEpochs[decisionIndex] = epoch;
+    }
+    if (!state.decisions.has(meta.id))
+      state.decisions.set(meta.id, { meta, vectors: /* @__PURE__ */ new Map() });
+    const vector = decodeProbeV2Vector(meta.conditions.length, encoded, outcome);
+    return vector ? mcdcEnd({ meta, values: vector.values }, value) : value;
+  } finally {
+    if (fallbackEpoch)
+      file.clock.epoch = previousEpoch;
+  }
+}
 function selectionBegin(shortId, rightId) {
   return { shortId, rightId, rightEvaluated: false };
 }
@@ -570,6 +892,15 @@ function applyInferredName(value, inferredName) {
   }
   return value;
 }
+var hostNamesParenthesizedAssignments = (() => {
+  let candidate;
+  candidate = function() {
+  };
+  return candidate.name === "candidate";
+})();
+function parenthesizedAssignmentValue(value, inferredName) {
+  return hostNamesParenthesizedAssignments ? applyInferredName(value, inferredName) : value;
+}
 function selectionRight(frame, value, inferredName) {
   frame.rightEvaluated = true;
   return applyInferredName(value, inferredName);
@@ -582,6 +913,31 @@ function optionalSelect(shortId, continuedId, value) {
   coverageHit(value === null || value === void 0 ? shortId : continuedId);
   return value;
 }
+function optionalCallBegin(shortId, continuedId) {
+  return { shortId, continuedId, reached: false, continued: false };
+}
+function optionalCallReached(frame, value) {
+  frame.reached = true;
+  return value;
+}
+var optionalCallEmptySpread = {
+  [Symbol.iterator]() {
+    return {
+      next() {
+        return { done: true, value: void 0 };
+      }
+    };
+  }
+};
+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);
@@ -659,16 +1015,20 @@ function mcdcEnd(frame, value) {
   return value;
 }
 export {
+  activateCoverageScope,
   beginBufferedServerEvidence,
   bindCoverageContext,
   coverageCarrier,
   coverageContextEnvironment,
   coverageContextHeaders,
   coverageHit,
+  coverageHitV2,
   coverageSnapshot,
+  decodeProbeV2Vector,
   defaultEntered,
   defaultSelected,
   enableRuntimeSnapshotEvidence,
+  flushBufferedBackgroundEvidence,
   flushBufferedServerEvidence,
   loopBegin,
   loopEnd,
@@ -676,15 +1036,24 @@ export {
   mcdcBegin,
   mcdcCondition,
   mcdcEnd,
+  mcdcEndV2,
+  optionalCallBegin,
+  optionalCallContinued,
+  optionalCallEnd,
+  optionalCallReached,
   optionalSelect,
+  parenthesizedAssignmentValue,
+  registerProbeV2,
   resetCoverage,
   selectionBegin,
   selectionEnd,
   selectionRight,
+  takeNodeAssertionPhases,
   tryBegin,
   tryCatch,
   tryEnd,
   withCoverageCarrier,
+  withNodeAssertionPhase,
   withRequestPhase,
   writeExclusiveBackgroundRecord
 };